You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

159 lines
5.8 KiB

2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
  1. #include "znvs.hpp"
  2. #include <string.h>
  3. #include "sdk\components\flash\zsimple_flash.hpp"
  4. #define TAG "config"
  5. using namespace iflytop;
  6. using namespace std;
  7. #define MARK_S 0x123456
  8. #define MARK_E 0x87654321
  9. #define GET_CFG(typename) \
  10. cfg_t* cfg = get_cfg(key); \
  11. if (cfg == nullptr || cfg->type != kcfg_type_##typename) { \
  12. allocate_cfg(key, kcfg_type_##typename, (uint8_t*)&default_val, sizeof(default_val)); \
  13. cfg = get_cfg(key); \
  14. } \
  15. return *(typename*)cfg->val;
  16. #define SET_CFG(typename) \
  17. cfg_t* cfg = get_cfg(key); \
  18. if (cfg == nullptr || cfg->type != kcfg_type_##typename) { \
  19. allocate_cfg(key, kcfg_type_##typename, (uint8_t*)&val, sizeof(val)); \
  20. cfg = get_cfg(key); \
  21. } else { \
  22. *(typename*)cfg->val = val; \
  23. flush(); \
  24. }
  25. ZNVS& ZNVS::ins() {
  26. static ZNVS instance;
  27. return instance;
  28. }
  29. void ZNVS::initialize() {
  30. zsimple_flash_init(IFLYTOP_NVS_CONFIG_FLASH_SECTOR);
  31. zsimple_flash_read((uint8_t*)&m_cfg, sizeof(m_cfg));
  32. if (m_cfg.config_start != MARK_S || m_cfg.config_end != MARK_E) {
  33. ZLOGW(TAG, "config uninitialized, initialize it");
  34. memset(&m_cfg, 0, sizeof(m_cfg));
  35. m_cfg.config_start = MARK_S;
  36. m_cfg.config_end = MARK_E;
  37. zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg));
  38. } else {
  39. ZLOGI(TAG, "config initialized");
  40. }
  41. }
  42. void ZNVS::factory_reset() {
  43. memset(&m_cfg, 0, sizeof(m_cfg));
  44. m_cfg.config_start = MARK_S;
  45. m_cfg.config_end = MARK_E;
  46. zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg));
  47. }
  48. ZNVS::cfg_t* ZNVS::get_cfg(const char* key) {
  49. for (int i = 0; i < IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM; i++) {
  50. if (strcmp(m_cfg.cfgs[i].key, key) == 0) {
  51. return &m_cfg.cfgs[i];
  52. }
  53. }
  54. return nullptr;
  55. }
  56. void ZNVS::allocate_cfg(const char* key, type_t type, uint8_t* default_val, uint8_t len) {
  57. cfg_t* cfg = get_cfg(key);
  58. for (int i = 0; i < IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM; i++) {
  59. if (m_cfg.cfgs[i].is_initialed == false) {
  60. cfg = &m_cfg.cfgs[i];
  61. strcpy(cfg->key, key);
  62. cfg->is_initialed = true;
  63. cfg->type = (uint8_t)type;
  64. memcpy(cfg->val, default_val, len);
  65. #if 0
  66. /**
  67. * @brief ˢflash
  68. *
  69. * TODO:ŻĴҪÿζˢflash
  70. */
  71. zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg));
  72. #endif
  73. break;
  74. }
  75. }
  76. }
  77. ZNVS::cfg_t* ZNVS::get_and_create_cfg(const char* key, type_t type, uint8_t* default_val, uint8_t len) {
  78. cfg_t* cfg = get_cfg(key);
  79. if (cfg == nullptr) {
  80. allocate_cfg(key, type, default_val, len);
  81. cfg = get_cfg(key);
  82. }
  83. return cfg;
  84. }
  85. void ZNVS::dumpcfg() {
  86. ZLOGI(TAG, "=================dump nvs config ==================");
  87. ZLOGI(TAG, "=");
  88. for (int i = 0; i < IFLYTOP_NVS_CONFIG_MAX_ITEM_NUM; i++) {
  89. if (m_cfg.cfgs[i].is_initialed) {
  90. dumpcfg(&m_cfg.cfgs[i]);
  91. }
  92. }
  93. ZLOGI(TAG, "=============");
  94. }
  95. void ZNVS::dumpcfg(cfg_t* cfg) {
  96. if (!cfg->is_initialed) return;
  97. switch (cfg->type) {
  98. case kcfg_type_int8_t:
  99. ZLOGI(TAG, "= %s val:%d", cfg->key, *(int8_t*)cfg->val);
  100. break;
  101. case kcfg_type_int16_t:
  102. ZLOGI(TAG, "= %s val:%d", cfg->key, *(int16_t*)cfg->val);
  103. break;
  104. case kcfg_type_int32_t:
  105. ZLOGI(TAG, "= %s val:%d", cfg->key, *(int32_t*)cfg->val);
  106. break;
  107. case kcfg_type_uint8_t:
  108. ZLOGI(TAG, "= %s val:%u", cfg->key, *(int8_t*)cfg->val);
  109. break;
  110. case kcfg_type_uint16_t:
  111. ZLOGI(TAG, "= %s val:%u", cfg->key, *(int16_t*)cfg->val);
  112. break;
  113. case kcfg_type_uint32_t:
  114. ZLOGI(TAG, "= %s val:%u", cfg->key, *(int32_t*)cfg->val);
  115. break;
  116. case kcfg_type_float:
  117. ZLOGI(TAG, "= %s val:%f", cfg->key, *(float*)cfg->val);
  118. break;
  119. case kcfg_type_bool:
  120. ZLOGI(TAG, "= %s val:%d", cfg->key, *(bool*)cfg->val);
  121. break;
  122. default:
  123. ZLOGI(TAG, "= %s val:unknow type", cfg->key);
  124. break;
  125. }
  126. return;
  127. }
  128. int8_t ZNVS::get_config_int8(const char* key, int8_t default_val) { GET_CFG(int8_t); }
  129. void ZNVS::set_config_int8(const char* key, int8_t val) { SET_CFG(int8_t); }
  130. uint8_t ZNVS::get_config_uint8(const char* key, uint8_t default_val) { GET_CFG(uint8_t); }
  131. void ZNVS::set_config_uint8(const char* key, uint8_t val) { SET_CFG(uint8_t); }
  132. int16_t ZNVS::get_config_int16(const char* key, int16_t default_val) { GET_CFG(int16_t); }
  133. void ZNVS::set_config_int16(const char* key, int16_t val) { SET_CFG(int16_t); }
  134. uint16_t ZNVS::get_config_uint16(const char* key, uint16_t default_val) { GET_CFG(uint16_t); }
  135. void ZNVS::set_config_uint16(const char* key, uint16_t val) { SET_CFG(uint16_t); }
  136. int32_t ZNVS::get_config_int32(const char* key, int32_t default_val) { GET_CFG(int32_t); }
  137. void ZNVS::set_config_int32(const char* key, int32_t val) { SET_CFG(int32_t); }
  138. uint32_t ZNVS::get_config_uint32(const char* key, uint32_t default_val) { GET_CFG(uint32_t); }
  139. void ZNVS::set_config_uint32(const char* key, uint32_t val) { SET_CFG(uint32_t); }
  140. float ZNVS::get_config_float(const char* key, float default_val) { GET_CFG(float); }
  141. void ZNVS::set_config_float(const char* key, float val) { SET_CFG(float); }
  142. bool ZNVS::get_config_bool(const char* key, bool default_val) { GET_CFG(bool); }
  143. void ZNVS::set_config_bool(const char* key, bool val) { SET_CFG(bool); }
  144. void ZNVS::flush() { zsimple_flash_write((uint8_t*)&m_cfg, sizeof(m_cfg)); }