桌面墨水屏信息牌：从自己的 JSON 显示天气和待办

// ---- network_config.h ----
// SPDX-License-Identifier: MIT
#pragma once
#if defined(D05_BUILD_NETWORK_CHECK)
static const char WIFI_SSID[]="DO_NOT_CONNECT_BUILD_ONLY";
static const char WIFI_PASSWORD[]="PUBLIC_COMPILE_ONLY_PASSWORD";
static const char INFO_URL[]="http://192.0.2.1:8080/data";
static const char NTP_SERVER[]="192.0.2.123";
#elif __has_include("network_config_local.h")
#include "network_config_local.h"
#else
static const char WIFI_SSID[]="REPLACE_WITH_2G4_SSID";
static const char WIFI_PASSWORD[]="REPLACE_WITH_PASSWORD";
static const char INFO_URL[]="";
static const char NTP_SERVER[]="";
#endif
// ---- network_config_local.example.h ----
// SPDX-License-Identifier: MIT
#pragma once
// Copy to network_config_local.h, edit locally; do not publish real credentials.
static const char WIFI_SSID[]="REPLACE_WITH_2G4_SSID";
static const char WIFI_PASSWORD[]="REPLACE_WITH_PASSWORD";
static const char INFO_URL[]="http://REPLACE_WITH_YOUR_SERVER_IP:8080/data";
static const char NTP_SERVER[]="REPLACE_WITH_YOUR_NTP_SERVER";

# ---- server/test_server.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Trusted-LAN teaching source. Default is unconfigured; --demo is synthetic, never weather measurement."""
import argparse
import json
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path


def payload(mode, demo, source_file):
    if demo:
        data = {"schema": 1, "observed_at": int(time.time()), "temperature_c": 23.5,
                "weather": "CLOUDY", "todo": "Water plants", "source": "DEMO"}
    elif source_file:
        data = json.loads(Path(source_file).read_text(encoding="utf-8"))
    else:
        data = {"status": "UNCONFIGURED: use your data file or explicit --demo"}
    if mode in {"stale", "future", "missing", "large"} and "observed_at" in data:
        data["source"] = "DEMO"  # Fault-injected derivative is not an unmodified manual observation.
    if mode == "stale" and "observed_at" in data:
        data["observed_at"] = int(time.time()) - 7200
    if mode == "future" and "observed_at" in data:
        data["observed_at"] = int(time.time()) + 3600
    if mode == "missing":
        data.pop("todo", None)
    if mode == "large":
        data["todo"] = "X" * 1500
    return data


def handler(demo=False, source_file=None):
    class Handler(BaseHTTPRequestHandler):
        def do_GET(self):
            mode = self.path.split("?", 1)[0].strip("/")
            if mode not in {"data", "stale", "future", "missing", "large", "slow", "malformed", "error"}:
                self.send_error(404)
                return
            if mode == "slow":
                time.sleep(3)
            status = 503 if mode == "error" else 200
            try:
                body = b"{broken" if mode == "malformed" else json.dumps(payload(mode, demo, source_file), ensure_ascii=True).encode()
            except (OSError, ValueError) as error:
                status, body = 500, json.dumps({"error": str(error)}).encode()
            self.send_response(status)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(body)))
            self.send_header("Cache-Control", "no-store")
            self.end_headers()
            try:
                self.wfile.write(body)
            except (BrokenPipeError, ConnectionResetError):
                pass  # Expected when a timeout-test client already left.

        def log_message(self, *_):
            pass

    return Handler


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--bind", default="127.0.0.1", help="Use own LAN address only when intentionally allowing the board")
    parser.add_argument("--port", type=int, default=8080)
    group = parser.add_mutually_exclusive_group()
    group.add_argument("--demo", action="store_true", help="explicit synthetic weather/todo, source always DEMO")
    group.add_argument("--file", help="your edited JSON; observed_at is observation time, never rewritten by /data")
    args = parser.parse_args()
    print(f"Listening on {args.bind}:{args.port}; source={'SYNTHETIC DEMO' if args.demo else args.file or 'UNCONFIGURED'}", flush=True)
    ThreadingHTTPServer((args.bind, args.port), handler(args.demo, args.file)).serve_forever()


if __name__ == "__main__":
    main()

// ---- InfoModel.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <string.h>
namespace info {
constexpr size_t BODY_LIMIT=1024;
struct Payload {uint32_t observed=0;int16_t tenths=0;bool demo=false;char weather[16]={},todo[32]={};};
inline bool textOk(const char* b,size_t n,size_t limit){if(!b||n<1||n>limit||strlen(b)!=n)return false;bool visible=false;for(size_t i=0;i<n;++i){if((unsigned char)b[i]<32||(unsigned char)b[i]>126)return false;if(b[i]!=' ')visible=true;}return visible;}
enum Fetch{CONFIG_NEEDED,OFFLINE,CONNECTING,HTTP_ERROR,BODY_ERROR,BAD_FIELDS,OK};
inline const char* fetchName(Fetch f){switch(f){case CONFIG_NEEDED:return "CONFIG NEEDED";case OFFLINE:return "OFFLINE";case CONNECTING:return "CONNECTING";case HTTP_ERROR:return "HTTP ERROR";case BODY_ERROR:return "BODY ERROR";case BAD_FIELDS:return "BAD FIELDS";case OK:return "OK";}return "?";}
enum Cache{EMPTY,LOADED,SAVED,SAVE_FAILED,BAD_CACHE};
inline const char* cacheName(Cache c){switch(c){case EMPTY:return "NONE";case LOADED:return "LOADED";case SAVED:return "SAVED";case SAVE_FAILED:return "ERROR";case BAD_CACHE:return "BAD";}return "?";}
struct State {Cache cache=EMPTY;int httpCode=0;bool have=false,timeTrusted=false,receivedThisBoot=false;Payload payload;Fetch fetch=CONFIG_NEEDED;uint64_t syncedAt=0,receivedAt=0;};
inline bool trusted(const State& s,uint64_t now){return s.timeTrusted&&now>=s.syncedAt&&now-s.syncedAt<=7200000;}
inline void expireTrust(State& s,uint64_t now){if(s.timeTrusted&&!trusted(s,now))s.timeTrusted=false;}
inline const char* status(const State& s,uint64_t mono,uint32_t epoch){
 if(!s.have)return "NO CACHE";
 if(!trusted(s,mono))return "TIME UNKNOWN";
 if(uint64_t(s.payload.observed)>uint64_t(epoch)+5)return "FUTURE CACHE";
 if(epoch>=s.payload.observed&&epoch-s.payload.observed>900)return "STALE CACHE";
 if(s.fetch==OFFLINE||s.fetch==CONNECTING)return "OFFLINE CACHE";
 if(s.fetch!=OK)return "FETCH ERR CACHE";
 return "FRESH CACHE";
}
inline int64_t ageSeconds(const State& s,uint64_t mono,uint32_t epoch){if(!s.have||!trusted(s,mono))return -1;if(epoch<s.payload.observed)return s.payload.observed-epoch<=5?0:-1;return int64_t(epoch-s.payload.observed);}
inline uint32_t crc32(const uint8_t* b,size_t n){uint32_t c=0xffffffff;for(size_t i=0;i<n;++i){c^=b[i];for(int k=0;k<8;++k)c=(c&1)?(c>>1)^0xedb88320u:c>>1;}return ~c;}
constexpr size_t CACHE_SIZE=128;
inline void put32(uint8_t* b,uint32_t n){for(int i=0;i<4;++i)b[i]=uint8_t(n>>(8*i));}
inline uint32_t get32(const uint8_t* b){uint32_t n=0;for(int i=0;i<4;++i)n|=uint32_t(b[i])<<(8*i);return n;}
inline bool payloadOk(const Payload& p){return p.observed>=1577836800u&&p.observed<=4102444800u&&p.tenths>=-500&&p.tenths<=600&&textOk(p.weather,strnlen(p.weather,sizeof p.weather),15)&&textOk(p.todo,strnlen(p.todo,sizeof p.todo),28);}
inline void encode(const Payload& p,uint8_t b[CACHE_SIZE]){memset(b,0,CACHE_SIZE);memcpy(b,"D05C",4);b[4]=1;b[5]=p.demo;b[6]=CACHE_SIZE;put32(b+8,p.observed);uint16_t t=uint16_t(p.tenths);b[12]=t;b[13]=t>>8;memcpy(b+16,p.weather,strlen(p.weather));memcpy(b+32,p.todo,strlen(p.todo));put32(b+124,crc32(b,124));}
inline bool decode(const uint8_t* b,size_t n,Payload& out){
 if(!b||n!=CACHE_SIZE||memcmp(b,"D05C",4)||b[4]!=1||b[5]>1||b[6]!=CACHE_SIZE||b[7]||b[14]||b[15]||get32(b+124)!=crc32(b,124))return false;
 for(size_t i=64;i<124;++i)if(b[i])return false;
 if(!memchr(b+16,0,16)||!memchr(b+32,0,32))return false;
 Payload p;p.observed=get32(b+8);uint16_t raw=uint16_t(b[12])|(uint16_t(b[13])<<8);p.tenths=int16_t(raw>=32768?int(raw)-65536:int(raw));p.demo=b[5];memcpy(p.weather,b+16,16);memcpy(p.todo,b+32,32);
 if(!payloadOk(p))return false;
 out=p;return true;
}
}
// ---- JsonPayload.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <ArduinoJson.h>
#include <math.h>
#include "InfoModel.h"
namespace info {
// This reader shares its cursor so the bytes after the parsed object can be checked.
struct Reader {const char* data;size_t length;size_t* at;int read(){return *at<length?(unsigned char)data[(*at)++]:-1;}size_t readBytes(char* out,size_t n){size_t k=0;while(k<n&&*at<length)out[k++]=data[(*at)++];return k;}};
inline bool parse(const char* body,size_t length,Payload& out){
 if(!body||length==0||length>BODY_LIMIT)return false;
 JsonDocument doc;size_t at=0;Reader reader{body,length,&at};
 auto error=deserializeJson(doc,reader,DeserializationOption::NestingLimit(3));
 if(error||!doc.is<JsonObject>())return false;
 for(;at<length;++at)if(body[at]!=' '&&body[at]!='\r'&&body[at]!='\n'&&body[at]!='\t')return false;
 if(!doc["schema"].is<unsigned>()||doc["schema"].as<unsigned>()!=1||!doc["observed_at"].is<uint32_t>()||!doc["temperature_c"].is<double>())return false;
 double t=doc["temperature_c"].as<double>();if(!isfinite(t)||t< -50||t>60)return false;
 if(!doc["weather"].is<const char*>()||!doc["todo"].is<const char*>()||!doc["source"].is<const char*>())return false;
 JsonString w=doc["weather"].as<JsonString>(),todo=doc["todo"].as<JsonString>(),src=doc["source"].as<JsonString>();
 if(!textOk(w.c_str(),w.size(),15)||!textOk(todo.c_str(),todo.size(),28)||!textOk(src.c_str(),src.size(),6))return false;
 if(strcmp(src.c_str(),"DEMO")&&strcmp(src.c_str(),"MANUAL"))return false;
 Payload p;p.observed=doc["observed_at"].as<uint32_t>();p.tenths=int16_t(lround(t*10));p.demo=!strcmp(src.c_str(),"DEMO");memcpy(p.weather,w.c_str(),w.size());memcpy(p.todo,todo.c_str(),todo.size());
 if(!payloadOk(p))return false;
 out=p;return true;
}
}

// ---- BusyBudget.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
struct BusyBudget {
 static constexpr uint32_t limitMs=8000;
 uint32_t started=0;bool active=false;bool fault=false;
 void begin(uint32_t now){started=now;active=true;fault=false;}
 void observe(uint32_t now,bool busy){if(active&&busy&&uint32_t(now-started)>=limitMs)fault=true;}
 bool finish(uint32_t now,bool busy){observe(now,busy);active=false;if(busy)fault=true;return !fault;}
};
inline bool refresh_due(uint32_t now,uint32_t last,bool attempted){return !attempted||uint32_t(now-last)>=180000;}
// ---- Retry.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
namespace info {
struct Retry {
 bool attempting=false;uint32_t attemptAt=0,nextTry=0,backoff=2000;
 void dropped(uint32_t now){attempting=false;nextTry=now;backoff=2000;}
 bool timedOut(uint32_t now)const{return attempting&&uint32_t(now-attemptAt)>=15000;}
 void failed(uint32_t now){attempting=false;nextTry=now+backoff;backoff=backoff>=16000?30000:backoff*2;}
 bool due(uint32_t now)const{return !attempting&&int32_t(now-nextTry)>=0;}
 void began(uint32_t now){attempting=true;attemptAt=now;}
 void online(){attempting=false;backoff=2000;}
};
}
// ---- esp32-epaper-info-board.ino ----
// SPDX-License-Identifier: MIT
#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Preferences.h>
#include <SPI.h>
#include <GxEPD2_BW.h>
#include <gdey/GxEPD2_213_GDEY0213B74.h>
#include <esp_sntp.h>
#include <esp_timer.h>
#include <time.h>
#include "network_config.h"
#include "JsonPayload.h"
#include "BusyBudget.h"
#include "Retry.h"
constexpr int EPD_SCK=12,EPD_MOSI=11,EPD_CS=5,EPD_DC=4,EPD_RES=6,EPD_BUSY=10;
constexpr uint32_t REFRESH_MS=180000;
SPIClass epdSPI(FSPI);
GxEPD2_BW<GxEPD2_213_GDEY0213B74,GxEPD2_213_GDEY0213B74::HEIGHT>
 display(GxEPD2_213_GDEY0213B74(EPD_CS,EPD_DC,EPD_RES,EPD_BUSY));
QueueHandle_t snapshots,ntpNotices;
BusyBudget busyBudget;
bool displayHalted=false;
uint32_t lastAttempt=0;
uint64_t monoMs(){return uint64_t(esp_timer_get_time()/1000);}
void timeSynced(struct timeval*){uint64_t at=monoMs();xQueueOverwrite(ntpNotices,&at);}
void busyCallback(const void*){busyBudget.observe(millis(),digitalRead(EPD_BUSY)==HIGH);delay(1);}
bool networkConfigured(){return strlen(WIFI_SSID)>0&&strlen(WIFI_SSID)<=32&&strcmp(WIFI_SSID,"REPLACE_WITH_2G4_SSID")&&strlen(WIFI_PASSWORD)>=8&&strlen(WIFI_PASSWORD)<=63&&strcmp(WIFI_PASSWORD,"REPLACE_WITH_PASSWORD")&&strlen(INFO_URL)>7&&strlen(INFO_URL)<=200&&!strncmp(INFO_URL,"http://",7);}
bool timeConfigured(){return strlen(NTP_SERVER)>0&&strlen(NTP_SERVER)<=128&&strncmp(NTP_SERVER,"REPLACE_",8)&&!strstr(NTP_SERVER,"://");}
info::Fetch fetchPayload(info::Payload& out,int& status){
 NetworkClient tcp;HTTPClient http;http.setConnectTimeout(1500);http.setTimeout(1500);http.setFollowRedirects(HTTPC_DISABLE_FOLLOW_REDIRECTS);http.setReuse(false);
 if(!http.begin(tcp,INFO_URL)){status=-1000;return info::HTTP_ERROR;}
 const char* keys[]={"Transfer-Encoding"};http.collectHeaders(keys,1);
 http.addHeader("Accept","application/json");status=http.GET();
 if(status!=200){http.end();return info::HTTP_ERROR;}
 String encoding=http.header("Transfer-Encoding");encoding.trim();if(encoding.length()&&!encoding.equalsIgnoreCase("identity")){http.end();return info::BODY_ERROR;}
 int length=http.getSize();if(length<=0||length>int(info::BODY_LIMIT)){http.end();return info::BODY_ERROR;}
 char body[info::BODY_LIMIT+1];size_t used=0;uint32_t started=millis();NetworkClient* stream=http.getStreamPtr();
 if(!stream){http.end();return info::BODY_ERROR;}
 while(used<size_t(length)&&uint32_t(millis()-started)<2000){
  int available=stream->available();
  if(available>0){size_t want=size_t(available);if(want>size_t(length)-used)want=size_t(length)-used;int n=stream->read((uint8_t*)body+used,want);if(n>0)used+=size_t(n);}
  else if(!stream->connected())break;
  delay(1);
 }
 http.end();if(used!=size_t(length))return info::BODY_ERROR;body[used]=0;
 return info::parse(body,used,out)?info::OK:info::BAD_FIELDS;
}
void worker(void*){
 info::State state;Preferences prefs;bool storeReady=prefs.begin("d05-v1",false);uint8_t lastStored[info::CACHE_SIZE]={};bool stored=false;
 if(!storeReady){state.cache=info::SAVE_FAILED;Serial.println("STORE ERROR: cache is RAM only");}
 else{size_t len=prefs.getBytesLength("cache");if(len){if(len==sizeof lastStored&&prefs.getBytes("cache",lastStored,sizeof lastStored)==sizeof lastStored&&info::decode(lastStored,len,state.payload)){state.have=true;state.cache=info::LOADED;stored=true;Serial.println("BOOT CACHE: payload restored, time untrusted until this boot syncs");}else{state.cache=info::BAD_CACHE;Serial.println("BAD CACHE: ignored, no default weather inserted");}}}
 bool configured=networkConfigured(),ntpStarted=false,wasOnline=false;
 info::Retry retry;
 uint32_t lastPoll=0,lastReport=0;
 if(configured){WiFi.persistent(false);WiFi.mode(WIFI_STA);WiFi.setAutoReconnect(false);}else Serial.println("CONFIG NEEDED: edit network_config_local.h; no Wi-Fi/HTTP attempt");
 xQueueOverwrite(snapshots,&state);
 for(;;){
  uint64_t notice;if(xQueueReceive(ntpNotices,&notice,0)==pdTRUE){state.timeTrusted=true;state.syncedAt=notice;Serial.println("TIME SYNC NOTICE: observed this boot; server not authenticated");}
  uint32_t now=millis();uint64_t mono=monoMs();info::expireTrust(state,mono);bool online=configured&&WiFi.status()==WL_CONNECTED;
  if(!configured)state.fetch=info::CONFIG_NEEDED;
  else if(!online){
   state.fetch=info::OFFLINE;
   if(wasOnline){retry.dropped(now);Serial.println("WIFI lost: new retry timebase");}
   if(retry.timedOut(now)){WiFi.disconnect(false,false);retry.failed(now);Serial.println("WIFI attempt deadline; backoff scheduled");}
   if(retry.due(now)){WiFi.begin(WIFI_SSID,WIFI_PASSWORD);retry.began(now);state.fetch=info::CONNECTING;}
  }else{
   retry.online();
   if(!wasOnline){Serial.print("ONLINE IP=");Serial.println(WiFi.localIP());}
   if(!ntpStarted&&timeConfigured()){sntp_set_time_sync_notification_cb(timeSynced);configTime(0,0,NTP_SERVER);ntpStarted=true;}
   if(!wasOnline||uint32_t(now-lastPoll)>=60000){
    lastPoll=now;info::Payload candidate;state.fetch=fetchPayload(candidate,state.httpCode);
    if(state.fetch==info::OK){
     state.payload=candidate;state.have=true;state.receivedThisBoot=true;state.receivedAt=monoMs();
     uint8_t encoded[info::CACHE_SIZE];info::encode(candidate,encoded);
     if(storeReady&&(!stored||memcmp(encoded,lastStored,sizeof encoded))){if(prefs.putBytes("cache",encoded,sizeof encoded)==sizeof encoded){memcpy(lastStored,encoded,sizeof encoded);stored=true;state.cache=info::SAVED;}else state.cache=info::SAVE_FAILED;}
    }
    Serial.printf("FETCH code=%d result=%s retained_payload=%u observed=%lu source=%s\n",state.httpCode,info::fetchName(state.fetch),state.have,(unsigned long)state.payload.observed,state.have?(state.payload.demo?"DEMO":"MANUAL"):"NONE");
   }
  }
  xQueueOverwrite(snapshots,&state);
  if(uint32_t(now-lastReport)>=10000){lastReport=now;Serial.printf("STATE %s fetch=%s store=%s time_trusted=%u; physical page is a dated snapshot\n",info::status(state,monoMs(),uint32_t(time(nullptr))),info::fetchName(state.fetch),info::cacheName(state.cache),info::trusted(state,monoMs()));}
  wasOnline=online;vTaskDelay(pdMS_TO_TICKS(200));
 }
}
void lineAt(int y,const char* s){display.setCursor(5,y);display.print(s);}
void utc(uint32_t epoch,char out[24]){time_t t=epoch;struct tm tm;if(!gmtime_r(&t,&tm)||!strftime(out,24,"%Y-%m-%d %H:%MZ",&tm))strcpy(out,"NA");}
bool preflight(){uint32_t start=millis();while(digitalRead(EPD_BUSY)==HIGH&&uint32_t(millis()-start)<2000)delay(1);return digitalRead(EPD_BUSY)==LOW;}
void render(const info::State& s){
 if(!preflight()){displayHalted=true;Serial.println("DISPLAY STOP: BUSY high before call; no display transaction");return;}
 uint64_t mono=monoMs();uint32_t epoch=uint32_t(time(nullptr));bool clockOk=info::trusted(s,mono);char page[24]="UPTIME ONLY",observed[24]="NA";if(clockOk)utc(epoch,page);if(s.have)utc(s.payload.observed,observed);
 uint32_t started=millis();busyBudget.begin(started);display.init(115200,true,10,false);display.setRotation(1);display.setFullWindow();display.setTextColor(GxEPD_BLACK);display.setTextSize(1);display.setTextWrap(false);
 display.firstPage();
 do{
  char b[64];display.fillScreen(GxEPD_WHITE);display.drawRect(0,0,250,122,GxEPD_BLACK);
  snprintf(b,sizeof b,"SNAPSHOT %s",info::status(s,mono,epoch));lineAt(4,b);
  if(clockOk)snprintf(b,sizeof b,"PAGE %s",page);else snprintf(b,sizeof b,"PAGE UPTIME %llu S",(unsigned long long)(mono/1000));lineAt(17,b);
  if(s.have){int t=s.payload.tenths;unsigned a=t<0?unsigned(-t):unsigned(t);snprintf(b,sizeof b,"%s %s %s%u.%u C",s.payload.demo?"DEMO":"MANUAL",s.payload.weather,t<0?"-":"",a/10,a%10);lineAt(30,b);snprintf(b,sizeof b,"TODO %s",s.payload.todo);lineAt(43,b);}else{lineAt(30,"NO WEATHER / NO TODO");lineAt(43,"Configure your own JSON source");}
  snprintf(b,sizeof b,"OBS %s",observed);lineAt(56,b);
  int64_t age=info::ageSeconds(s,mono,epoch);if(age<0)snprintf(b,sizeof b,"AGE@PAGE UNKNOWN");else snprintf(b,sizeof b,"AGE@PAGE %lld S",(long long)age);lineAt(69,b);
  if(s.receivedThisBoot)snprintf(b,sizeof b,"FETCH AGE@PAGE %llu S",(unsigned long long)((mono>=s.receivedAt?mono-s.receivedAt:0)/1000));else snprintf(b,sizeof b,"FETCH AGE UNKNOWN / BOOT CACHE");lineAt(82,b);
  snprintf(b,sizeof b,"HTTP %d %s",s.httpCode,info::fetchName(s.fetch));lineAt(95,b);
  snprintf(b,sizeof b,"CLOCK %s STORE %s",clockOk?"OK":"UNKNOWN",info::cacheName(s.cache));lineAt(108,b);
 }while(display.nextPage());
 uint32_t elapsed=millis()-started;
 if(!busyBudget.finish(millis(),digitalRead(EPD_BUSY)==HIGH)){displayHalted=true;Serial.printf("DISPLAY STOP after API returned call_ms=%lu; no further panel calls\n",(unsigned long)elapsed);return;}
 Serial.printf("PANEL_API_RETURN_BUSY_LOW call_ms=%lu; optical completion not measured\n",(unsigned long)elapsed);
 busyBudget.begin(millis());display.hibernate();if(!busyBudget.finish(millis(),digitalRead(EPD_BUSY)==HIGH)){displayHalted=true;Serial.println("DISPLAY STOP: hibernate result fault");}
}
void setup(){
 Serial.begin(115200);delay(300);pinMode(EPD_BUSY,INPUT);digitalWrite(EPD_CS,HIGH);pinMode(EPD_CS,OUTPUT);
 snapshots=xQueueCreate(1,sizeof(info::State));ntpNotices=xQueueCreate(1,sizeof(uint64_t));if(!snapshots||!ntpNotices){displayHalted=true;Serial.println("STOP queue allocation");return;}
 if(!epdSPI.begin(EPD_SCK,-1,EPD_MOSI,EPD_CS)){displayHalted=true;Serial.println("STOP SPI begin");return;}
 display.epd2.selectSPI(epdSPI,SPISettings(4000000,MSBFIRST,SPI_MODE0));display.epd2.setBusyCallback(busyCallback);
 if(xTaskCreate(worker,"json_worker",8192,nullptr,2,nullptr)!=pdPASS){displayHalted=true;Serial.println("STOP worker allocation");return;}
 lastAttempt=millis();Serial.println("D05 READY: first panel attempt after 180s; all pages are dated snapshots, not live status");
}
void loop(){
 if(!displayHalted&&uint32_t(millis()-lastAttempt)>=REFRESH_MS){info::State s;if(xQueuePeek(snapshots,&s,0)==pdTRUE){lastAttempt=millis();render(s);}}
 delay(10);
}