param_backup.c 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877
  1. /*
  2. * 参数双分区备份模块实现
  3. *
  4. * 依赖: FAL(param_a / param_b 两个 4KB 分区) + EasyFlash + device_status
  5. * 说明: 本模块不改动 EasyFlash 自身的写入路径,而是在其之上加一层
  6. * "整包快照 + A/B 轮写 + CRC 校验",开机双向修复:
  7. * - EasyFlash 丢了 -> 从快照恢复并回写 EasyFlash
  8. * - 快照丢了/更旧 -> 从 EasyFlash 重建快照
  9. */
  10. #include "param_backup.h"
  11. #include <string.h>
  12. #include <fal.h>
  13. #include <easyflash.h>
  14. #include "control.h"
  15. #define DBG_ENABLE
  16. #define DBG_COLOR
  17. #define DBG_TAG "param"
  18. #define DBG_LVL DBG_LOG
  19. #include <rtdbg.h>
  20. /* device_status 由 control.h 的 extern 声明提供, 唯一定义在 main.c, 本模块只引用 */
  21. /* ===================== 内部状态 ===================== */
  22. static const struct fal_partition *g_part_a = RT_NULL;
  23. static const struct fal_partition *g_part_b = RT_NULL;
  24. static rt_mutex_t g_lock = RT_NULL; /* 保护落盘过程,避免多线程同时擦写 */
  25. static rt_thread_t g_tid = RT_NULL;
  26. static uint8_t g_dirty = 0;
  27. static rt_tick_t g_dirty_tick = 0;
  28. static uint32_t g_last_seq = 0; /* 最近一次成功写入/读出的 seq */
  29. /* ★ 存储不可用(SPI flash 探测失败/分区表建不起来)时置 1。
  30. 此时 mark_dirty / flush 一律直接返回失败, 否则落盘线程会每隔几秒就重试一次
  31. 并打一条 LOG_E, 把串口刷爆, 也让业务线程白等锁。 */
  32. static uint8_t g_disabled = 0;
  33. /* 落盘节流用: 上次成功写入的内容与时刻 */
  34. static param_persist_t g_last_saved;
  35. static uint8_t g_have_saved = 0;
  36. static rt_tick_t g_last_save_tick = 0;
  37. /* ★ 上次落盘**失败**的时刻(0 = 没有待退避的失败)。
  38. flash 真的坏了时, 原来每 PARAM_POLL_TICKS 就会重试一次完整擦写,
  39. 既加速磨损又刷爆串口。失败后退避 PARAM_FAIL_BACKOFF_TICKS 再试。 */
  40. static rt_tick_t g_fail_backoff_tick = 0;
  41. /* 回读校验缓冲,避免占用大栈 */
  42. static uint8_t g_rb_buf[sizeof(param_persist_t)];
  43. /* ★ 静态工作区 —— 极其重要,别改成局部变量!
  44. sizeof(param_persist_t) = 820 字节。两个就是 1640 字节,而
  45. - main 线程栈 RT_MAIN_THREAD_STACK_SIZE = 2048
  46. - 落盘线程栈 = 1024
  47. Check_ParamConfig() 跑在 main 线程,里面放 2 个 param_persist_t
  48. 再调 param_backup_read()(内部又 2 个)栈峰值超过 3.2KB —— 必爆栈 hard fault。
  49. 所以模块内部凡是需要临时 param_persist_t 的地方,一律用这块静态区,
  50. 并且必须在 g_lock 保护下使用(多线程共用)。 */
  51. static param_persist_t g_work;
  52. /* 快照头在分区内的偏移 */
  53. #define PARAM_HDR_SIZE ((uint32_t)sizeof(param_snapshot_hdr_t))
  54. #define PARAM_TOTAL_SIZE (PARAM_HDR_SIZE + (uint32_t)sizeof(param_persist_t))
  55. /* ===================== CRC32 (IEEE 802.3, 多项式 0xEDB88320 反射) ===================== */
  56. static uint32_t crc32_calc(const uint8_t *data, uint32_t len)
  57. {
  58. uint32_t crc = 0xFFFFFFFFu;
  59. uint32_t i, j;
  60. for (i = 0; i < len; i++)
  61. {
  62. crc ^= data[i];
  63. for (j = 0; j < 8; j++)
  64. {
  65. if (crc & 1u)
  66. {
  67. crc = (crc >> 1) ^ 0xEDB88320u;
  68. }
  69. else
  70. {
  71. crc >>= 1;
  72. }
  73. }
  74. }
  75. return crc ^ 0xFFFFFFFFu;
  76. }
  77. /* ===================== 分区槽操作 ===================== */
  78. /* 只读快照头 */
  79. static int slot_read_hdr(const struct fal_partition *part, param_snapshot_hdr_t *hdr)
  80. {
  81. if (part == RT_NULL || hdr == RT_NULL)
  82. {
  83. return -1;
  84. }
  85. memset(hdr, 0, sizeof(*hdr));
  86. if (fal_partition_read(part, 0, (uint8_t *)hdr, PARAM_HDR_SIZE) < 0)
  87. {
  88. return -2;
  89. }
  90. return 0;
  91. }
  92. /* 读一个槽,校验 magic / version / len / crc,全部通过才认为有效 */
  93. static int slot_read(const struct fal_partition *part, param_persist_t *out, uint32_t *seq)
  94. {
  95. param_snapshot_hdr_t hdr;
  96. uint32_t crc;
  97. if (part == RT_NULL || out == RT_NULL)
  98. {
  99. return -1;
  100. }
  101. if (slot_read_hdr(part, &hdr) != 0)
  102. {
  103. return -2;
  104. }
  105. if (hdr.magic != PARAM_MAGIC)
  106. {
  107. return -3; /* 空槽或未格式化 */
  108. }
  109. if (hdr.version != PARAM_VERSION)
  110. {
  111. return -4; /* 固件升级后结构变化,旧快照作废 */
  112. }
  113. if (hdr.len != sizeof(param_persist_t))
  114. {
  115. return -5;
  116. }
  117. if (fal_partition_read(part, PARAM_HDR_SIZE, (uint8_t *)out, hdr.len) < 0)
  118. {
  119. return -6;
  120. }
  121. crc = crc32_calc((const uint8_t *)out, hdr.len);
  122. if (crc != hdr.crc32)
  123. {
  124. LOG_W("[param] %s CRC bad(0x%08x != 0x%08x)", part->name, crc, hdr.crc32);
  125. return -7; /* 写一半掉电,本槽作废,用另一槽 */
  126. }
  127. if (seq)
  128. {
  129. *seq = hdr.seq;
  130. }
  131. return 0;
  132. }
  133. /* 写一个槽: 擦除整区 -> 写头 -> 写体 -> 回读校验 */
  134. static int slot_write(const struct fal_partition *part, const param_persist_t *data, uint32_t seq)
  135. {
  136. param_snapshot_hdr_t hdr;
  137. uint32_t crc;
  138. if (part == RT_NULL || data == RT_NULL)
  139. {
  140. return -1;
  141. }
  142. hdr.magic = PARAM_MAGIC;
  143. hdr.version = PARAM_VERSION;
  144. hdr.seq = seq;
  145. hdr.len = sizeof(param_persist_t);
  146. hdr.crc32 = crc32_calc((const uint8_t *)data, sizeof(param_persist_t));
  147. hdr.reserved = 0;
  148. /* 1. 擦除整个分区(4KB)。此时另一分区仍是上一版完整数据,中断不会两边都毁 */
  149. if (fal_partition_erase_all(part) < 0)
  150. {
  151. LOG_E("[param] erase %s FAILED", part->name);
  152. return -2;
  153. }
  154. /* 2. 写头 */
  155. if (fal_partition_write(part, 0, (const uint8_t *)&hdr, PARAM_HDR_SIZE) < 0)
  156. {
  157. LOG_E("[param] write hdr %s FAILED", part->name);
  158. return -3;
  159. }
  160. /* 3. 写体 */
  161. if (fal_partition_write(part, PARAM_HDR_SIZE, (const uint8_t *)data, hdr.len) < 0)
  162. {
  163. LOG_E("[param] write body %s FAILED", part->name);
  164. return -4;
  165. }
  166. /* 4. 回读校验,确认真的落进去了(NOR 写失败很隐蔽) */
  167. memset(g_rb_buf, 0, sizeof(g_rb_buf));
  168. if (fal_partition_read(part, PARAM_HDR_SIZE, g_rb_buf, hdr.len) < 0)
  169. {
  170. LOG_E("[param] readback %s FAILED", part->name);
  171. return -5;
  172. }
  173. crc = crc32_calc(g_rb_buf, hdr.len);
  174. if (crc != hdr.crc32)
  175. {
  176. LOG_E("[param] readback %s mismatch(0x%08x != 0x%08x)", part->name, crc, hdr.crc32);
  177. return -6;
  178. }
  179. return 0;
  180. }
  181. /* ===================== 对外: 初始化 / 读 / 写 ===================== */
  182. int param_backup_init(void)
  183. {
  184. /* ★ 闸门①: FAL 必须先建表成功。
  185. fal_partition_find() 第一行就是 assert(init_ok), fal_init() 失败时
  186. 它是死循环 —— 2026-09-24 上板实测 "(init_ok) has assert failed at
  187. fal_partition_find." 就是从这里进去的(降级启动分支照常调了本函数)。
  188. 查 fal_init_check() 是最省事也最可靠的门控。 */
  189. if (fal_init_check() != 1)
  190. {
  191. LOG_E("[param] FAL NOT initialized, param backup disabled");
  192. g_disabled = 1;
  193. return -RT_ERROR;
  194. }
  195. /* ★ 闸门②: norflash0 芯片本身要可用。
  196. FAL 建表成功不代表 flash 是好的 —— 为了让 FAL 不被单个坏设备拖垮,
  197. nor_flash0.len 在探测失败时仍保留标称容量(见 fal_flash_sfud_port.c),
  198. 所以分区照样找得到, 但读写一律返回 -1。不在这里闸掉的话, 落盘线程会
  199. 每隔 PARAM_POLL_TICKS 重试一次并打一条 LOG_E, 把串口刷爆。 */
  200. if (!nor_flash0_is_ready())
  201. {
  202. LOG_E("[param] SPI flash NOT ready, param backup disabled");
  203. g_disabled = 1;
  204. return -RT_ERROR;
  205. }
  206. g_part_a = fal_partition_find(PARAM_PART_A_NAME);
  207. g_part_b = fal_partition_find(PARAM_PART_B_NAME);
  208. if (g_part_a == RT_NULL && g_part_b == RT_NULL)
  209. {
  210. LOG_E("[param] partition %s / %s NOT found", PARAM_PART_A_NAME, PARAM_PART_B_NAME);
  211. /* 一个分区都找不到 = SPI flash 不可用(探测失败或分区表没建起来)。
  212. 置 disabled, 后续完全不再尝试落盘。 */
  213. g_disabled = 1;
  214. return -RT_ERROR;
  215. }
  216. g_disabled = 0;
  217. if (g_part_a == RT_NULL || g_part_b == RT_NULL)
  218. {
  219. LOG_W("[param] only one partition found, backup degraded");
  220. }
  221. if (g_lock == RT_NULL)
  222. {
  223. g_lock = rt_mutex_create("param_lk", RT_IPC_FLAG_PRIO);
  224. if (g_lock == RT_NULL)
  225. {
  226. LOG_E("[param] create mutex FAILED");
  227. return -RT_ENOMEM;
  228. }
  229. }
  230. /* 上电先摸清当前有效快照的 seq,后续写入在其基础上递增。
  231. 这里只关心 seq,payload 直接复用静态工作区(不占栈)。 */
  232. {
  233. uint32_t sa = 0, sb = 0, ra, rb;
  234. if (g_lock != RT_NULL)
  235. {
  236. rt_mutex_take(g_lock, RT_WAITING_FOREVER);
  237. }
  238. ra = (g_part_a != RT_NULL) ? slot_read(g_part_a, &g_work, &sa) : -1;
  239. rb = (g_part_b != RT_NULL) ? slot_read(g_part_b, &g_work, &sb) : -1;
  240. if (g_lock != RT_NULL)
  241. {
  242. rt_mutex_release(g_lock);
  243. }
  244. if (ra == 0 && rb == 0)
  245. {
  246. g_last_seq = (sa > sb) ? sa : sb;
  247. }
  248. else if (ra == 0)
  249. {
  250. g_last_seq = sa;
  251. }
  252. else if (rb == 0)
  253. {
  254. g_last_seq = sb;
  255. }
  256. else
  257. {
  258. g_last_seq = 0;
  259. }
  260. LOG_I("[param] init ok. A=%s(seq %u) B=%s(seq %u)",
  261. (ra == 0) ? "ok" : "bad", (unsigned)sa,
  262. (rb == 0) ? "ok" : "bad", (unsigned)sb);
  263. }
  264. return RT_EOK;
  265. }
  266. int param_backup_read(param_persist_t *out, uint32_t *seq)
  267. {
  268. uint32_t sa = 0, sb = 0;
  269. int ra, rb, ret = -2;
  270. if (out == RT_NULL)
  271. {
  272. return -1;
  273. }
  274. /* g_work 是多线程共用的静态区,必须加锁 */
  275. if (g_lock != RT_NULL)
  276. {
  277. rt_mutex_take(g_lock, RT_WAITING_FOREVER);
  278. }
  279. /* 只用一个缓冲: 先读 A 槽,再读 B 槽,谁 seq 大谁是最终赢家。
  280. 这样 820 字节的 param_persist_t 只出现一次,且不在栈上。 */
  281. ra = (g_part_a != RT_NULL) ? slot_read(g_part_a, &g_work, &sa) : -1;
  282. if (ra == 0)
  283. {
  284. *out = g_work;
  285. if (seq) *seq = sa;
  286. ret = 0;
  287. }
  288. rb = (g_part_b != RT_NULL) ? slot_read(g_part_b, &g_work, &sb) : -1;
  289. if (rb == 0 && (ra != 0 || sb > sa))
  290. {
  291. *out = g_work;
  292. if (seq) *seq = sb;
  293. ret = 0;
  294. }
  295. if (g_lock != RT_NULL)
  296. {
  297. rt_mutex_release(g_lock);
  298. }
  299. return ret; /* -2 = 两槽都无效 */
  300. }
  301. int param_backup_write(const param_persist_t *in)
  302. {
  303. const struct fal_partition *target = RT_NULL; /* ★ 显式初始化, 配合下面的空指针兜底 */
  304. param_snapshot_hdr_t ha, hb;
  305. uint32_t sa = 0, sb = 0, next_seq;
  306. int ra = -1, rb = -1, ret;
  307. if (in == RT_NULL)
  308. {
  309. return -1;
  310. }
  311. if (g_part_a == RT_NULL && g_part_b == RT_NULL)
  312. {
  313. return -2;
  314. }
  315. if (g_lock != RT_NULL)
  316. {
  317. rt_mutex_take(g_lock, RT_WAITING_FOREVER);
  318. }
  319. /* 只举手之劳读头,判断哪一槽更旧 */
  320. if (g_part_a != RT_NULL)
  321. {
  322. if (slot_read_hdr(g_part_a, &ha) == 0 && ha.magic == PARAM_MAGIC
  323. && ha.version == PARAM_VERSION && ha.len == sizeof(param_persist_t))
  324. {
  325. sa = ha.seq;
  326. ra = 0;
  327. }
  328. }
  329. if (g_part_b != RT_NULL)
  330. {
  331. if (slot_read_hdr(g_part_b, &hb) == 0 && hb.magic == PARAM_MAGIC
  332. && hb.version == PARAM_VERSION && hb.len == sizeof(param_persist_t))
  333. {
  334. sb = hb.seq;
  335. rb = 0;
  336. }
  337. }
  338. /* 优先写"无效或更旧"的槽,保证另一槽始终是上一版可用数据 */
  339. if (ra != 0 && g_part_a != RT_NULL)
  340. {
  341. target = g_part_a;
  342. next_seq = (rb == 0) ? (sb + 1) : (g_last_seq + 1);
  343. }
  344. else if (rb != 0 && g_part_b != RT_NULL)
  345. {
  346. target = g_part_b;
  347. next_seq = sa + 1;
  348. }
  349. else
  350. {
  351. target = (sa <= sb) ? g_part_a : g_part_b;
  352. next_seq = ((sa > sb) ? sa : sb) + 1;
  353. }
  354. /* ★ 单分区降级(param_a / param_b 只建起来一个)时, 上面两个分支可能把
  355. target 指到那个为 NULL 的分区, 紧接着 target->name 就是空指针解引用
  356. -> 多数情况直接 Bus Fault; 躲过去也是"参数永远存不进去"
  357. (下面 LOG 前也做了判空)。这里补一道兜底。 */
  358. if (target == RT_NULL)
  359. {
  360. target = (g_part_a != RT_NULL) ? g_part_a : g_part_b;
  361. }
  362. if (target == RT_NULL)
  363. {
  364. LOG_E("[param] no usable partition, save aborted");
  365. if (g_lock != RT_NULL)
  366. {
  367. rt_mutex_release(g_lock);
  368. }
  369. return -RT_ERROR;
  370. }
  371. /* seq 必须严格递增,防止回绕后被误判为旧数据 */
  372. if (next_seq <= g_last_seq)
  373. {
  374. next_seq = g_last_seq + 1;
  375. }
  376. if (next_seq == 0)
  377. {
  378. next_seq = 1;
  379. }
  380. ret = slot_write(target, in, next_seq);
  381. if (ret == 0)
  382. {
  383. g_last_seq = next_seq;
  384. LOG_D("[param] saved to %s, seq=%u", target->name, (unsigned)next_seq);
  385. }
  386. else
  387. {
  388. LOG_E("[param] save to %s FAILED(%d)", target->name, ret);
  389. }
  390. if (g_lock != RT_NULL)
  391. {
  392. rt_mutex_release(g_lock);
  393. }
  394. return ret;
  395. }
  396. /* ===================== device_status <-> param_persist_t ===================== */
  397. void param_pack(param_persist_t *dst)
  398. {
  399. if (dst == RT_NULL)
  400. {
  401. return;
  402. }
  403. memset(dst, 0, sizeof(*dst));
  404. dst->iSave = device_status.iSave;
  405. dst->dtype = device_status.dtype;
  406. dst->version_type = device_status.version_type;
  407. dst->Power_Type = device_status.Power_Type;
  408. dst->ds = device_status.ds;
  409. dst->timeSwitch = device_status.timeSwitch;
  410. dst->run_sta = device_status.run_sta;
  411. dst->cul_time = device_status.cul_time;
  412. dst->motor_active = device_status.motor_active;
  413. dst->heat_sw = device_status.heat_sw;
  414. dst->cold_sw = device_status.cold_sw;
  415. dst->wind_sw = device_status.wind_sw;
  416. dst->collecting_sh1 = device_status.collecting_sh1;
  417. dst->collecting_eh1 = device_status.collecting_eh1;
  418. dst->collecting_sh2 = device_status.collecting_sh2;
  419. dst->collecting_eh2 = device_status.collecting_eh2;
  420. dst->handle_bugger = device_status.handle_bugger;
  421. dst->work_mode = device_status.work_mode;
  422. dst->shake_ws = device_status.shake_ws;
  423. dst->tph = device_status.tph;
  424. dst->tpl = device_status.tpl;
  425. dst->clt_time = device_status.clt_time;
  426. dst->heattime = device_status.heattime;
  427. dst->heatvalue = device_status.heatvalue;
  428. dst->sunBar = device_status.sunBar;
  429. dst->startBar = device_status.startBar;
  430. dst->stopBar = device_status.stopBar;
  431. dst->vol = device_status.vol;
  432. dst->stop_in_bootloader = device_status.stop_in_bootloader;
  433. dst->update_flag = device_status.update_flag;
  434. dst->dattim = device_status.dattim;
  435. dst->shake_sec = device_status.shake_sec;
  436. dst->thsp = device_status.thsp;
  437. dst->passWord = device_status.passWord;
  438. dst->rebootcnt = device_status.rebootcnt;
  439. strncpy(dst->tempture, device_status.tempture, sizeof(dst->tempture) - 1);
  440. strncpy(dst->humidity, device_status.humidity, sizeof(dst->humidity) - 1);
  441. strncpy(dst->mqttcfg1, device_status.mqttcfg1, sizeof(dst->mqttcfg1) - 1);
  442. strncpy(dst->deviceId, device_status.deviceId, sizeof(dst->deviceId) - 1);
  443. strncpy(dst->imei, device_status.imei, sizeof(dst->imei) - 1);
  444. strncpy(dst->iccid, device_status.iccid, sizeof(dst->iccid) - 1);
  445. strncpy(dst->lat, device_status.lat, sizeof(dst->lat) - 1);
  446. strncpy(dst->lng, device_status.lng, sizeof(dst->lng) - 1);
  447. strncpy(dst->alarm_tg, device_status.alarm_tg, sizeof(dst->alarm_tg) - 1);
  448. strncpy(dst->driver_bl, device_status.driver_bl, sizeof(dst->driver_bl) - 1);
  449. strncpy(dst->driver_compile, device_status.driver_compile, sizeof(dst->driver_compile) - 1);
  450. }
  451. void param_unpack(const param_persist_t *src)
  452. {
  453. if (src == RT_NULL)
  454. {
  455. return;
  456. }
  457. device_status.iSave = src->iSave;
  458. device_status.dtype = src->dtype;
  459. device_status.version_type = src->version_type;
  460. device_status.Power_Type = src->Power_Type;
  461. device_status.ds = src->ds;
  462. device_status.timeSwitch = src->timeSwitch;
  463. device_status.run_sta = src->run_sta;
  464. device_status.cul_time = src->cul_time;
  465. device_status.motor_active = src->motor_active;
  466. device_status.heat_sw = src->heat_sw;
  467. device_status.cold_sw = src->cold_sw;
  468. device_status.wind_sw = src->wind_sw;
  469. device_status.collecting_sh1 = src->collecting_sh1;
  470. device_status.collecting_eh1 = src->collecting_eh1;
  471. device_status.collecting_sh2 = src->collecting_sh2;
  472. device_status.collecting_eh2 = src->collecting_eh2;
  473. device_status.handle_bugger = src->handle_bugger;
  474. device_status.work_mode = src->work_mode;
  475. device_status.shake_ws = src->shake_ws;
  476. device_status.tph = src->tph;
  477. device_status.tpl = src->tpl;
  478. device_status.clt_time = src->clt_time;
  479. device_status.heattime = src->heattime;
  480. device_status.heatvalue = src->heatvalue;
  481. device_status.sunBar = src->sunBar;
  482. device_status.startBar = src->startBar;
  483. device_status.stopBar = src->stopBar;
  484. device_status.vol = src->vol;
  485. device_status.stop_in_bootloader = src->stop_in_bootloader;
  486. device_status.update_flag = src->update_flag;
  487. device_status.dattim = src->dattim;
  488. device_status.shake_sec = src->shake_sec;
  489. device_status.thsp = src->thsp;
  490. device_status.passWord = src->passWord;
  491. device_status.rebootcnt = src->rebootcnt;
  492. strncpy(device_status.tempture, src->tempture, sizeof(device_status.tempture) - 1);
  493. strncpy(device_status.humidity, src->humidity, sizeof(device_status.humidity) - 1);
  494. strncpy(device_status.mqttcfg1, src->mqttcfg1, sizeof(device_status.mqttcfg1) - 1);
  495. strncpy(device_status.deviceId, src->deviceId, sizeof(device_status.deviceId) - 1);
  496. strncpy(device_status.imei, src->imei, sizeof(device_status.imei) - 1);
  497. strncpy(device_status.iccid, src->iccid, sizeof(device_status.iccid) - 1);
  498. strncpy(device_status.lat, src->lat, sizeof(device_status.lat) - 1);
  499. strncpy(device_status.lng, src->lng, sizeof(device_status.lng) - 1);
  500. strncpy(device_status.alarm_tg, src->alarm_tg, sizeof(device_status.alarm_tg) - 1);
  501. strncpy(device_status.driver_bl, src->driver_bl, sizeof(device_status.driver_bl) - 1);
  502. strncpy(device_status.driver_compile, src->driver_compile, sizeof(device_status.driver_compile) - 1);
  503. }
  504. int param_write_back_to_easyflash(const param_persist_t *src)
  505. {
  506. int n = 0;
  507. if (src == RT_NULL)
  508. {
  509. return 0;
  510. }
  511. /* 与 param_check_health / Check_ParamConfig 读取的 key 一一对应 */
  512. n += (ef_set_env_blob("iSave", &src->iSave, sizeof(src->iSave)) == EF_NO_ERR);
  513. n += (ef_set_env_blob("ds", &src->ds, sizeof(src->ds)) == EF_NO_ERR);
  514. n += (ef_set_env_blob("stime", &src->clt_time, sizeof(src->clt_time)) == EF_NO_ERR);
  515. n += (ef_set_env_blob("startBar", &src->startBar, sizeof(src->startBar)) == EF_NO_ERR);
  516. n += (ef_set_env_blob("stopBar", &src->stopBar, sizeof(src->stopBar)) == EF_NO_ERR);
  517. n += (ef_set_env_blob("timeSwitch", &src->timeSwitch, sizeof(src->timeSwitch)) == EF_NO_ERR);
  518. n += (ef_set_env_blob("sunBar", &src->sunBar, sizeof(src->sunBar)) == EF_NO_ERR);
  519. n += (ef_set_env_blob("jtime", &src->heattime, sizeof(src->heattime)) == EF_NO_ERR);
  520. n += (ef_set_env_blob("jheat", &src->heatvalue, sizeof(src->heatvalue)) == EF_NO_ERR);
  521. n += (ef_set_env_blob("tph", &src->tph, sizeof(src->tph)) == EF_NO_ERR);
  522. n += (ef_set_env_blob("tpl", &src->tpl, sizeof(src->tpl)) == EF_NO_ERR);
  523. n += (ef_set_env_blob("shake_ws", &src->shake_ws, sizeof(src->shake_ws)) == EF_NO_ERR);
  524. n += (ef_set_env_blob("shake_sec", &src->shake_sec, sizeof(src->shake_sec)) == EF_NO_ERR);
  525. n += (ef_set_env_blob("thsp", &src->thsp, sizeof(src->thsp)) == EF_NO_ERR);
  526. n += (ef_set_env_blob("passWord", &src->passWord, sizeof(src->passWord)) == EF_NO_ERR);
  527. n += (ef_set_env_blob("dattim", &src->dattim, sizeof(src->dattim)) == EF_NO_ERR);
  528. n += (ef_set_env_blob("version_type", &src->version_type, sizeof(src->version_type)) == EF_NO_ERR);
  529. n += (ef_set_env_blob("dtype", &src->dtype, sizeof(src->dtype)) == EF_NO_ERR);
  530. n += (ef_set_env_blob("env_t", src->tempture, sizeof(src->tempture)) == EF_NO_ERR);
  531. n += (ef_set_env_blob("env_h", src->humidity, sizeof(src->humidity)) == EF_NO_ERR);
  532. n += (ef_set_env_blob("platform", src->mqttcfg1, sizeof(src->mqttcfg1)) == EF_NO_ERR);
  533. n += (ef_set_env_blob("cul_time", &src->cul_time, sizeof(src->cul_time)) == EF_NO_ERR);
  534. n += (ef_set_env_blob("motor_active", &src->motor_active, sizeof(src->motor_active)) == EF_NO_ERR);
  535. n += (ef_set_env_blob("heat_sw", &src->heat_sw, sizeof(src->heat_sw)) == EF_NO_ERR);
  536. n += (ef_set_env_blob("cold_sw", &src->cold_sw, sizeof(src->cold_sw)) == EF_NO_ERR);
  537. n += (ef_set_env_blob("collecting_sh1", &src->collecting_sh1, sizeof(src->collecting_sh1)) == EF_NO_ERR);
  538. n += (ef_set_env_blob("collecting_eh1", &src->collecting_eh1, sizeof(src->collecting_eh1)) == EF_NO_ERR);
  539. n += (ef_set_env_blob("collecting_sh2", &src->collecting_sh2, sizeof(src->collecting_sh2)) == EF_NO_ERR);
  540. n += (ef_set_env_blob("collecting_eh2", &src->collecting_eh2, sizeof(src->collecting_eh2)) == EF_NO_ERR);
  541. n += (ef_set_env_blob("run_sta", &src->run_sta, sizeof(src->run_sta)) == EF_NO_ERR);
  542. n += (ef_set_env_blob("Power_Type", &src->Power_Type, sizeof(src->Power_Type)) == EF_NO_ERR);
  543. n += (ef_set_env_blob("deviceId", src->deviceId, sizeof(src->deviceId)) == EF_NO_ERR);
  544. n += (ef_set_env_blob("handle_bugger",&src->handle_bugger,sizeof(src->handle_bugger))== EF_NO_ERR);
  545. n += (ef_set_env_blob("work_mode", &src->work_mode, sizeof(src->work_mode)) == EF_NO_ERR);
  546. n += (ef_set_env_blob("alarm_tg", src->alarm_tg, sizeof(src->alarm_tg)) == EF_NO_ERR);
  547. n += (ef_set_env_blob("imei", src->imei, sizeof(src->imei)) == EF_NO_ERR);
  548. n += (ef_set_env_blob("iccid", src->iccid, sizeof(src->iccid)) == EF_NO_ERR);
  549. n += (ef_set_env_blob("lat", src->lat, sizeof(src->lat)) == EF_NO_ERR);
  550. n += (ef_set_env_blob("lng", src->lng, sizeof(src->lng)) == EF_NO_ERR);
  551. n += (ef_set_env_blob("driver_bl", src->driver_bl, sizeof(src->driver_bl)) == EF_NO_ERR);
  552. n += (ef_set_env_blob("reboot_time", &src->rebootcnt, sizeof(src->rebootcnt)) == EF_NO_ERR);
  553. n += (ef_set_env_blob("vol", &src->vol, sizeof(src->vol)) == EF_NO_ERR);
  554. return n;
  555. }
  556. int param_check_health(const param_persist_t *p)
  557. {
  558. int err = 0;
  559. if (p == RT_NULL)
  560. {
  561. return -1;
  562. }
  563. if (p->iSave != 2) /* FLASH_FLAG == 2 */
  564. {
  565. err |= PARAM_ERR_ISAVE;
  566. }
  567. if (p->tph == 0) { err |= PARAM_ERR_TPH; }
  568. if (p->thsp == 0) { err |= PARAM_ERR_THSP; }
  569. if (p->dattim == 0) { err |= PARAM_ERR_DATTIM; }
  570. if (p->sunBar == 0) { err |= PARAM_ERR_SUNBAR; }
  571. if (p->clt_time == 0) { err |= PARAM_ERR_CLTIME; }
  572. if (p->heattime == 0) { err |= PARAM_ERR_HEATTIME; }
  573. if (p->heatvalue == 0) { err |= PARAM_ERR_HEATVALUE; }
  574. return err;
  575. }
  576. /* ===================== 延迟落盘 ===================== */
  577. void param_mark_dirty(void)
  578. {
  579. /* 故意不加锁: 这里只写两个对齐的字长变量,Cortex-M3 上单字读写本身是原子的。
  580. 加锁反而会让业务线程在落盘线程擦写 4KB 的 ~100ms 里被卡住。 */
  581. if (g_disabled)
  582. {
  583. return; /* 存储不可用,别让落盘线程反复重试 */
  584. }
  585. g_dirty_tick = rt_tick_get();
  586. g_dirty = 1;
  587. }
  588. /* force==0: 走节流(内容相同不写 / 最小间隔内推迟)
  589. force!=0: 立即写,跳过节流 */
  590. static int param_flush_impl(int force)
  591. {
  592. int ret;
  593. if (g_disabled)
  594. {
  595. return -2; /* 存储不可用: 静默失败,不重试不刷屏 */
  596. }
  597. /* 本函数可能被业务线程(恢复出厂等)和落盘线程同时调用,
  598. g_work 是共用静态区,所以全程持锁。
  599. 注: RT-Thread 的 mutex 支持同线程递归 take(hold++),
  600. 因此下面再调 param_backup_write() 内部加锁不会死锁。 */
  601. if (g_lock != RT_NULL)
  602. {
  603. rt_mutex_take(g_lock, RT_WAITING_FOREVER);
  604. }
  605. param_pack(&g_work);
  606. /* 节流①: 内容没变就不擦写。屏幕每秒刷帧都会 mark_dirty,
  607. 没有这道闸 4KB sector 几天就写穿了 */
  608. if (!force && g_have_saved && (memcmp(&g_last_saved, &g_work, sizeof(g_work)) == 0))
  609. {
  610. g_dirty = 0;
  611. if (g_lock != RT_NULL) rt_mutex_release(g_lock);
  612. return 0;
  613. }
  614. /* 节流②: 两次落盘最小间隔 */
  615. if (!force && g_have_saved
  616. && ((rt_tick_get() - g_last_save_tick) < (rt_tick_t)PARAM_MIN_SAVE_TICKS))
  617. {
  618. if (g_lock != RT_NULL) rt_mutex_release(g_lock);
  619. return 1; /* dirty 保留,下个周期再试 */
  620. }
  621. ret = param_backup_write(&g_work);
  622. if (ret == 0)
  623. {
  624. g_last_saved = g_work;
  625. g_have_saved = 1;
  626. g_last_save_tick = rt_tick_get();
  627. g_dirty = 0;
  628. g_fail_backoff_tick = 0; /* ★ 写成功了就清除退避 */
  629. }
  630. else
  631. {
  632. /* ★ 写失败(g_dirty 保持 1、g_last_save_tick 不更新)时, 原来会在下一个
  633. PARAM_POLL_TICKS 立刻再走一次完整的"擦除 4KB + 写 + 回读":
  634. flash 真的坏了时就是每 200ms 一次擦除 + 一条 LOG_E, 既加速磨损又刷爆串口,
  635. 而且每次擦写阻塞 40~100ms, 低优先级的本线程会反复占用 SPI 总线,
  636. 拖慢 EasyFlash 和其它 flash 访问。
  637. 这里失败后置一个退避时间戳, 到期前不再重试。 */
  638. g_fail_backoff_tick = rt_tick_get();
  639. LOG_E("[param] save FAILED(%d), backoff %d ms", ret, PARAM_FAIL_BACKOFF_TICKS);
  640. }
  641. if (g_lock != RT_NULL)
  642. {
  643. rt_mutex_release(g_lock);
  644. }
  645. return ret;
  646. }
  647. int param_flush(void)
  648. {
  649. return param_flush_impl(0);
  650. }
  651. int param_flush_force(void)
  652. {
  653. return param_flush_impl(1);
  654. }
  655. static void param_autosave_entry(void *parameter)
  656. {
  657. while (1)
  658. {
  659. rt_thread_mdelay(PARAM_POLL_TICKS);
  660. if (g_dirty == 0)
  661. {
  662. continue;
  663. }
  664. /* ★ 上一次落盘失败后的退避窗口: 到期前不重试(见 param_flush_impl) */
  665. if (g_fail_backoff_tick != 0
  666. && ((rt_tick_get() - g_fail_backoff_tick) < (rt_tick_t)PARAM_FAIL_BACKOFF_TICKS))
  667. {
  668. continue;
  669. }
  670. /* 静默期: 距最后一次变更超过 PARAM_QUIET_TICKS 才落盘,
  671. 把"一条参数一次擦写"合并成"一批变更一次擦写" */
  672. if ((rt_tick_get() - g_dirty_tick) < PARAM_QUIET_TICKS)
  673. {
  674. continue;
  675. }
  676. param_flush();
  677. }
  678. }
  679. int param_backup_start(void)
  680. {
  681. if (g_tid != RT_NULL)
  682. {
  683. return RT_EOK; /* 已启动 */
  684. }
  685. /* 栈不能给 1024: 线程里会调 param_flush() -> fal 擦写 + LOG 打印,
  686. rt_kprintf 的 vsnprintf 本身就要好几百字节栈。 */
  687. g_tid = rt_thread_create("param_sv",
  688. param_autosave_entry, RT_NULL,
  689. 2048,
  690. 20, /* 低优先级,不抢业务线程 */
  691. 20);
  692. if (g_tid == RT_NULL)
  693. {
  694. LOG_E("[param] create autosave thread FAILED");
  695. return -RT_ERROR;
  696. }
  697. rt_thread_startup(g_tid);
  698. return RT_EOK;
  699. }
  700. /* ===================== 调试命令 ===================== */
  701. #ifdef RT_USING_FINSH
  702. #include <finsh.h>
  703. /* ★ P2-11 修法: 调试命令**不要**直接把落盘用的共享静态区 g_work 当读取目标。
  704. param_backup_read() 内部读完就释放 g_lock, 命令拿到指针后才去 param_unpack() /
  705. rt_kprintf —— 这期间落盘线程可能正在 param_pack(&g_work), 读到半新半旧的参数。
  706. 改成各用一份**私有**静态快照(同样是 820 字节, 不能放栈上), 与 g_work 完全隔离。 */
  707. static param_persist_t g_dbg_dump;
  708. static param_persist_t g_dbg_restore;
  709. static void param_dump(void)
  710. {
  711. /* 820 字节走静态工作区, 不放栈上(tshell 栈也未必够, 且 main 栈只有 2KB) */
  712. param_persist_t *snap = &g_dbg_dump;
  713. uint32_t seq = 0;
  714. if (param_backup_read(snap, &seq) != 0)
  715. {
  716. rt_kprintf("no valid snapshot\n");
  717. return;
  718. }
  719. rt_kprintf("seq : %u\n", (unsigned)seq);
  720. rt_kprintf("iSave : %d\n", snap->iSave);
  721. rt_kprintf("dtype : %d\n", snap->dtype);
  722. rt_kprintf("ver_type : %d\n", snap->version_type);
  723. rt_kprintf("rebootcnt : %d\n", (int)snap->rebootcnt);
  724. rt_kprintf("tph/tpl : %d/%d\n", snap->tph, snap->tpl);
  725. rt_kprintf("thsp : %d\n", snap->thsp);
  726. rt_kprintf("dattim : %d\n", snap->dattim);
  727. rt_kprintf("sunBar : %d\n", snap->sunBar);
  728. rt_kprintf("clt/heat : %d/%d\n", snap->clt_time, snap->heattime);
  729. rt_kprintf("start/stop: %d/%d\n", snap->startBar, snap->stopBar);
  730. rt_kprintf("imei : %s\n", snap->imei);
  731. rt_kprintf("deviceId : %s\n", snap->deviceId);
  732. rt_kprintf("platform : %s\n", snap->mqttcfg1);
  733. rt_kprintf("health : 0x%x\n", param_check_health(snap));
  734. }
  735. MSH_CMD_EXPORT(param_dump, dump param snapshot from backup partition);
  736. static void param_save_now(void)
  737. {
  738. int ret = param_flush_force();
  739. rt_kprintf("param_flush_force ret=%d\n", ret);
  740. }
  741. MSH_CMD_EXPORT(param_save_now, force save device_status to backup partition);
  742. static void param_restore(void)
  743. {
  744. param_persist_t *snap = &g_dbg_restore; /* 私有缓冲, 不与 g_work 抢 */
  745. if (param_backup_read(snap, RT_NULL) != 0)
  746. {
  747. rt_kprintf("no valid snapshot to restore\n");
  748. return;
  749. }
  750. param_unpack(snap);
  751. rt_kprintf("restored to RAM. run 'param_save_ef' to fix easyflash\n");
  752. }
  753. MSH_CMD_EXPORT(param_restore, restore device_status from backup partition);
  754. static void param_save_ef(void)
  755. {
  756. int n;
  757. if (g_lock != RT_NULL) rt_mutex_take(g_lock, RT_WAITING_FOREVER);
  758. param_pack(&g_work);
  759. n = param_write_back_to_easyflash(&g_work);
  760. if (g_lock != RT_NULL) rt_mutex_release(g_lock);
  761. rt_kprintf("write back %d items to easyflash\n", n);
  762. }
  763. MSH_CMD_EXPORT(param_save_ef, write device_status back to easyflash);
  764. /* ★ 存储链路体检(2026-09-24 上板定位用)。
  765. 现场报"丢参数/起不来"时先敲这个: 一眼看出是 FAL 没建表、flash 没探测到,
  766. 还是分区/快照的问题, 不用猜。 */
  767. static void param_stat(void)
  768. {
  769. rt_kprintf("fal_init_check : %d (1=FAL 建表成功, 0=所有 fal_partition_find 会断言死循环)\n",
  770. fal_init_check());
  771. rt_kprintf("nor_flash0_ready : %d (0=SPI flash 未探测到, 已走降级 RAM 参数)\n",
  772. nor_flash0_is_ready());
  773. rt_kprintf("param_a / param_b: %s / %s\n",
  774. g_part_a ? g_part_a->name : "NULL", g_part_b ? g_part_b->name : "NULL");
  775. rt_kprintf("g_disabled : %d\n", (int)g_disabled);
  776. rt_kprintf("last_seq : %u\n", (unsigned)g_last_seq);
  777. rt_kprintf("dirty : %d\n", (int)g_dirty);
  778. }
  779. MSH_CMD_EXPORT(param_stat, show param storage health (FAL/flash/partitions));
  780. #endif /* RT_USING_FINSH */