|
|
@@ -1,877 +0,0 @@
|
|
|
-/*
|
|
|
- * 参数双分区备份模块实现
|
|
|
- *
|
|
|
- * 依赖: FAL(param_a / param_b 两个 4KB 分区) + EasyFlash + device_status
|
|
|
- * 说明: 本模块不改动 EasyFlash 自身的写入路径,而是在其之上加一层
|
|
|
- * "整包快照 + A/B 轮写 + CRC 校验",开机双向修复:
|
|
|
- * - EasyFlash 丢了 -> 从快照恢复并回写 EasyFlash
|
|
|
- * - 快照丢了/更旧 -> 从 EasyFlash 重建快照
|
|
|
- */
|
|
|
-#include "param_backup.h"
|
|
|
-
|
|
|
-#include <string.h>
|
|
|
-#include <fal.h>
|
|
|
-#include <easyflash.h>
|
|
|
-#include "control.h"
|
|
|
-
|
|
|
-#define DBG_ENABLE
|
|
|
-#define DBG_COLOR
|
|
|
-#define DBG_TAG "param"
|
|
|
-#define DBG_LVL DBG_LOG
|
|
|
-#include <rtdbg.h>
|
|
|
-
|
|
|
-/* device_status 由 control.h 的 extern 声明提供, 唯一定义在 main.c, 本模块只引用 */
|
|
|
-
|
|
|
-/* ===================== 内部状态 ===================== */
|
|
|
-static const struct fal_partition *g_part_a = RT_NULL;
|
|
|
-static const struct fal_partition *g_part_b = RT_NULL;
|
|
|
-
|
|
|
-static rt_mutex_t g_lock = RT_NULL; /* 保护落盘过程,避免多线程同时擦写 */
|
|
|
-static rt_thread_t g_tid = RT_NULL;
|
|
|
-static uint8_t g_dirty = 0;
|
|
|
-static rt_tick_t g_dirty_tick = 0;
|
|
|
-static uint32_t g_last_seq = 0; /* 最近一次成功写入/读出的 seq */
|
|
|
-
|
|
|
-/* ★ 存储不可用(SPI flash 探测失败/分区表建不起来)时置 1。
|
|
|
- 此时 mark_dirty / flush 一律直接返回失败, 否则落盘线程会每隔几秒就重试一次
|
|
|
- 并打一条 LOG_E, 把串口刷爆, 也让业务线程白等锁。 */
|
|
|
-static uint8_t g_disabled = 0;
|
|
|
-
|
|
|
-/* 落盘节流用: 上次成功写入的内容与时刻 */
|
|
|
-static param_persist_t g_last_saved;
|
|
|
-static uint8_t g_have_saved = 0;
|
|
|
-static rt_tick_t g_last_save_tick = 0;
|
|
|
-
|
|
|
-/* ★ 上次落盘**失败**的时刻(0 = 没有待退避的失败)。
|
|
|
- flash 真的坏了时, 原来每 PARAM_POLL_TICKS 就会重试一次完整擦写,
|
|
|
- 既加速磨损又刷爆串口。失败后退避 PARAM_FAIL_BACKOFF_TICKS 再试。 */
|
|
|
-static rt_tick_t g_fail_backoff_tick = 0;
|
|
|
-
|
|
|
-/* 回读校验缓冲,避免占用大栈 */
|
|
|
-static uint8_t g_rb_buf[sizeof(param_persist_t)];
|
|
|
-
|
|
|
-/* ★ 静态工作区 —— 极其重要,别改成局部变量!
|
|
|
- sizeof(param_persist_t) = 820 字节。两个就是 1640 字节,而
|
|
|
- - main 线程栈 RT_MAIN_THREAD_STACK_SIZE = 2048
|
|
|
- - 落盘线程栈 = 1024
|
|
|
- Check_ParamConfig() 跑在 main 线程,里面放 2 个 param_persist_t
|
|
|
- 再调 param_backup_read()(内部又 2 个)栈峰值超过 3.2KB —— 必爆栈 hard fault。
|
|
|
- 所以模块内部凡是需要临时 param_persist_t 的地方,一律用这块静态区,
|
|
|
- 并且必须在 g_lock 保护下使用(多线程共用)。 */
|
|
|
-static param_persist_t g_work;
|
|
|
-
|
|
|
-/* 快照头在分区内的偏移 */
|
|
|
-#define PARAM_HDR_SIZE ((uint32_t)sizeof(param_snapshot_hdr_t))
|
|
|
-#define PARAM_TOTAL_SIZE (PARAM_HDR_SIZE + (uint32_t)sizeof(param_persist_t))
|
|
|
-
|
|
|
-/* ===================== CRC32 (IEEE 802.3, 多项式 0xEDB88320 反射) ===================== */
|
|
|
-static uint32_t crc32_calc(const uint8_t *data, uint32_t len)
|
|
|
-{
|
|
|
- uint32_t crc = 0xFFFFFFFFu;
|
|
|
- uint32_t i, j;
|
|
|
-
|
|
|
- for (i = 0; i < len; i++)
|
|
|
- {
|
|
|
- crc ^= data[i];
|
|
|
- for (j = 0; j < 8; j++)
|
|
|
- {
|
|
|
- if (crc & 1u)
|
|
|
- {
|
|
|
- crc = (crc >> 1) ^ 0xEDB88320u;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- crc >>= 1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return crc ^ 0xFFFFFFFFu;
|
|
|
-}
|
|
|
-
|
|
|
-/* ===================== 分区槽操作 ===================== */
|
|
|
-
|
|
|
-/* 只读快照头 */
|
|
|
-static int slot_read_hdr(const struct fal_partition *part, param_snapshot_hdr_t *hdr)
|
|
|
-{
|
|
|
- if (part == RT_NULL || hdr == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- memset(hdr, 0, sizeof(*hdr));
|
|
|
- if (fal_partition_read(part, 0, (uint8_t *)hdr, PARAM_HDR_SIZE) < 0)
|
|
|
- {
|
|
|
- return -2;
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/* 读一个槽,校验 magic / version / len / crc,全部通过才认为有效 */
|
|
|
-static int slot_read(const struct fal_partition *part, param_persist_t *out, uint32_t *seq)
|
|
|
-{
|
|
|
- param_snapshot_hdr_t hdr;
|
|
|
- uint32_t crc;
|
|
|
-
|
|
|
- if (part == RT_NULL || out == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- if (slot_read_hdr(part, &hdr) != 0)
|
|
|
- {
|
|
|
- return -2;
|
|
|
- }
|
|
|
- if (hdr.magic != PARAM_MAGIC)
|
|
|
- {
|
|
|
- return -3; /* 空槽或未格式化 */
|
|
|
- }
|
|
|
- if (hdr.version != PARAM_VERSION)
|
|
|
- {
|
|
|
- return -4; /* 固件升级后结构变化,旧快照作废 */
|
|
|
- }
|
|
|
- if (hdr.len != sizeof(param_persist_t))
|
|
|
- {
|
|
|
- return -5;
|
|
|
- }
|
|
|
- if (fal_partition_read(part, PARAM_HDR_SIZE, (uint8_t *)out, hdr.len) < 0)
|
|
|
- {
|
|
|
- return -6;
|
|
|
- }
|
|
|
- crc = crc32_calc((const uint8_t *)out, hdr.len);
|
|
|
- if (crc != hdr.crc32)
|
|
|
- {
|
|
|
- LOG_W("[param] %s CRC bad(0x%08x != 0x%08x)", part->name, crc, hdr.crc32);
|
|
|
- return -7; /* 写一半掉电,本槽作废,用另一槽 */
|
|
|
- }
|
|
|
- if (seq)
|
|
|
- {
|
|
|
- *seq = hdr.seq;
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/* 写一个槽: 擦除整区 -> 写头 -> 写体 -> 回读校验 */
|
|
|
-static int slot_write(const struct fal_partition *part, const param_persist_t *data, uint32_t seq)
|
|
|
-{
|
|
|
- param_snapshot_hdr_t hdr;
|
|
|
- uint32_t crc;
|
|
|
-
|
|
|
- if (part == RT_NULL || data == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
-
|
|
|
- hdr.magic = PARAM_MAGIC;
|
|
|
- hdr.version = PARAM_VERSION;
|
|
|
- hdr.seq = seq;
|
|
|
- hdr.len = sizeof(param_persist_t);
|
|
|
- hdr.crc32 = crc32_calc((const uint8_t *)data, sizeof(param_persist_t));
|
|
|
- hdr.reserved = 0;
|
|
|
-
|
|
|
- /* 1. 擦除整个分区(4KB)。此时另一分区仍是上一版完整数据,中断不会两边都毁 */
|
|
|
- if (fal_partition_erase_all(part) < 0)
|
|
|
- {
|
|
|
- LOG_E("[param] erase %s FAILED", part->name);
|
|
|
- return -2;
|
|
|
- }
|
|
|
- /* 2. 写头 */
|
|
|
- if (fal_partition_write(part, 0, (const uint8_t *)&hdr, PARAM_HDR_SIZE) < 0)
|
|
|
- {
|
|
|
- LOG_E("[param] write hdr %s FAILED", part->name);
|
|
|
- return -3;
|
|
|
- }
|
|
|
- /* 3. 写体 */
|
|
|
- if (fal_partition_write(part, PARAM_HDR_SIZE, (const uint8_t *)data, hdr.len) < 0)
|
|
|
- {
|
|
|
- LOG_E("[param] write body %s FAILED", part->name);
|
|
|
- return -4;
|
|
|
- }
|
|
|
- /* 4. 回读校验,确认真的落进去了(NOR 写失败很隐蔽) */
|
|
|
- memset(g_rb_buf, 0, sizeof(g_rb_buf));
|
|
|
- if (fal_partition_read(part, PARAM_HDR_SIZE, g_rb_buf, hdr.len) < 0)
|
|
|
- {
|
|
|
- LOG_E("[param] readback %s FAILED", part->name);
|
|
|
- return -5;
|
|
|
- }
|
|
|
- crc = crc32_calc(g_rb_buf, hdr.len);
|
|
|
- if (crc != hdr.crc32)
|
|
|
- {
|
|
|
- LOG_E("[param] readback %s mismatch(0x%08x != 0x%08x)", part->name, crc, hdr.crc32);
|
|
|
- return -6;
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/* ===================== 对外: 初始化 / 读 / 写 ===================== */
|
|
|
-
|
|
|
-int param_backup_init(void)
|
|
|
-{
|
|
|
- /* ★ 闸门①: FAL 必须先建表成功。
|
|
|
- fal_partition_find() 第一行就是 assert(init_ok), fal_init() 失败时
|
|
|
- 它是死循环 —— 2026-09-24 上板实测 "(init_ok) has assert failed at
|
|
|
- fal_partition_find." 就是从这里进去的(降级启动分支照常调了本函数)。
|
|
|
- 查 fal_init_check() 是最省事也最可靠的门控。 */
|
|
|
- if (fal_init_check() != 1)
|
|
|
- {
|
|
|
- LOG_E("[param] FAL NOT initialized, param backup disabled");
|
|
|
- g_disabled = 1;
|
|
|
- return -RT_ERROR;
|
|
|
- }
|
|
|
-
|
|
|
- /* ★ 闸门②: norflash0 芯片本身要可用。
|
|
|
- FAL 建表成功不代表 flash 是好的 —— 为了让 FAL 不被单个坏设备拖垮,
|
|
|
- nor_flash0.len 在探测失败时仍保留标称容量(见 fal_flash_sfud_port.c),
|
|
|
- 所以分区照样找得到, 但读写一律返回 -1。不在这里闸掉的话, 落盘线程会
|
|
|
- 每隔 PARAM_POLL_TICKS 重试一次并打一条 LOG_E, 把串口刷爆。 */
|
|
|
- if (!nor_flash0_is_ready())
|
|
|
- {
|
|
|
- LOG_E("[param] SPI flash NOT ready, param backup disabled");
|
|
|
- g_disabled = 1;
|
|
|
- return -RT_ERROR;
|
|
|
- }
|
|
|
-
|
|
|
- g_part_a = fal_partition_find(PARAM_PART_A_NAME);
|
|
|
- g_part_b = fal_partition_find(PARAM_PART_B_NAME);
|
|
|
-
|
|
|
- if (g_part_a == RT_NULL && g_part_b == RT_NULL)
|
|
|
- {
|
|
|
- LOG_E("[param] partition %s / %s NOT found", PARAM_PART_A_NAME, PARAM_PART_B_NAME);
|
|
|
- /* 一个分区都找不到 = SPI flash 不可用(探测失败或分区表没建起来)。
|
|
|
- 置 disabled, 后续完全不再尝试落盘。 */
|
|
|
- g_disabled = 1;
|
|
|
- return -RT_ERROR;
|
|
|
- }
|
|
|
- g_disabled = 0;
|
|
|
- if (g_part_a == RT_NULL || g_part_b == RT_NULL)
|
|
|
- {
|
|
|
- LOG_W("[param] only one partition found, backup degraded");
|
|
|
- }
|
|
|
-
|
|
|
- if (g_lock == RT_NULL)
|
|
|
- {
|
|
|
- g_lock = rt_mutex_create("param_lk", RT_IPC_FLAG_PRIO);
|
|
|
- if (g_lock == RT_NULL)
|
|
|
- {
|
|
|
- LOG_E("[param] create mutex FAILED");
|
|
|
- return -RT_ENOMEM;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* 上电先摸清当前有效快照的 seq,后续写入在其基础上递增。
|
|
|
- 这里只关心 seq,payload 直接复用静态工作区(不占栈)。 */
|
|
|
- {
|
|
|
- uint32_t sa = 0, sb = 0, ra, rb;
|
|
|
-
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_take(g_lock, RT_WAITING_FOREVER);
|
|
|
- }
|
|
|
- ra = (g_part_a != RT_NULL) ? slot_read(g_part_a, &g_work, &sa) : -1;
|
|
|
- rb = (g_part_b != RT_NULL) ? slot_read(g_part_b, &g_work, &sb) : -1;
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_release(g_lock);
|
|
|
- }
|
|
|
-
|
|
|
- if (ra == 0 && rb == 0)
|
|
|
- {
|
|
|
- g_last_seq = (sa > sb) ? sa : sb;
|
|
|
- }
|
|
|
- else if (ra == 0)
|
|
|
- {
|
|
|
- g_last_seq = sa;
|
|
|
- }
|
|
|
- else if (rb == 0)
|
|
|
- {
|
|
|
- g_last_seq = sb;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- g_last_seq = 0;
|
|
|
- }
|
|
|
- LOG_I("[param] init ok. A=%s(seq %u) B=%s(seq %u)",
|
|
|
- (ra == 0) ? "ok" : "bad", (unsigned)sa,
|
|
|
- (rb == 0) ? "ok" : "bad", (unsigned)sb);
|
|
|
- }
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-int param_backup_read(param_persist_t *out, uint32_t *seq)
|
|
|
-{
|
|
|
- uint32_t sa = 0, sb = 0;
|
|
|
- int ra, rb, ret = -2;
|
|
|
-
|
|
|
- if (out == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- /* g_work 是多线程共用的静态区,必须加锁 */
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_take(g_lock, RT_WAITING_FOREVER);
|
|
|
- }
|
|
|
-
|
|
|
- /* 只用一个缓冲: 先读 A 槽,再读 B 槽,谁 seq 大谁是最终赢家。
|
|
|
- 这样 820 字节的 param_persist_t 只出现一次,且不在栈上。 */
|
|
|
- ra = (g_part_a != RT_NULL) ? slot_read(g_part_a, &g_work, &sa) : -1;
|
|
|
- if (ra == 0)
|
|
|
- {
|
|
|
- *out = g_work;
|
|
|
- if (seq) *seq = sa;
|
|
|
- ret = 0;
|
|
|
- }
|
|
|
-
|
|
|
- rb = (g_part_b != RT_NULL) ? slot_read(g_part_b, &g_work, &sb) : -1;
|
|
|
- if (rb == 0 && (ra != 0 || sb > sa))
|
|
|
- {
|
|
|
- *out = g_work;
|
|
|
- if (seq) *seq = sb;
|
|
|
- ret = 0;
|
|
|
- }
|
|
|
-
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_release(g_lock);
|
|
|
- }
|
|
|
- return ret; /* -2 = 两槽都无效 */
|
|
|
-}
|
|
|
-
|
|
|
-int param_backup_write(const param_persist_t *in)
|
|
|
-{
|
|
|
- const struct fal_partition *target = RT_NULL; /* ★ 显式初始化, 配合下面的空指针兜底 */
|
|
|
- param_snapshot_hdr_t ha, hb;
|
|
|
- uint32_t sa = 0, sb = 0, next_seq;
|
|
|
- int ra = -1, rb = -1, ret;
|
|
|
-
|
|
|
- if (in == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- if (g_part_a == RT_NULL && g_part_b == RT_NULL)
|
|
|
- {
|
|
|
- return -2;
|
|
|
- }
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_take(g_lock, RT_WAITING_FOREVER);
|
|
|
- }
|
|
|
-
|
|
|
- /* 只举手之劳读头,判断哪一槽更旧 */
|
|
|
- if (g_part_a != RT_NULL)
|
|
|
- {
|
|
|
- if (slot_read_hdr(g_part_a, &ha) == 0 && ha.magic == PARAM_MAGIC
|
|
|
- && ha.version == PARAM_VERSION && ha.len == sizeof(param_persist_t))
|
|
|
- {
|
|
|
- sa = ha.seq;
|
|
|
- ra = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- if (g_part_b != RT_NULL)
|
|
|
- {
|
|
|
- if (slot_read_hdr(g_part_b, &hb) == 0 && hb.magic == PARAM_MAGIC
|
|
|
- && hb.version == PARAM_VERSION && hb.len == sizeof(param_persist_t))
|
|
|
- {
|
|
|
- sb = hb.seq;
|
|
|
- rb = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* 优先写"无效或更旧"的槽,保证另一槽始终是上一版可用数据 */
|
|
|
- if (ra != 0 && g_part_a != RT_NULL)
|
|
|
- {
|
|
|
- target = g_part_a;
|
|
|
- next_seq = (rb == 0) ? (sb + 1) : (g_last_seq + 1);
|
|
|
- }
|
|
|
- else if (rb != 0 && g_part_b != RT_NULL)
|
|
|
- {
|
|
|
- target = g_part_b;
|
|
|
- next_seq = sa + 1;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- target = (sa <= sb) ? g_part_a : g_part_b;
|
|
|
- next_seq = ((sa > sb) ? sa : sb) + 1;
|
|
|
- }
|
|
|
- /* ★ 单分区降级(param_a / param_b 只建起来一个)时, 上面两个分支可能把
|
|
|
- target 指到那个为 NULL 的分区, 紧接着 target->name 就是空指针解引用
|
|
|
- -> 多数情况直接 Bus Fault; 躲过去也是"参数永远存不进去"
|
|
|
- (下面 LOG 前也做了判空)。这里补一道兜底。 */
|
|
|
- if (target == RT_NULL)
|
|
|
- {
|
|
|
- target = (g_part_a != RT_NULL) ? g_part_a : g_part_b;
|
|
|
- }
|
|
|
- if (target == RT_NULL)
|
|
|
- {
|
|
|
- LOG_E("[param] no usable partition, save aborted");
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_release(g_lock);
|
|
|
- }
|
|
|
- return -RT_ERROR;
|
|
|
- }
|
|
|
- /* seq 必须严格递增,防止回绕后被误判为旧数据 */
|
|
|
- if (next_seq <= g_last_seq)
|
|
|
- {
|
|
|
- next_seq = g_last_seq + 1;
|
|
|
- }
|
|
|
- if (next_seq == 0)
|
|
|
- {
|
|
|
- next_seq = 1;
|
|
|
- }
|
|
|
-
|
|
|
- ret = slot_write(target, in, next_seq);
|
|
|
- if (ret == 0)
|
|
|
- {
|
|
|
- g_last_seq = next_seq;
|
|
|
- LOG_D("[param] saved to %s, seq=%u", target->name, (unsigned)next_seq);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- LOG_E("[param] save to %s FAILED(%d)", target->name, ret);
|
|
|
- }
|
|
|
-
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_release(g_lock);
|
|
|
- }
|
|
|
- return ret;
|
|
|
-}
|
|
|
-
|
|
|
-/* ===================== device_status <-> param_persist_t ===================== */
|
|
|
-
|
|
|
-void param_pack(param_persist_t *dst)
|
|
|
-{
|
|
|
- if (dst == RT_NULL)
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
- memset(dst, 0, sizeof(*dst));
|
|
|
-
|
|
|
- dst->iSave = device_status.iSave;
|
|
|
- dst->dtype = device_status.dtype;
|
|
|
- dst->version_type = device_status.version_type;
|
|
|
- dst->Power_Type = device_status.Power_Type;
|
|
|
-
|
|
|
- dst->ds = device_status.ds;
|
|
|
- dst->timeSwitch = device_status.timeSwitch;
|
|
|
- dst->run_sta = device_status.run_sta;
|
|
|
- dst->cul_time = device_status.cul_time;
|
|
|
-
|
|
|
- dst->motor_active = device_status.motor_active;
|
|
|
- dst->heat_sw = device_status.heat_sw;
|
|
|
- dst->cold_sw = device_status.cold_sw;
|
|
|
- dst->wind_sw = device_status.wind_sw;
|
|
|
-
|
|
|
- dst->collecting_sh1 = device_status.collecting_sh1;
|
|
|
- dst->collecting_eh1 = device_status.collecting_eh1;
|
|
|
- dst->collecting_sh2 = device_status.collecting_sh2;
|
|
|
- dst->collecting_eh2 = device_status.collecting_eh2;
|
|
|
-
|
|
|
- dst->handle_bugger = device_status.handle_bugger;
|
|
|
- dst->work_mode = device_status.work_mode;
|
|
|
- dst->shake_ws = device_status.shake_ws;
|
|
|
- dst->tph = device_status.tph;
|
|
|
-
|
|
|
- dst->tpl = device_status.tpl;
|
|
|
- dst->clt_time = device_status.clt_time;
|
|
|
- dst->heattime = device_status.heattime;
|
|
|
- dst->heatvalue = device_status.heatvalue;
|
|
|
-
|
|
|
- dst->sunBar = device_status.sunBar;
|
|
|
- dst->startBar = device_status.startBar;
|
|
|
- dst->stopBar = device_status.stopBar;
|
|
|
- dst->vol = device_status.vol;
|
|
|
-
|
|
|
- dst->stop_in_bootloader = device_status.stop_in_bootloader;
|
|
|
- dst->update_flag = device_status.update_flag;
|
|
|
-
|
|
|
- dst->dattim = device_status.dattim;
|
|
|
- dst->shake_sec = device_status.shake_sec;
|
|
|
- dst->thsp = device_status.thsp;
|
|
|
-
|
|
|
- dst->passWord = device_status.passWord;
|
|
|
- dst->rebootcnt = device_status.rebootcnt;
|
|
|
-
|
|
|
- strncpy(dst->tempture, device_status.tempture, sizeof(dst->tempture) - 1);
|
|
|
- strncpy(dst->humidity, device_status.humidity, sizeof(dst->humidity) - 1);
|
|
|
- strncpy(dst->mqttcfg1, device_status.mqttcfg1, sizeof(dst->mqttcfg1) - 1);
|
|
|
- strncpy(dst->deviceId, device_status.deviceId, sizeof(dst->deviceId) - 1);
|
|
|
- strncpy(dst->imei, device_status.imei, sizeof(dst->imei) - 1);
|
|
|
- strncpy(dst->iccid, device_status.iccid, sizeof(dst->iccid) - 1);
|
|
|
- strncpy(dst->lat, device_status.lat, sizeof(dst->lat) - 1);
|
|
|
- strncpy(dst->lng, device_status.lng, sizeof(dst->lng) - 1);
|
|
|
- strncpy(dst->alarm_tg, device_status.alarm_tg, sizeof(dst->alarm_tg) - 1);
|
|
|
- strncpy(dst->driver_bl, device_status.driver_bl, sizeof(dst->driver_bl) - 1);
|
|
|
- strncpy(dst->driver_compile, device_status.driver_compile, sizeof(dst->driver_compile) - 1);
|
|
|
-}
|
|
|
-
|
|
|
-void param_unpack(const param_persist_t *src)
|
|
|
-{
|
|
|
- if (src == RT_NULL)
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- device_status.iSave = src->iSave;
|
|
|
- device_status.dtype = src->dtype;
|
|
|
- device_status.version_type = src->version_type;
|
|
|
- device_status.Power_Type = src->Power_Type;
|
|
|
-
|
|
|
- device_status.ds = src->ds;
|
|
|
- device_status.timeSwitch = src->timeSwitch;
|
|
|
- device_status.run_sta = src->run_sta;
|
|
|
- device_status.cul_time = src->cul_time;
|
|
|
-
|
|
|
- device_status.motor_active = src->motor_active;
|
|
|
- device_status.heat_sw = src->heat_sw;
|
|
|
- device_status.cold_sw = src->cold_sw;
|
|
|
- device_status.wind_sw = src->wind_sw;
|
|
|
-
|
|
|
- device_status.collecting_sh1 = src->collecting_sh1;
|
|
|
- device_status.collecting_eh1 = src->collecting_eh1;
|
|
|
- device_status.collecting_sh2 = src->collecting_sh2;
|
|
|
- device_status.collecting_eh2 = src->collecting_eh2;
|
|
|
-
|
|
|
- device_status.handle_bugger = src->handle_bugger;
|
|
|
- device_status.work_mode = src->work_mode;
|
|
|
- device_status.shake_ws = src->shake_ws;
|
|
|
- device_status.tph = src->tph;
|
|
|
-
|
|
|
- device_status.tpl = src->tpl;
|
|
|
- device_status.clt_time = src->clt_time;
|
|
|
- device_status.heattime = src->heattime;
|
|
|
- device_status.heatvalue = src->heatvalue;
|
|
|
-
|
|
|
- device_status.sunBar = src->sunBar;
|
|
|
- device_status.startBar = src->startBar;
|
|
|
- device_status.stopBar = src->stopBar;
|
|
|
- device_status.vol = src->vol;
|
|
|
-
|
|
|
- device_status.stop_in_bootloader = src->stop_in_bootloader;
|
|
|
- device_status.update_flag = src->update_flag;
|
|
|
-
|
|
|
- device_status.dattim = src->dattim;
|
|
|
- device_status.shake_sec = src->shake_sec;
|
|
|
- device_status.thsp = src->thsp;
|
|
|
-
|
|
|
- device_status.passWord = src->passWord;
|
|
|
- device_status.rebootcnt = src->rebootcnt;
|
|
|
-
|
|
|
- strncpy(device_status.tempture, src->tempture, sizeof(device_status.tempture) - 1);
|
|
|
- strncpy(device_status.humidity, src->humidity, sizeof(device_status.humidity) - 1);
|
|
|
- strncpy(device_status.mqttcfg1, src->mqttcfg1, sizeof(device_status.mqttcfg1) - 1);
|
|
|
- strncpy(device_status.deviceId, src->deviceId, sizeof(device_status.deviceId) - 1);
|
|
|
- strncpy(device_status.imei, src->imei, sizeof(device_status.imei) - 1);
|
|
|
- strncpy(device_status.iccid, src->iccid, sizeof(device_status.iccid) - 1);
|
|
|
- strncpy(device_status.lat, src->lat, sizeof(device_status.lat) - 1);
|
|
|
- strncpy(device_status.lng, src->lng, sizeof(device_status.lng) - 1);
|
|
|
- strncpy(device_status.alarm_tg, src->alarm_tg, sizeof(device_status.alarm_tg) - 1);
|
|
|
- strncpy(device_status.driver_bl, src->driver_bl, sizeof(device_status.driver_bl) - 1);
|
|
|
- strncpy(device_status.driver_compile, src->driver_compile, sizeof(device_status.driver_compile) - 1);
|
|
|
-}
|
|
|
-
|
|
|
-int param_write_back_to_easyflash(const param_persist_t *src)
|
|
|
-{
|
|
|
- int n = 0;
|
|
|
-
|
|
|
- if (src == RT_NULL)
|
|
|
- {
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- /* 与 param_check_health / Check_ParamConfig 读取的 key 一一对应 */
|
|
|
- n += (ef_set_env_blob("iSave", &src->iSave, sizeof(src->iSave)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("ds", &src->ds, sizeof(src->ds)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("stime", &src->clt_time, sizeof(src->clt_time)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("startBar", &src->startBar, sizeof(src->startBar)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("stopBar", &src->stopBar, sizeof(src->stopBar)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("timeSwitch", &src->timeSwitch, sizeof(src->timeSwitch)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("sunBar", &src->sunBar, sizeof(src->sunBar)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("jtime", &src->heattime, sizeof(src->heattime)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("jheat", &src->heatvalue, sizeof(src->heatvalue)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("tph", &src->tph, sizeof(src->tph)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("tpl", &src->tpl, sizeof(src->tpl)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("shake_ws", &src->shake_ws, sizeof(src->shake_ws)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("shake_sec", &src->shake_sec, sizeof(src->shake_sec)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("thsp", &src->thsp, sizeof(src->thsp)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("passWord", &src->passWord, sizeof(src->passWord)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("dattim", &src->dattim, sizeof(src->dattim)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("version_type", &src->version_type, sizeof(src->version_type)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("dtype", &src->dtype, sizeof(src->dtype)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("env_t", src->tempture, sizeof(src->tempture)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("env_h", src->humidity, sizeof(src->humidity)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("platform", src->mqttcfg1, sizeof(src->mqttcfg1)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("cul_time", &src->cul_time, sizeof(src->cul_time)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("motor_active", &src->motor_active, sizeof(src->motor_active)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("heat_sw", &src->heat_sw, sizeof(src->heat_sw)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("cold_sw", &src->cold_sw, sizeof(src->cold_sw)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("collecting_sh1", &src->collecting_sh1, sizeof(src->collecting_sh1)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("collecting_eh1", &src->collecting_eh1, sizeof(src->collecting_eh1)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("collecting_sh2", &src->collecting_sh2, sizeof(src->collecting_sh2)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("collecting_eh2", &src->collecting_eh2, sizeof(src->collecting_eh2)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("run_sta", &src->run_sta, sizeof(src->run_sta)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("Power_Type", &src->Power_Type, sizeof(src->Power_Type)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("deviceId", src->deviceId, sizeof(src->deviceId)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("handle_bugger",&src->handle_bugger,sizeof(src->handle_bugger))== EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("work_mode", &src->work_mode, sizeof(src->work_mode)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("alarm_tg", src->alarm_tg, sizeof(src->alarm_tg)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("imei", src->imei, sizeof(src->imei)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("iccid", src->iccid, sizeof(src->iccid)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("lat", src->lat, sizeof(src->lat)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("lng", src->lng, sizeof(src->lng)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("driver_bl", src->driver_bl, sizeof(src->driver_bl)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("reboot_time", &src->rebootcnt, sizeof(src->rebootcnt)) == EF_NO_ERR);
|
|
|
- n += (ef_set_env_blob("vol", &src->vol, sizeof(src->vol)) == EF_NO_ERR);
|
|
|
-
|
|
|
- return n;
|
|
|
-}
|
|
|
-
|
|
|
-int param_check_health(const param_persist_t *p)
|
|
|
-{
|
|
|
- int err = 0;
|
|
|
-
|
|
|
- if (p == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- if (p->iSave != 2) /* FLASH_FLAG == 2 */
|
|
|
- {
|
|
|
- err |= PARAM_ERR_ISAVE;
|
|
|
- }
|
|
|
- if (p->tph == 0) { err |= PARAM_ERR_TPH; }
|
|
|
- if (p->thsp == 0) { err |= PARAM_ERR_THSP; }
|
|
|
- if (p->dattim == 0) { err |= PARAM_ERR_DATTIM; }
|
|
|
- if (p->sunBar == 0) { err |= PARAM_ERR_SUNBAR; }
|
|
|
- if (p->clt_time == 0) { err |= PARAM_ERR_CLTIME; }
|
|
|
- if (p->heattime == 0) { err |= PARAM_ERR_HEATTIME; }
|
|
|
- if (p->heatvalue == 0) { err |= PARAM_ERR_HEATVALUE; }
|
|
|
-
|
|
|
- return err;
|
|
|
-}
|
|
|
-
|
|
|
-/* ===================== 延迟落盘 ===================== */
|
|
|
-
|
|
|
-void param_mark_dirty(void)
|
|
|
-{
|
|
|
- /* 故意不加锁: 这里只写两个对齐的字长变量,Cortex-M3 上单字读写本身是原子的。
|
|
|
- 加锁反而会让业务线程在落盘线程擦写 4KB 的 ~100ms 里被卡住。 */
|
|
|
- if (g_disabled)
|
|
|
- {
|
|
|
- return; /* 存储不可用,别让落盘线程反复重试 */
|
|
|
- }
|
|
|
- g_dirty_tick = rt_tick_get();
|
|
|
- g_dirty = 1;
|
|
|
-}
|
|
|
-
|
|
|
-/* force==0: 走节流(内容相同不写 / 最小间隔内推迟)
|
|
|
- force!=0: 立即写,跳过节流 */
|
|
|
-static int param_flush_impl(int force)
|
|
|
-{
|
|
|
- int ret;
|
|
|
-
|
|
|
- if (g_disabled)
|
|
|
- {
|
|
|
- return -2; /* 存储不可用: 静默失败,不重试不刷屏 */
|
|
|
- }
|
|
|
-
|
|
|
- /* 本函数可能被业务线程(恢复出厂等)和落盘线程同时调用,
|
|
|
- g_work 是共用静态区,所以全程持锁。
|
|
|
- 注: RT-Thread 的 mutex 支持同线程递归 take(hold++),
|
|
|
- 因此下面再调 param_backup_write() 内部加锁不会死锁。 */
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_take(g_lock, RT_WAITING_FOREVER);
|
|
|
- }
|
|
|
-
|
|
|
- param_pack(&g_work);
|
|
|
-
|
|
|
- /* 节流①: 内容没变就不擦写。屏幕每秒刷帧都会 mark_dirty,
|
|
|
- 没有这道闸 4KB sector 几天就写穿了 */
|
|
|
- if (!force && g_have_saved && (memcmp(&g_last_saved, &g_work, sizeof(g_work)) == 0))
|
|
|
- {
|
|
|
- g_dirty = 0;
|
|
|
- if (g_lock != RT_NULL) rt_mutex_release(g_lock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- /* 节流②: 两次落盘最小间隔 */
|
|
|
- if (!force && g_have_saved
|
|
|
- && ((rt_tick_get() - g_last_save_tick) < (rt_tick_t)PARAM_MIN_SAVE_TICKS))
|
|
|
- {
|
|
|
- if (g_lock != RT_NULL) rt_mutex_release(g_lock);
|
|
|
- return 1; /* dirty 保留,下个周期再试 */
|
|
|
- }
|
|
|
-
|
|
|
- ret = param_backup_write(&g_work);
|
|
|
- if (ret == 0)
|
|
|
- {
|
|
|
- g_last_saved = g_work;
|
|
|
- g_have_saved = 1;
|
|
|
- g_last_save_tick = rt_tick_get();
|
|
|
- g_dirty = 0;
|
|
|
- g_fail_backoff_tick = 0; /* ★ 写成功了就清除退避 */
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- /* ★ 写失败(g_dirty 保持 1、g_last_save_tick 不更新)时, 原来会在下一个
|
|
|
- PARAM_POLL_TICKS 立刻再走一次完整的"擦除 4KB + 写 + 回读":
|
|
|
- flash 真的坏了时就是每 200ms 一次擦除 + 一条 LOG_E, 既加速磨损又刷爆串口,
|
|
|
- 而且每次擦写阻塞 40~100ms, 低优先级的本线程会反复占用 SPI 总线,
|
|
|
- 拖慢 EasyFlash 和其它 flash 访问。
|
|
|
- 这里失败后置一个退避时间戳, 到期前不再重试。 */
|
|
|
- g_fail_backoff_tick = rt_tick_get();
|
|
|
- LOG_E("[param] save FAILED(%d), backoff %d ms", ret, PARAM_FAIL_BACKOFF_TICKS);
|
|
|
- }
|
|
|
-
|
|
|
- if (g_lock != RT_NULL)
|
|
|
- {
|
|
|
- rt_mutex_release(g_lock);
|
|
|
- }
|
|
|
- return ret;
|
|
|
-}
|
|
|
-
|
|
|
-int param_flush(void)
|
|
|
-{
|
|
|
- return param_flush_impl(0);
|
|
|
-}
|
|
|
-
|
|
|
-int param_flush_force(void)
|
|
|
-{
|
|
|
- return param_flush_impl(1);
|
|
|
-}
|
|
|
-
|
|
|
-static void param_autosave_entry(void *parameter)
|
|
|
-{
|
|
|
- while (1)
|
|
|
- {
|
|
|
- rt_thread_mdelay(PARAM_POLL_TICKS);
|
|
|
-
|
|
|
- if (g_dirty == 0)
|
|
|
- {
|
|
|
- continue;
|
|
|
- }
|
|
|
- /* ★ 上一次落盘失败后的退避窗口: 到期前不重试(见 param_flush_impl) */
|
|
|
- if (g_fail_backoff_tick != 0
|
|
|
- && ((rt_tick_get() - g_fail_backoff_tick) < (rt_tick_t)PARAM_FAIL_BACKOFF_TICKS))
|
|
|
- {
|
|
|
- continue;
|
|
|
- }
|
|
|
- /* 静默期: 距最后一次变更超过 PARAM_QUIET_TICKS 才落盘,
|
|
|
- 把"一条参数一次擦写"合并成"一批变更一次擦写" */
|
|
|
- if ((rt_tick_get() - g_dirty_tick) < PARAM_QUIET_TICKS)
|
|
|
- {
|
|
|
- continue;
|
|
|
- }
|
|
|
- param_flush();
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-int param_backup_start(void)
|
|
|
-{
|
|
|
- if (g_tid != RT_NULL)
|
|
|
- {
|
|
|
- return RT_EOK; /* 已启动 */
|
|
|
- }
|
|
|
- /* 栈不能给 1024: 线程里会调 param_flush() -> fal 擦写 + LOG 打印,
|
|
|
- rt_kprintf 的 vsnprintf 本身就要好几百字节栈。 */
|
|
|
- g_tid = rt_thread_create("param_sv",
|
|
|
- param_autosave_entry, RT_NULL,
|
|
|
- 2048,
|
|
|
- 20, /* 低优先级,不抢业务线程 */
|
|
|
- 20);
|
|
|
- if (g_tid == RT_NULL)
|
|
|
- {
|
|
|
- LOG_E("[param] create autosave thread FAILED");
|
|
|
- return -RT_ERROR;
|
|
|
- }
|
|
|
- rt_thread_startup(g_tid);
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-/* ===================== 调试命令 ===================== */
|
|
|
-#ifdef RT_USING_FINSH
|
|
|
-#include <finsh.h>
|
|
|
-
|
|
|
-/* ★ P2-11 修法: 调试命令**不要**直接把落盘用的共享静态区 g_work 当读取目标。
|
|
|
- param_backup_read() 内部读完就释放 g_lock, 命令拿到指针后才去 param_unpack() /
|
|
|
- rt_kprintf —— 这期间落盘线程可能正在 param_pack(&g_work), 读到半新半旧的参数。
|
|
|
- 改成各用一份**私有**静态快照(同样是 820 字节, 不能放栈上), 与 g_work 完全隔离。 */
|
|
|
-static param_persist_t g_dbg_dump;
|
|
|
-static param_persist_t g_dbg_restore;
|
|
|
-
|
|
|
-static void param_dump(void)
|
|
|
-{
|
|
|
- /* 820 字节走静态工作区, 不放栈上(tshell 栈也未必够, 且 main 栈只有 2KB) */
|
|
|
- param_persist_t *snap = &g_dbg_dump;
|
|
|
- uint32_t seq = 0;
|
|
|
-
|
|
|
- if (param_backup_read(snap, &seq) != 0)
|
|
|
- {
|
|
|
- rt_kprintf("no valid snapshot\n");
|
|
|
- return;
|
|
|
- }
|
|
|
- rt_kprintf("seq : %u\n", (unsigned)seq);
|
|
|
- rt_kprintf("iSave : %d\n", snap->iSave);
|
|
|
- rt_kprintf("dtype : %d\n", snap->dtype);
|
|
|
- rt_kprintf("ver_type : %d\n", snap->version_type);
|
|
|
- rt_kprintf("rebootcnt : %d\n", (int)snap->rebootcnt);
|
|
|
- rt_kprintf("tph/tpl : %d/%d\n", snap->tph, snap->tpl);
|
|
|
- rt_kprintf("thsp : %d\n", snap->thsp);
|
|
|
- rt_kprintf("dattim : %d\n", snap->dattim);
|
|
|
- rt_kprintf("sunBar : %d\n", snap->sunBar);
|
|
|
- rt_kprintf("clt/heat : %d/%d\n", snap->clt_time, snap->heattime);
|
|
|
- rt_kprintf("start/stop: %d/%d\n", snap->startBar, snap->stopBar);
|
|
|
- rt_kprintf("imei : %s\n", snap->imei);
|
|
|
- rt_kprintf("deviceId : %s\n", snap->deviceId);
|
|
|
- rt_kprintf("platform : %s\n", snap->mqttcfg1);
|
|
|
- rt_kprintf("health : 0x%x\n", param_check_health(snap));
|
|
|
-}
|
|
|
-MSH_CMD_EXPORT(param_dump, dump param snapshot from backup partition);
|
|
|
-
|
|
|
-static void param_save_now(void)
|
|
|
-{
|
|
|
- int ret = param_flush_force();
|
|
|
- rt_kprintf("param_flush_force ret=%d\n", ret);
|
|
|
-}
|
|
|
-MSH_CMD_EXPORT(param_save_now, force save device_status to backup partition);
|
|
|
-
|
|
|
-static void param_restore(void)
|
|
|
-{
|
|
|
- param_persist_t *snap = &g_dbg_restore; /* 私有缓冲, 不与 g_work 抢 */
|
|
|
-
|
|
|
- if (param_backup_read(snap, RT_NULL) != 0)
|
|
|
- {
|
|
|
- rt_kprintf("no valid snapshot to restore\n");
|
|
|
- return;
|
|
|
- }
|
|
|
- param_unpack(snap);
|
|
|
- rt_kprintf("restored to RAM. run 'param_save_ef' to fix easyflash\n");
|
|
|
-}
|
|
|
-MSH_CMD_EXPORT(param_restore, restore device_status from backup partition);
|
|
|
-
|
|
|
-static void param_save_ef(void)
|
|
|
-{
|
|
|
- int n;
|
|
|
-
|
|
|
- if (g_lock != RT_NULL) rt_mutex_take(g_lock, RT_WAITING_FOREVER);
|
|
|
- param_pack(&g_work);
|
|
|
- n = param_write_back_to_easyflash(&g_work);
|
|
|
- if (g_lock != RT_NULL) rt_mutex_release(g_lock);
|
|
|
- rt_kprintf("write back %d items to easyflash\n", n);
|
|
|
-}
|
|
|
-MSH_CMD_EXPORT(param_save_ef, write device_status back to easyflash);
|
|
|
-
|
|
|
-/* ★ 存储链路体检(2026-09-24 上板定位用)。
|
|
|
- 现场报"丢参数/起不来"时先敲这个: 一眼看出是 FAL 没建表、flash 没探测到,
|
|
|
- 还是分区/快照的问题, 不用猜。 */
|
|
|
-static void param_stat(void)
|
|
|
-{
|
|
|
- rt_kprintf("fal_init_check : %d (1=FAL 建表成功, 0=所有 fal_partition_find 会断言死循环)\n",
|
|
|
- fal_init_check());
|
|
|
- rt_kprintf("nor_flash0_ready : %d (0=SPI flash 未探测到, 已走降级 RAM 参数)\n",
|
|
|
- nor_flash0_is_ready());
|
|
|
- rt_kprintf("param_a / param_b: %s / %s\n",
|
|
|
- g_part_a ? g_part_a->name : "NULL", g_part_b ? g_part_b->name : "NULL");
|
|
|
- rt_kprintf("g_disabled : %d\n", (int)g_disabled);
|
|
|
- rt_kprintf("last_seq : %u\n", (unsigned)g_last_seq);
|
|
|
- rt_kprintf("dirty : %d\n", (int)g_dirty);
|
|
|
-}
|
|
|
-MSH_CMD_EXPORT(param_stat, show param storage health (FAL/flash/partitions));
|
|
|
-#endif /* RT_USING_FINSH */
|