S4：工程化——从「能跑」到「装在墙上跑三十天没人管」

# 装工具链
sudo apt install -y gcc-aarch64-linux-gnu

# 一条命令搞定
aarch64-linux-gnu-gcc -std=c11 -Wall -Wextra -Werror -O2 \
    -o gw-collector gw-collector.c -lmosquitto

# 确认架构对不对（关键一步，别跳）
file gw-collector
# 期望：ELF 64-bit LSB executable, ARM aarch64

# 板子上
dpkg -L libmosquitto1 | grep '\.so'

# PC 上
scp pi:/usr/lib/aarch64-linux-gnu/libmosquitto.so.1 ./libs/
aarch64-linux-gnu-gcc -o app app.c -L./libs -lmosquitto

# 把板子的 /usr/include 和 /usr/lib 整个同步到 PC
rsync -av pi:/usr/include/  /opt/rpi-sysroot/usr/include/
rsync -av pi:/usr/lib/aarch64-linux-gnu/ /opt/rpi-sysroot/usr/lib/aarch64-linux-gnu/

aarch64-linux-gnu-gcc --sysroot=/opt/rpi-sysroot -o app app.c -lmosquitto

/* ESP32 任务看门狗（Task WDT） */
#include "esp_task_wdt.h"

#define WDT_TIMEOUT_S 10

void app_main(void)
{
    /* 初始化：超时 10 秒 */
    esp_task_wdt_init(WDT_TIMEOUT_S, true);   /* true = 超时触发 panic 重启 */
    esp_task_wdt_add(NULL);                   /* 把自己这个任务加进去 */

    for (;;) {
        do_work();
        esp_task_wdt_reset();                 /* 喂狗：必须在业务真正做完之后 */
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

# 树莓派启用硬件看门狗
echo 'dtparam=watchdog=on' | sudo tee -a /boot/firmware/config.txt
sudo systemctl enable watchdog

# 应用层用 /dev/watchdog

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/watchdog.h>

int wdt_open(int timeout_s)
{
    int fd = open("/dev/watchdog", O_WRONLY);
    if (fd < 0) return -1;
    ioctl(fd, WDIOC_SETTIMEOUT, &timeout_s);
    return fd;
}

/* 主循环里定期调用 */
void wdt_feed(int fd) { write(fd, "x", 1); }

/* ❌ 错误：在循环顶部无脑喂 */
for (;;) {
    esp_task_wdt_reset();     /* 只要循环转着就一直喂 */
    do_work();                /* ← 这里卡死 10 分钟也照喂不误 */
}

/* ✅ 正确：业务真的完成之后才喂 */
for (;;) {
    int rc = do_work();       /* 卡在这里 → 没人喂 → 看门狗复位 */
    if (rc == 0) esp_task_wdt_reset();
}

# /etc/systemd/system/gw-collector.service
[Unit]
Description=Gateway MQTT collector
After=network-online.target mosquitto.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/opt/gw/bin/gw-collector
Restart=always
RestartSec=3

# 软件看门狗：60 秒内没有 sd_notify(WATCHDOG=1) 就判定卡死
WatchdogSec=60

[Install]
WantedBy=multi-user.target

#include <systemd/sd-daemon.h>

int main(void)
{
    /* 告诉 systemd：我起来了 */
    sd_notify(0, "READY=1");

    for (;;) {
        int rc = poll_and_forward();   /* 真正的业务 */

        /* 只有业务成功才告诉 systemd「我还健康」 */
        if (rc == 0) {
            sd_notify(0, "WATCHDOG=1");
        }

        usleep(10 * 1000);
    }
}

# 树莓派每分钟发一次心跳
*/1 * * * * curl -s -m 5 -X POST http://gateway.local/api/hb \
             -d "dev=$(hostname)&ts=$(date +%s)&up=$(uptime -s)"

# 概念示意：连续 3 次没收到 → 判定离线
if now - last_seen > 180:
    alert(f"{dev} 失联超过 3 分钟")

#include "esp_ota_ops.h"
#include "esp_http_client.h"

esp_err_t ota_update(const char *url)
{
    const esp_partition_t *running = esp_ota_get_running_partition();
    const esp_partition_t *update  = esp_ota_get_next_update_partition(NULL);
    if (!update) return ESP_ERR_NOT_FOUND;

    esp_ota_handle_t handle = 0;
    esp_err_t err = esp_ota_begin(update, OTA_SIZE_UNKNOWN, &handle);
    if (err != ESP_OK) return err;

    /* 下载并分块写入（不要一次读进内存） */
    esp_http_client_config_t cfg = { .url = url };
    esp_http_client_handle_t cli = esp_http_client_init(&cfg);
    esp_http_client_open(cli, 0);

    char buf[1024];
    int total = 0;
    while (1) {
        int n = esp_http_client_read(cli, buf, sizeof(buf));
        if (n < 0) { esp_ota_abort(handle); return ESP_FAIL; }
        if (n == 0) break;
        if ((err = esp_ota_write(handle, buf, n)) != ESP_OK) {
            esp_ota_abort(handle);
            return err;
        }
        total += n;
    }
    esp_http_client_close(cli);
    esp_http_client_cleanup(cli);

    /* 这一步会校验镜像完整性 —— 不能省 */
    if ((err = esp_ota_end(handle)) != ESP_OK) return err;

    /* 切换启动分区，但还没确认 */
    if ((err = esp_ota_set_boot_partition(update)) != ESP_OK) return err;

    ESP_LOGI("OTA", "written %d bytes, rebooting", total);
    esp_restart();
    return ESP_OK;
}

void app_main(void)
{
    /* 1. 启动后先看自己是不是「未确认」的新固件 */
    const esp_partition_t *running = esp_ota_get_running_partition();
    esp_ota_img_states_t state;
    bool pending_verify = false;

    if (esp_ota_get_state_partition(running, &state) == ESP_OK) {
        if (state == ESP_OTA_IMG_PENDING_VERIFY) pending_verify = true;
    }

    /* 2. 做真正的自检：连网、连 Broker、读一次传感器 */
    bool healthy = false;
    for (int i = 0; i < 5 && !healthy; i++) {
        healthy = (wifi_connect() == 0) &&
                  (mqtt_connect() == 0) &&
                  (sht30_probe() == 0);
        if (!healthy) vTaskDelay(pdMS_TO_TICKS(2000));
    }

    /* 3. 自检通过 → 确认；否则不确认，等看门狗复位后自动回滚 */
    if (pending_verify) {
        if (healthy) {
            esp_ota_mark_app_valid_cancel_rollback();
            ESP_LOGI("OTA", "new firmware confirmed");
        } else {
            ESP_LOGE("OTA", "self-check failed, will rollback on reset");
            /* 故意不喂狗，等它复位回旧分区 */
            while (1) { vTaskDelay(pdMS_TO_TICKS(1000)); }
        }
    }

    normal_business_loop();
}

# /etc/fstab
/dev/mmcblk0p1  /boot/firmware  vfat  ro           0  1
/dev/mmcblk0p2  /               ext4  ro           0  1
tmpfs           /var/log        tmpfs defaults,noatime,size=64M  0  0
tmpfs           /tmp            tmpfs defaults,noatime,size=64M  0  0
/dev/mmcblk0p3  /data           ext4  rw,noatime   0  2

/* ❌ 原地改：写到一半断电 → 配置文件损坏 → 启动读不出来 */
FILE *f = fopen("/data/config.json", "w");
fprintf(f, ...);      /* ← 此刻断电，文件可能只有一半 */
fclose(f);

/* ✅ 写临时文件 + fsync + rename（rename 是原子操作） */
FILE *f = fopen("/data/config.json.tmp", "w");
fprintf(f, ...);
fflush(f);
fsync(fileno(f));           /* ← 关键：强制落盘 */
fclose(f);
rename("/data/config.json.tmp", "/data/config.json");   /* 原子替换 */

/* 顺序错了，断电后「已确认」的数据其实没落盘 */
write(file, data, len);
fsync(file);              /* ← 必须在回 ACK 之前 */
send_ack_to_server();

/* ❌ 没有超时的等网络：网络不通就永远卡在这 */
while (wifi_connect() != 0) { sleep(1); }

/* ✅ 带超时，且失败也要继续跑（降级模式） */
int has_net = 0;
for (int i = 0; i < 30; i++) {
    if (wifi_connect() == 0) { has_net = 1; break; }
    sleep(1);
}
if (!has_net) {
    LOG_WARN("no network, enter degraded mode");
    /* 继续跑：先采集并缓存，等网络恢复再补发 */
}

#include "esp_system.h"

void log_boot_banner(void)
{
    esp_reset_reason_t r = esp_reset_reason();
    const char *why =
        (r == ESP_RST_POWERON)  ? "power-on" :
        (r == ESP_RST_WDT)      ? "watchdog"  :
        (r == ESP_RST_PANIC)    ? "panic"     :
        (r == ESP_RST_BROWNOUT) ? "brownout"  : "other";
    ESP_LOGI("BOOT", "dev=%s reset_reason=%s", NODE_ID, why);
}

/* ❌ 重启就没了，等于没写 */
freopen("/tmp/app.log", "a", stdout);

/* ✅ 落到 data 分区，且轮转 */

# logrotate 或自己写
if [ $(stat -c%s /data/app.log) -gt 1048576 ]; then
    mv /data/app.log /data/app.log.1
fi

# 每天记一行，30 天后一眼看出来
echo "$(date +%F) $(ps -o rss= -p $(pgrep gw-collector))" >> /data/rss.log

/* ❌ 局域网也别裸跑，尤其经过 WiFi */
.broker.address.uri = "mqtt://192.168.1.10:1883"

/* ✅ TLS */
.broker.address.uri = "mqtts://192.168.1.10:8883",
.broker.verification.certificate = ca_pem_start,

/* ❌ 所有设备一个密码，泄露一台等于全泄 */
.credentials.username = "admin",
.credentials.authentication.password = "123456",

/* ✅ 一机一密，出厂烧进去 */
.credentials.client_id = NODE_ID,
.credentials.authentication.password = device_secret_from_nvs(NODE_ID),

/* ❌ 提交到 git = 永久泄露（历史里删不掉） */
const char *priv_key = "-----BEGIN PRIVATE KEY-----\nMIIE...";

/* ✅ 烧进 NVS / 单独的安全分区 */
esp_err_t load_key_from_nvs(char *out, size_t out_len);