rec.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. #include "rec.h"
  2. #include "crc.h"
  3. #include "w25qxx.h"
  4. #include "string.h"
  5. #include "main.h"
  6. #define FLASH_RETRY_TIMES 3
  7. // 状态定义
  8. #define RECORD_STATUS_VALID 0xff00 // 有效记录
  9. #define RECORD_STATUS_INVALID 0xffff // 无效记录(未使用)
  10. #define RECORD_STATUS_DELETED 0x0000 // 已删除
  11. typedef struct __attribute__((packed))
  12. {
  13. uint16_t status; // 记录状态
  14. uint16_t crc; // 数据CRC校验
  15. rec_data_t data;
  16. uint8_t rvs[28 - sizeof(rec_data_t)];
  17. } record_t;
  18. static struct
  19. {
  20. uint16_t write_addr; // 下一个写入地址
  21. uint16_t total_count;
  22. uint16_t count; // 当前有效记录数量
  23. rec_data_t rec_last;
  24. uint16_t crc;
  25. } rec_state;
  26. static uint8_t rec_buf[4096];
  27. // 内部函数声明
  28. int read_record(int index, record_t *out_rec);
  29. // 带重试的Flash写函数
  30. int flash_write_with_retry(uint8_t *pBuffer, uint32_t SectorAddress, uint32_t WriteAddr, uint32_t NumByteToWrite)
  31. {
  32. static uint8_t write_verify_buf[4096];
  33. for (int i = 0; i < FLASH_RETRY_TIMES; i++)
  34. {
  35. W25qxx_WriteSector(pBuffer, SectorAddress, WriteAddr, NumByteToWrite);
  36. HAL_Delay(10); // 短暂延时
  37. // 验证写入结果
  38. W25qxx_ReadSector(write_verify_buf, SectorAddress, WriteAddr, NumByteToWrite);
  39. if (memcmp(pBuffer, write_verify_buf, NumByteToWrite) == 0)
  40. {
  41. return 0; // 成功
  42. }
  43. }
  44. return -1; // 失败
  45. }
  46. // 带重试的Flash擦除函数(扇区)
  47. int flash_erase_with_retry(uint32_t sector)
  48. {
  49. uint8_t erase_verify_buf[64];
  50. for (int i = 0; i < FLASH_RETRY_TIMES; i++)
  51. {
  52. W25qxx_EraseSector(sector);
  53. // 验证是否全为 0xFF
  54. W25qxx_ReadSector(erase_verify_buf, sector, 0, sizeof(erase_verify_buf));
  55. int all_ff = 1;
  56. for (int j = 0; j < sizeof(erase_verify_buf); j++)
  57. {
  58. if (erase_verify_buf[j] != 0xFF)
  59. {
  60. all_ff = 0;
  61. break;
  62. }
  63. }
  64. if (all_ff)
  65. {
  66. return 0;
  67. }
  68. HAL_Delay(10);
  69. }
  70. return -1;
  71. }
  72. int rec_init(void)
  73. {
  74. record_t *rec;
  75. if (!W25qxx_Init())
  76. {
  77. return -1; // Flash 初始化失败
  78. }
  79. memset(&rec_state, 0, sizeof(rec_state));
  80. W25qxx_ReadSector(rec_buf, RECORD_FLASH_SECTOR, 0, sizeof(rec_buf));
  81. for (int i = 0; i < RECORD_MAX_COUNT; i++)
  82. {
  83. rec = (record_t *)&rec_buf[i * sizeof(record_t)];
  84. if (rec->status == RECORD_STATUS_VALID || rec->status == RECORD_STATUS_DELETED)
  85. {
  86. uint16_t calc_crc = CRC16((uint8_t *)&rec->data, sizeof(rec_data_t));
  87. if (calc_crc == rec->crc)
  88. {
  89. if (rec->status == RECORD_STATUS_VALID)
  90. {
  91. rec_state.count++;
  92. }
  93. rec_state.total_count++;
  94. memcpy(&rec_state.rec_last, &rec->data, sizeof(rec_data_t));
  95. }
  96. }
  97. else if (rec->status == RECORD_STATUS_INVALID)
  98. {
  99. break;
  100. }
  101. rec_state.write_addr = (i + 1) * sizeof(record_t); // 更新写入地址为下一个位置
  102. }
  103. rec_state.crc = CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2);
  104. return 0;
  105. }
  106. int rec_write(const rec_data_t *data)
  107. {
  108. record_t rec;
  109. if (rec_state.crc != CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2))
  110. {
  111. rec_init();
  112. }
  113. rec.status = RECORD_STATUS_VALID;
  114. memcpy(&rec.data, data, sizeof(rec_data_t));
  115. rec.crc = CRC16((uint8_t *)&rec.data, sizeof(rec_data_t));
  116. // 当有效记录数达到最大值时,触发整理并移除最旧的记录
  117. if (rec_state.count >= RECORD_MAX_COUNT || (rec_state.write_addr + sizeof(record_t)) > RECORD_MAX_COUNT * sizeof(record_t))
  118. {
  119. uint16_t write_offset = 0; // 新的写入位置偏移
  120. uint16_t valid_count = 0; // 有效记录计数
  121. uint16_t total_valid = 0; // 总有效记录数
  122. // 第一次遍历:计算总有效记录数
  123. for (int i = 0; i < RECORD_MAX_COUNT; i++)
  124. {
  125. record_t* src_rec = (record_t*)&rec_buf[i * sizeof(record_t)];
  126. if (src_rec->status == RECORD_STATUS_VALID)
  127. {
  128. uint16_t calc_crc = CRC16((uint8_t *)&src_rec->data, sizeof(rec_data_t));
  129. if (calc_crc == src_rec->crc)
  130. {
  131. total_valid++;
  132. }
  133. }
  134. }
  135. // 计算需要跳过的旧记录数量
  136. int16_t skip_count = 0;
  137. if (total_valid >= RECORD_MAX_COUNT)
  138. {
  139. skip_count = total_valid - RECORD_MAX_COUNT + 1; // 需要跳过最旧的一条记录, 2026-04-14 NiuJiuRu 修改
  140. valid_count = RECORD_MAX_COUNT;
  141. }
  142. else
  143. {
  144. valid_count = total_valid;
  145. }
  146. // 第二次遍历:将需要保留的记录移动到rec_buf开头
  147. uint16_t valid_index = 0;
  148. for (int i = 0; i < RECORD_MAX_COUNT && valid_index < valid_count; i++)
  149. {
  150. record_t* src_rec = (record_t*)&rec_buf[i * sizeof(record_t)];
  151. if (src_rec->status == RECORD_STATUS_VALID)
  152. {
  153. uint16_t calc_crc = CRC16((uint8_t *)&src_rec->data, sizeof(rec_data_t));
  154. if (calc_crc == src_rec->crc)
  155. {
  156. // 如果需要跳过旧记录,则先跳过
  157. if (skip_count > 0)
  158. {
  159. skip_count--;
  160. continue;
  161. }
  162. // 将记录移动到开头位置
  163. if (i * sizeof(record_t) != write_offset)
  164. {
  165. memcpy(&rec_buf[write_offset], src_rec, sizeof(record_t));
  166. }
  167. write_offset += sizeof(record_t);
  168. valid_index++;
  169. }
  170. }
  171. }
  172. // 擦除扇区
  173. if (flash_erase_with_retry(RECORD_FLASH_SECTOR) != 0)
  174. {
  175. return -2;
  176. }
  177. // 清空整理后的剩余空间
  178. memset(&rec_buf[write_offset], 0xFF, sizeof(rec_buf) - write_offset);
  179. // 写回整理后的rec_buf(使用重试机制)
  180. if (write_offset > 0)
  181. {
  182. if (flash_write_with_retry(rec_buf, RECORD_FLASH_SECTOR, 0, write_offset) != 0)
  183. {
  184. return -3;
  185. }
  186. }
  187. // 更新状态
  188. rec_state.write_addr = write_offset;
  189. rec_state.count = valid_index;
  190. rec_state.total_count = valid_index;
  191. }
  192. // 使用带重试的写入
  193. if (flash_write_with_retry((uint8_t *)&rec, RECORD_FLASH_SECTOR, rec_state.write_addr, sizeof(record_t)) != 0)
  194. {
  195. rec_state.write_addr += sizeof(record_t);
  196. rec_state.crc = CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2);
  197. return -1;
  198. }
  199. // 更新缓冲区和状态
  200. memcpy(rec_buf + rec_state.write_addr, &rec, sizeof(record_t));
  201. rec_state.write_addr += sizeof(record_t);
  202. rec_state.count++;
  203. rec_state.total_count++;
  204. memcpy(&rec_state.rec_last, &rec.data, sizeof(rec_data_t));
  205. rec_state.crc = CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2);
  206. return 0;
  207. }
  208. int rec_read(uint16_t start_index, uint16_t *out_index, rec_data_t *data_out)
  209. {
  210. record_t rec;
  211. if (rec_state.crc != CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2))
  212. {
  213. rec_init();
  214. }
  215. for (int i = start_index; i < RECORD_MAX_COUNT; i++)
  216. {
  217. if (read_record(i, &rec) != 0)
  218. {
  219. continue;
  220. }
  221. // 校验CRC和状态
  222. uint16_t calc_crc = CRC16((uint8_t *)&rec.data, sizeof(rec_data_t));
  223. if (calc_crc == rec.crc && rec.status == RECORD_STATUS_VALID)
  224. {
  225. if (out_index != NULL)
  226. {
  227. *out_index = i; // 输出找到的第一条有效记录的索引
  228. }
  229. if (data_out != NULL)
  230. {
  231. memcpy(data_out, &rec.data, sizeof(rec_data_t)); // 拷贝有效数据到输出缓冲区
  232. }
  233. return 0; // 成功找到并返回第一条有效记录
  234. }
  235. else if (rec.status == RECORD_STATUS_INVALID)
  236. {
  237. break;
  238. }
  239. }
  240. return -1; // 没有找到有效记录
  241. }
  242. int rec_delete(uint16_t index)
  243. {
  244. if (index >= RECORD_MAX_COUNT)
  245. {
  246. return -1; // 索引越界
  247. }
  248. if (rec_state.crc != CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2))
  249. {
  250. rec_init();
  251. }
  252. record_t rec;
  253. if (read_record(index, &rec) != 0)
  254. {
  255. return -2; // 读取失败
  256. }
  257. // 如果已经是删除状态,则直接返回
  258. if (rec.status == RECORD_STATUS_DELETED)
  259. {
  260. return 0;
  261. }
  262. rec.status = RECORD_STATUS_DELETED;
  263. if (flash_write_with_retry((uint8_t *)&rec,
  264. RECORD_FLASH_SECTOR,
  265. index * sizeof(record_t),
  266. sizeof(record_t)) != 0)
  267. {
  268. return -3; // 写入失败
  269. }
  270. // 更新缓冲区
  271. memcpy(rec_buf + index * sizeof(record_t), &rec, sizeof(record_t));
  272. // 更新计数器
  273. if (rec_state.count > 0)
  274. {
  275. rec_state.count--;
  276. rec_state.crc = CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2);
  277. }
  278. return 0;
  279. }
  280. uint16_t rec_get_count(void)
  281. {
  282. return rec_state.count;
  283. }
  284. int rec_get_last(rec_data_t *data_out)
  285. {
  286. if (rec_state.crc != CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2))
  287. {
  288. if (rec_init() != 0)
  289. {
  290. return -1;
  291. }
  292. }
  293. if (rec_state.total_count < 1)
  294. {
  295. return -2;
  296. }
  297. memcpy(data_out, &rec_state.rec_last, sizeof(rec_data_t));
  298. return 0;
  299. }
  300. int rec_clear_all(void)
  301. {
  302. if (flash_erase_with_retry(RECORD_FLASH_SECTOR) != 0)
  303. {
  304. return -1;
  305. }
  306. memset(&rec_state, 0, sizeof(rec_state));
  307. rec_state.crc = CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2);
  308. memset(rec_buf, 0xff, sizeof(rec_buf));
  309. return 0;
  310. }
  311. // 从Flash中读取指定索引的记录
  312. int read_record(int index, record_t *out_rec)
  313. {
  314. if (index < 0 || index >= RECORD_MAX_COUNT)
  315. {
  316. return -1; // 无效索引
  317. }
  318. if (rec_state.crc != CRC16((uint8_t *)&rec_state, sizeof(rec_state) - 2))
  319. {
  320. rec_init();
  321. }
  322. memcpy(out_rec, rec_buf + index * sizeof(record_t), sizeof(record_t));
  323. return 0;
  324. }