Branch data     Line data    Source code

       1                 :             : // src/persistence_backends.cpp
       2                 :             : 
       3                 :             : #include "esp_log.h"
       4                 :             : // #include "nvs.h"
       5                 :             : // #include "nvs_flash.h"
       6                 :             : 
       7                 :             : #include "persistence_backend.hpp"
       8                 :             : #include "i_hal_nvs.hpp"
       9                 :             : 
      10                 :             : static const char *TAG = "PersistenceBackend";
      11                 :             : static const char *NVS_NAMESPACE = "espnow_store";
      12                 :             : 
      13                 :             : // --- RTC Backend ---
      14                 :             : 
      15                 :           3 : RtcBackend::RtcBackend(void *storage, size_t size)
      16                 :           3 :     : storage_(storage)
      17                 :           3 :     , size_(size)
      18                 :             : {
      19                 :           3 : }
      20                 :             : 
      21                 :           2 : esp_err_t RtcBackend::load(void *data, size_t size)
      22                 :             : {
      23         [ +  + ]:           2 :     if (size > size_) {
      24                 :             :         return ESP_ERR_INVALID_SIZE;
      25                 :             :     }
      26                 :           1 :     memcpy(data, storage_, size);
      27                 :           1 :     return ESP_OK;
      28                 :             : }
      29                 :             : 
      30                 :           2 : esp_err_t RtcBackend::save(const void *data, size_t size)
      31                 :             : {
      32         [ +  + ]:           2 :     if (size > size_) {
      33                 :             :         return ESP_ERR_INVALID_SIZE;
      34                 :             :     }
      35                 :           1 :     memcpy(storage_, data, size);
      36                 :           1 :     return ESP_OK;
      37                 :             : }
      38                 :             : 
      39                 :             : // --- NVS Backend ---
      40                 :             : 
      41                 :          14 : NvsBackend::NvsBackend(INvsHAL &nvs_hal, const char *nvs_key)
      42                 :          14 :     : nvs_(nvs_hal)
      43                 :          14 :     , nvs_key_(nvs_key)
      44                 :             : {
      45                 :          14 : }
      46                 :             : 
      47                 :           5 : esp_err_t NvsBackend::load(void *data, size_t size)
      48                 :             : {
      49                 :           5 :     esp_err_t err = init_nvs();
      50         [ +  + ]:           5 :     if (err != ESP_OK) {
      51                 :             :         return err;
      52                 :             :     }
      53                 :             : 
      54                 :           4 :     nvs_handle_t handle;
      55                 :           4 :     err = nvs_.hal_nvs_open(NVS_NAMESPACE, NVS_READONLY, &handle);
      56         [ +  + ]:           4 :     if (err != ESP_OK) {
      57                 :             :         return err;
      58                 :             :     }
      59                 :             : 
      60                 :           3 :     size_t actual_size = size;
      61                 :           3 :     err = nvs_.hal_nvs_get_blob(handle, nvs_key_, data, &actual_size);
      62                 :           3 :     nvs_.hal_nvs_close(handle);
      63                 :             : 
      64         [ +  + ]:           3 :     if (err != ESP_OK) {
      65                 :             :         return err;
      66                 :             :     }
      67         [ +  + ]:           2 :     if (actual_size != size) {
      68                 :           1 :         return ESP_ERR_INVALID_SIZE;
      69                 :             :     }
      70                 :             : 
      71                 :             :     return ESP_OK;
      72                 :             : }
      73                 :             : 
      74                 :          10 : esp_err_t NvsBackend::save(const void *data, size_t size)
      75                 :             : {
      76                 :          10 :     esp_err_t err = init_nvs();
      77         [ +  + ]:          10 :     if (err != ESP_OK) {
      78                 :             :         return err;
      79                 :             :     }
      80                 :             : 
      81                 :           8 :     nvs_handle_t handle;
      82                 :           8 :     err = nvs_.hal_nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
      83         [ +  + ]:           8 :     if (err != ESP_OK) {
      84                 :             :         return err;
      85                 :             :     }
      86                 :             : 
      87                 :           7 :     err = nvs_.hal_nvs_set_blob(handle, nvs_key_, data, size);
      88         [ +  + ]:           7 :     if (err == ESP_OK) {
      89                 :           6 :         err = nvs_.hal_nvs_commit(handle);
      90                 :             :     }
      91                 :           7 :     nvs_.hal_nvs_close(handle);
      92                 :             : 
      93                 :           7 :     if (err != ESP_OK) {
      94                 :           7 :         ESP_LOGE(TAG, "Failed to save data to NVS: 0x%x", err);
      95                 :             :     }
      96                 :             : 
      97                 :           7 :     return err;
      98                 :             : }
      99                 :             : 
     100                 :          15 : esp_err_t NvsBackend::init_nvs()
     101                 :             : {
     102         [ +  + ]:          15 :     if (nvs_initialized_) {
     103                 :             :         return ESP_OK;
     104                 :             :     }
     105                 :             : 
     106                 :          14 :     esp_err_t err;
     107                 :             : 
     108                 :          14 :     err = nvs_.hal_nvs_flash_init();
     109         [ +  + ]:          14 :     if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
     110                 :           3 :         nvs_.hal_nvs_flash_erase();
     111                 :           3 :         err = nvs_.hal_nvs_flash_init();
     112                 :             :     }
     113         [ +  + ]:          14 :     if (err == ESP_OK) {
     114                 :          11 :         nvs_initialized_ = true;
     115                 :             :     }
     116                 :             :     return err;
     117                 :             : }