ESP32 对时与时区：断网后时钟还能信吗？

idf.py --version
# 应为ESP-IDF v5.5.5；进入本项目根目录
idf.py set-target esp32s3
idf.py menuconfig
idf.py build
idf.py -p REPLACE_WITH_UART_PORT flash monitor

// SPDX-License-Identifier: MIT
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_netif_sntp.h"
#include "sdkconfig.h"
#include "net.h"
#include "clock_policy.h"
static const char *TAG = "N05";
typedef struct { int64_t mono_ms, epoch; } sync_notice_t;
static QueueHandle_t sync_queue;
// lwIP task callback: copy only, no logging/Wi-Fi calls/calendar conversion.
static void synced(struct timeval *tv) {
    sync_notice_t notice = {.mono_ms = esp_timer_get_time() / 1000, .epoch = tv->tv_sec};
    xQueueOverwrite(sync_queue, &notice); // latest event retained; intermediate notices may coalesce
}
void app_main(void) {
    sync_queue = xQueueCreate(1, sizeof(sync_notice_t));
    if (!sync_queue) { ESP_LOGE(TAG, "queue allocation failed"); return; }
    if (setenv("TZ", CONFIG_DEMO_TZ, 1)) { ESP_LOGE(TAG, "TZ allocation failed"); return; }
    tzset();
    clock_policy_t clock = {0}; // deliberately distrust every new boot until this boot receives SNTP
    bool started = false, server_valid = strlen(CONFIG_DEMO_NTP_SERVER) && strcmp(CONFIG_DEMO_NTP_SERVER, "REPLACE_WITH_NTP_SERVER");
    if (!server_valid) ESP_LOGW(TAG, "NTP_CONFIG_MISSING: clock remains UNSYNCED");
    net_start();
    for (;;) {
        bool online = net_online();
        if (online && server_valid && !started) {
            esp_sntp_config_t cfg = ESP_NETIF_SNTP_DEFAULT_CONFIG(CONFIG_DEMO_NTP_SERVER);
            cfg.sync_cb = synced;
            cfg.wait_for_sync = false;
            cfg.smooth_sync = false; // immediate wall-clock corrections can jump; intervals use monotonic time
            esp_err_t err = esp_netif_sntp_init(&cfg);
            started = err == ESP_OK;
            ESP_LOGI(TAG, "sntp_init=%s", esp_err_to_name(err));
        }
        sync_notice_t notice;
        // Dequeue first, then sample now: a callback in this interval must not look like a future notice.
        const bool has_notice = xQueueReceive(sync_queue, &notice, 0) == pdTRUE;
        const int64_t now_ms = esp_timer_get_time() / 1000;
        if (has_notice && clock_note_sync(&clock, notice.mono_ms, now_ms))
            ESP_LOGI(TAG, "SYNC_NOTICE received_epoch=%" PRId64, notice.epoch);
        time_t now = time(NULL);
        char utc[40] = "NA", local[48] = "NA";
        if (clock.synced) {
            struct tm u, l;
            gmtime_r(&now, &u); localtime_r(&now, &l);
            strftime(utc, sizeof utc, "%Y-%m-%dT%H:%M:%SZ", &u);
            strftime(local, sizeof local, "%Y-%m-%dT%H:%M:%S%z", &l);
        }
        ESP_LOGI(TAG, "uptime_ms=%" PRId64 " epoch=%" PRId64 " state=%s online=%u sync_age_ms=%" PRId64 " notices_observed=%" PRIu32 " utc=%s local=%s TZ=%s",
                 now_ms, (int64_t)now, clock_state(&clock, online, now_ms, (int64_t)CONFIG_DEMO_STALE_SECONDS * 1000),
                 online, clock_age(&clock, now_ms), clock.notices, utc, local, CONFIG_DEMO_TZ);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

cc -std=c11 -Wall -Wextra -Werror host_check.c -o /tmp/n05-host
/tmp/n05-host