a8000_subboard_sdk/components/flash/znvs.cpp

#include "znvs.hpp"

#include <string.h>

#include "sdk\components\flash\zsimple_flash.hpp"
#define TAG "config"

#ifdef IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM


using namespace iflytop;
using namespace std;
#define MARK_S 0x123456
#define MARK_E 0x87654321

#define GET_CFG(typename)                                                                 \
  cfg_t* cfg = get_cfg(key);                                                              \
  if (cfg == nullptr || cfg->type != kcfg_type_##typename) {                              \
    allocate_cfg(key, kcfg_type_##typename, (uint8_t*)&default_val, sizeof(default_val)); \
    cfg = get_cfg(key);                                                                   \
  }                                                                                       \
  return *(typename*)cfg->val;

#define SET_CFG(typename)                                                 \
  cfg_t* cfg = get_cfg(key);                                              \
  if (cfg == nullptr || cfg->type != kcfg_type_##typename) {              \
    allocate_cfg(key, kcfg_type_##typename, (uint8_t*)&val, sizeof(val)); \
    cfg = get_cfg(key);                                                   \
  } else {                                                                \
    *(typename*)cfg->val = val;                                           \
    flush();                                                              \
  }

ZNVS& ZNVS::ins() {
  static ZNVS instance;
  return instance;
}
void ZNVS::initialize() {
  zsimple_flash_init(IFLYTOP_NVS_CONFIG_FLASH_SECTOR);
  zsimple_flash_read((uint8_t*)&m_cfg, sizeof(m_cfg));
  if (m_cfg.config_start != MARK_S || m_cfg.config_end != MARK_E) {
    ZLOGW(TAG, "config uninitialized, initialize it");
    memset(&m_cfg, 0, sizeof(m_cfg));
    m_cfg.config_start = MARK_S;
    m_cfg.config_end   = MARK_E;
    zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg));
  } else {
    ZLOGI(TAG, "config initialized");
  }
}

void ZNVS::factory_reset() {
  memset(&m_cfg, 0, sizeof(m_cfg));
  m_cfg.config_start = MARK_S;
  m_cfg.config_end   = MARK_E;
  zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg));
}

ZNVS::cfg_t* ZNVS::get_cfg(const char* key) {
  for (int i = 0; i < IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM; i++) {
    if (strcmp(m_cfg.cfgs[i].key, key) == 0) {
      return &m_cfg.cfgs[i];
    }
  }
  return nullptr;
}

void ZNVS::allocate_cfg(const char* key, type_t type, uint8_t* default_val, uint8_t len) {
  cfg_t* cfg = get_cfg(key);
  for (int i = 0; i < IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM; i++) {
    if (m_cfg.cfgs[i].is_initialed == false) {
      cfg = &m_cfg.cfgs[i];
      strcpy(cfg->key, key);
      cfg->is_initialed = true;
      cfg->type         = (uint8_t)type;
      memcpy(cfg->val, default_val, len);
#if 0
      /**
       * @brief ˢ��flash
       *
       * TODO:�Ż������Ĵ��룬��Ҫÿ�ζ�ˢ��flash
       */
      zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg));
#endif
      break;
    }
  }
}

ZNVS::cfg_t* ZNVS::get_and_create_cfg(const char* key, type_t type, uint8_t* default_val, uint8_t len) {
  cfg_t* cfg = get_cfg(key);
  if (cfg == nullptr) {
    allocate_cfg(key, type, default_val, len);
    cfg = get_cfg(key);
  }
  return cfg;
}

void ZNVS::dumpcfg() {
  ZLOGI(TAG, "=================dump nvs config ==================");
  ZLOGI(TAG, "=");
  for (int i = 0; i < IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM; i++) {
    if (m_cfg.cfgs[i].is_initialed) {
      dumpcfg(&m_cfg.cfgs[i]);
    }
  }
  ZLOGI(TAG, "=============");
}

void ZNVS::dumpcfg(cfg_t* cfg) {
  if (!cfg->is_initialed) return;
  switch (cfg->type) {
    case kcfg_type_int8_t:
      ZLOGI(TAG, "= %s val:%d", cfg->key, *(int8_t*)cfg->val);
      break;
    case kcfg_type_int16_t:
      ZLOGI(TAG, "= %s val:%d", cfg->key, *(int16_t*)cfg->val);
      break;
    case kcfg_type_int32_t:
      ZLOGI(TAG, "= %s val:%d", cfg->key, *(int32_t*)cfg->val);
      break;

    case kcfg_type_uint8_t:
      ZLOGI(TAG, "= %s val:%u", cfg->key, *(int8_t*)cfg->val);
      break;
    case kcfg_type_uint16_t:
      ZLOGI(TAG, "= %s val:%u", cfg->key, *(int16_t*)cfg->val);
      break;
    case kcfg_type_uint32_t:
      ZLOGI(TAG, "= %s val:%u", cfg->key, *(int32_t*)cfg->val);
      break;
    case kcfg_type_float:
      ZLOGI(TAG, "= %s val:%f", cfg->key, *(float*)cfg->val);
      break;
    case kcfg_type_bool:
      ZLOGI(TAG, "= %s val:%d", cfg->key, *(bool*)cfg->val);
      break;
    default:
      ZLOGI(TAG, "= %s val:unknow type", cfg->key);
      break;
  }
  return;
}

int8_t   ZNVS::get_config_int8(const char* key, int8_t default_val) { GET_CFG(int8_t); }
void     ZNVS::set_config_int8(const char* key, int8_t val) { SET_CFG(int8_t); }
uint8_t  ZNVS::get_config_uint8(const char* key, uint8_t default_val) { GET_CFG(uint8_t); }
void     ZNVS::set_config_uint8(const char* key, uint8_t val) { SET_CFG(uint8_t); }
int16_t  ZNVS::get_config_int16(const char* key, int16_t default_val) { GET_CFG(int16_t); }
void     ZNVS::set_config_int16(const char* key, int16_t val) { SET_CFG(int16_t); }
uint16_t ZNVS::get_config_uint16(const char* key, uint16_t default_val) { GET_CFG(uint16_t); }
void     ZNVS::set_config_uint16(const char* key, uint16_t val) { SET_CFG(uint16_t); }
int32_t  ZNVS::get_config_int32(const char* key, int32_t default_val) { GET_CFG(int32_t); }
void     ZNVS::set_config_int32(const char* key, int32_t val) { SET_CFG(int32_t); }
uint32_t ZNVS::get_config_uint32(const char* key, uint32_t default_val) { GET_CFG(uint32_t); }
void     ZNVS::set_config_uint32(const char* key, uint32_t val) { SET_CFG(uint32_t); }
float    ZNVS::get_config_float(const char* key, float default_val) { GET_CFG(float); }
void     ZNVS::set_config_float(const char* key, float val) { SET_CFG(float); }
bool     ZNVS::get_config_bool(const char* key, bool default_val) { GET_CFG(bool); }
void     ZNVS::set_config_bool(const char* key, bool val) { SET_CFG(bool); }

void ZNVS::flush() { zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg)); }

#endif