631 lines
19 KiB
C++
631 lines
19 KiB
C++
/*
|
||
* Doorbell Touch — Waveshare ESP32-S3-Touch-LCD-4.3 (non-B)
|
||
*
|
||
* Ported from ESP32-C6 + 1.44" TFT_eSPI version.
|
||
*
|
||
* Features:
|
||
* - Polls ntfy.sh topics (ALERT, SILENCE, ADMIN, STATUS)
|
||
* - 800×480 RGB display with blinking neon teal / hot fuchsia alerts
|
||
* - GT911 touch: tap to silence, double-tap to wake status screen
|
||
* - Backlight completely OFF when not alerting
|
||
* - Multi-WiFi support
|
||
* - NTP time sync, message age filtering, deduplication
|
||
* - 30-second boot grace period ignores stale messages
|
||
*/
|
||
|
||
#include <Arduino.h>
|
||
#include <Wire.h>
|
||
#include <WiFi.h>
|
||
#include <WiFiMulti.h>
|
||
#include <HTTPClient.h>
|
||
#include <ArduinoJson.h>
|
||
#include <NTPClient.h>
|
||
#include <WiFiUdp.h>
|
||
#include <Arduino_GFX_Library.h>
|
||
|
||
// =====================================================================
|
||
// WiFi — add as many networks as you like
|
||
// =====================================================================
|
||
struct WiFiCred { const char *ssid; const char *pass; };
|
||
|
||
WiFiCred wifiNetworks[] = {
|
||
{ "Dobro Veče", "goodnight" },
|
||
{ "iot-2GHz", "lesson-greater" },
|
||
};
|
||
const int NUM_WIFI = sizeof(wifiNetworks) / sizeof(wifiNetworks[0]);
|
||
|
||
WiFiMulti wifiMulti;
|
||
|
||
// =====================================================================
|
||
// ntfy.sh Topics
|
||
// =====================================================================
|
||
#define NTFY_BASE "https://ntfy.sh"
|
||
#define ALERT_TOPIC "ALERT_klubhaus_topic"
|
||
#define SILENCE_TOPIC "SILENCE_klubhaus_topic"
|
||
#define ADMIN_TOPIC "ADMIN_klubhaus_topic"
|
||
#define STATUS_TOPIC "STATUS_klubhaus_topic"
|
||
|
||
// =====================================================================
|
||
// Timing
|
||
// =====================================================================
|
||
#define POLL_INTERVAL_MS 5000
|
||
#define BOOT_GRACE_MS 30000
|
||
#define BLINK_INTERVAL_MS 500
|
||
#define ALERT_TIMEOUT_SEC 300 // 5 min auto-silence
|
||
#define MSG_MAX_AGE_SEC 60 // ignore messages older than 60s
|
||
#define WAKE_DISPLAY_MS 5000 // show status screen for 5s
|
||
#define DOUBLE_TAP_WINDOW_MS 500 // max gap between taps
|
||
#define TOUCH_DEBOUNCE_MS 250
|
||
|
||
// =====================================================================
|
||
// RGB565 Colors
|
||
// =====================================================================
|
||
#define COL_BLACK 0x0000
|
||
#define COL_WHITE 0xFFFF
|
||
#define COL_NEON_TEAL 0x07FA // #00FFD0
|
||
#define COL_HOT_PINK 0xF814 // #FF00A0
|
||
#define COL_DARK_GRAY 0x2104
|
||
#define COL_GREEN 0x07E0
|
||
#define COL_RED 0xF800
|
||
#define COL_YELLOW 0xFFE0
|
||
|
||
// =====================================================================
|
||
// I2C
|
||
// =====================================================================
|
||
#define I2C_SDA 8
|
||
#define I2C_SCL 9
|
||
|
||
// =====================================================================
|
||
// CH422G IO Expander (direct Wire — no library needed)
|
||
// =====================================================================
|
||
#define CH422G_SYS 0x24 // system / mode register
|
||
#define CH422G_OUT 0x38 // output register
|
||
#define CH422G_OE 0x01 // enable push-pull outputs
|
||
|
||
#define IO_TP_RST (1 << 1) // touch reset
|
||
#define IO_LCD_BL (1 << 2) // backlight
|
||
#define IO_LCD_RST (1 << 3) // LCD reset
|
||
|
||
static uint8_t ioState = 0; // shadow of CH422G output register
|
||
|
||
void ch422g_write(uint8_t addr, uint8_t data) {
|
||
Wire.beginTransmission(addr);
|
||
Wire.write(data);
|
||
Wire.endTransmission();
|
||
}
|
||
|
||
void setBacklight(bool on) {
|
||
if (on) ioState |= IO_LCD_BL;
|
||
else ioState &= ~IO_LCD_BL;
|
||
ch422g_write(CH422G_OUT, ioState);
|
||
Serial.printf("Backlight %s\n", on ? "ON" : "OFF");
|
||
}
|
||
|
||
// =====================================================================
|
||
// GT911 Touch (direct I2C — avoids driver_ng conflict)
|
||
// =====================================================================
|
||
#define GT911_ADDR1 0x14
|
||
#define GT911_ADDR2 0x5D
|
||
#define GT911_IRQ 4
|
||
|
||
static uint8_t gt911Addr = 0;
|
||
static bool touchAvailable = false;
|
||
|
||
void gt911_writeReg(uint16_t reg, uint8_t val) {
|
||
Wire.beginTransmission(gt911Addr);
|
||
Wire.write(reg >> 8);
|
||
Wire.write(reg & 0xFF);
|
||
Wire.write(val);
|
||
Wire.endTransmission();
|
||
}
|
||
|
||
bool gt911_init() {
|
||
pinMode(GT911_IRQ, INPUT);
|
||
|
||
// Probe both possible addresses
|
||
for (uint8_t addr : { GT911_ADDR1, GT911_ADDR2 }) {
|
||
Wire.beginTransmission(addr);
|
||
if (Wire.endTransmission() == 0) {
|
||
gt911Addr = addr;
|
||
touchAvailable = true;
|
||
Serial.printf("GT911 found at 0x%02X\n", addr);
|
||
return true;
|
||
}
|
||
}
|
||
Serial.println("GT911 not found — touch disabled");
|
||
return false;
|
||
}
|
||
|
||
// Returns true if a touch point was read
|
||
bool gt911_read(int16_t *x, int16_t *y) {
|
||
if (!touchAvailable) return false;
|
||
|
||
// Read status register 0x814E
|
||
Wire.beginTransmission(gt911Addr);
|
||
Wire.write(0x81); Wire.write(0x4E);
|
||
Wire.endTransmission(false);
|
||
Wire.requestFrom(gt911Addr, (uint8_t)1);
|
||
if (!Wire.available()) return false;
|
||
uint8_t status = Wire.read();
|
||
|
||
bool ready = status & 0x80;
|
||
uint8_t pts = status & 0x0F;
|
||
|
||
// Always clear the status flag
|
||
gt911_writeReg(0x814E, 0x00);
|
||
|
||
if (!ready || pts == 0) return false;
|
||
|
||
// Read first touch point from 0x8150 (need 4 bytes: xl, xh, yl, yh)
|
||
Wire.beginTransmission(gt911Addr);
|
||
Wire.write(0x81); Wire.write(0x50);
|
||
Wire.endTransmission(false);
|
||
Wire.requestFrom(gt911Addr, (uint8_t)4);
|
||
if (Wire.available() < 4) return false;
|
||
|
||
uint8_t xl = Wire.read();
|
||
uint8_t xh = Wire.read();
|
||
uint8_t yl = Wire.read();
|
||
uint8_t yh = Wire.read();
|
||
|
||
*x = xl | (xh << 8);
|
||
*y = yl | (yh << 8);
|
||
return true;
|
||
}
|
||
|
||
// =====================================================================
|
||
// RGB Display — correct pin map for 4.3 non-B
|
||
// =====================================================================
|
||
Arduino_ESP32RGBPanel *rgbpanel = new Arduino_ESP32RGBPanel(
|
||
5 /* DE */, 3 /* VSYNC */, 46 /* HSYNC */, 7 /* PCLK */,
|
||
1 /* R0 */, 2 /* R1 */, 42 /* R2 */, 41 /* R3 */, 40 /* R4 */,
|
||
39 /* G0 */, 0 /* G1 */, 45 /* G2 */, 48 /* G3 */, 47 /* G4 */, 21 /* G5 */,
|
||
14 /* B0 */, 38 /* B1 */, 18 /* B2 */, 17 /* B3 */, 10 /* B4 */,
|
||
0, 8, 4, 8, // hsync: pol, fp, pw, bp
|
||
0, 8, 4, 8, // vsync: pol, fp, pw, bp
|
||
1, 16000000 // pclk_neg, speed
|
||
);
|
||
|
||
Arduino_RGB_Display *gfx = new Arduino_RGB_Display(800, 480, rgbpanel, 0, true);
|
||
|
||
// =====================================================================
|
||
// NTP
|
||
// =====================================================================
|
||
WiFiUDP ntpUDP;
|
||
NTPClient timeClient(ntpUDP, "pool.ntp.org", 0, 60000);
|
||
|
||
// =====================================================================
|
||
// Application State
|
||
// =====================================================================
|
||
enum State { ST_IDLE, ST_ALERTING, ST_SILENCED, ST_WAKE };
|
||
|
||
State state = ST_IDLE;
|
||
String alertMessage = "";
|
||
String lastMsgId = "";
|
||
unsigned long bootTime = 0;
|
||
unsigned long lastPoll = 0;
|
||
unsigned long alertStart = 0;
|
||
unsigned long blinkTimer = 0;
|
||
bool blinkPhase = false;
|
||
unsigned long wakeStart = 0;
|
||
|
||
// Touch double-tap tracking
|
||
unsigned long lastTapMs = 0;
|
||
int tapCount = 0;
|
||
|
||
// =====================================================================
|
||
// Drawing Helpers
|
||
// =====================================================================
|
||
void drawCentered(const char *txt, int y, int sz, uint16_t col) {
|
||
gfx->setTextSize(sz);
|
||
gfx->setTextColor(col);
|
||
int w = strlen(txt) * 6 * sz; // approximate pixel width
|
||
gfx->setCursor(max(0, (800 - w) / 2), y);
|
||
gfx->print(txt);
|
||
}
|
||
|
||
void drawAlertScreen(bool phase) {
|
||
uint16_t bg = phase ? COL_NEON_TEAL : COL_HOT_PINK;
|
||
uint16_t fg = phase ? COL_BLACK : COL_WHITE;
|
||
|
||
gfx->fillScreen(bg);
|
||
|
||
drawCentered("! DOORBELL !", 60, 6, fg);
|
||
|
||
if (alertMessage.length() > 0) {
|
||
gfx->setTextSize(3);
|
||
gfx->setTextColor(fg);
|
||
// Simple word-wrap: just let it overflow for now — message is usually short
|
||
gfx->setCursor(40, 220);
|
||
gfx->print(alertMessage.c_str());
|
||
}
|
||
|
||
drawCentered("TAP ANYWHERE TO SILENCE", 430, 2, fg);
|
||
}
|
||
|
||
void drawStatusScreen() {
|
||
gfx->fillScreen(COL_BLACK);
|
||
|
||
drawCentered("DOORBELL MONITOR", 20, 3, COL_NEON_TEAL);
|
||
gfx->drawFastHLine(50, 65, 700, COL_DARK_GRAY);
|
||
|
||
gfx->setTextSize(2);
|
||
int y = 90;
|
||
auto line = [&](uint16_t col, const char *fmt, ...) {
|
||
char buf[128];
|
||
va_list ap;
|
||
va_start(ap, fmt);
|
||
vsnprintf(buf, sizeof(buf), fmt, ap);
|
||
va_end(ap);
|
||
gfx->setTextColor(col);
|
||
gfx->setCursor(60, y);
|
||
gfx->print(buf);
|
||
y += 36;
|
||
};
|
||
|
||
line(COL_WHITE, "WiFi: %s", WiFi.isConnected() ? WiFi.SSID().c_str() : "DISCONNECTED");
|
||
line(COL_WHITE, "IP: %s", WiFi.isConnected() ? WiFi.localIP().toString().c_str() : "---");
|
||
line(COL_WHITE, "RSSI: %d dBm", WiFi.RSSI());
|
||
line(COL_WHITE, "Heap: %d KB", ESP.getFreeHeap() / 1024);
|
||
line(COL_WHITE, "PSRAM: %d MB free", ESP.getFreePsram() / (1024 * 1024));
|
||
line(COL_WHITE, "Time: %s UTC", timeClient.getFormattedTime().c_str());
|
||
line(COL_WHITE, "Up: %lu min", (millis() - bootTime) / 60000);
|
||
|
||
y += 10;
|
||
const char *stStr =
|
||
state == ST_IDLE ? "IDLE — Monitoring" :
|
||
state == ST_SILENCED ? "SILENCED" :
|
||
state == ST_ALERTING ? "ALERTING" : "AWAKE";
|
||
uint16_t stCol =
|
||
state == ST_IDLE ? COL_GREEN :
|
||
state == ST_SILENCED ? COL_YELLOW :
|
||
state == ST_ALERTING ? COL_RED : COL_NEON_TEAL;
|
||
line(stCol, "State: %s", stStr);
|
||
|
||
if (alertMessage.length() > 0) {
|
||
y += 10;
|
||
line(COL_DARK_GRAY, "Last: %s", alertMessage.c_str());
|
||
}
|
||
|
||
drawCentered("tap to dismiss | auto-sleeps in 5s", 445, 1, COL_DARK_GRAY);
|
||
}
|
||
|
||
// =====================================================================
|
||
// ntfy.sh Communication
|
||
// =====================================================================
|
||
void ntfyPublish(const char *topic, const char *msg) {
|
||
if (!WiFi.isConnected()) return;
|
||
HTTPClient http;
|
||
http.begin(String(NTFY_BASE) + "/" + topic);
|
||
http.addHeader("Content-Type", "text/plain");
|
||
http.POST(msg);
|
||
http.end();
|
||
}
|
||
|
||
// Poll a topic; returns the message body of the newest unseen message, or ""
|
||
String ntfyPoll(const char *topic) {
|
||
if (!WiFi.isConnected()) return "";
|
||
|
||
HTTPClient http;
|
||
String url = String(NTFY_BASE) + "/" + topic + "/json?poll=1&since=5s";
|
||
http.begin(url);
|
||
http.setTimeout(5000);
|
||
|
||
int code = http.GET();
|
||
String result = "";
|
||
|
||
if (code == 200) {
|
||
String body = http.getString();
|
||
|
||
// ntfy returns newline-delimited JSON — grab the last line
|
||
int nl = body.lastIndexOf('\n', body.length() - 2);
|
||
String last = (nl >= 0) ? body.substring(nl + 1) : body;
|
||
last.trim();
|
||
|
||
if (last.length() > 2) {
|
||
JsonDocument doc;
|
||
if (!deserializeJson(doc, last) && doc["event"] == "message") {
|
||
String id = doc["id"].as<String>();
|
||
long ts = doc["time"].as<long>();
|
||
|
||
// Dedup
|
||
if (id != lastMsgId) {
|
||
// Age check
|
||
long now = timeClient.getEpochTime();
|
||
if (now <= 0 || (now - ts) <= MSG_MAX_AGE_SEC) {
|
||
lastMsgId = id;
|
||
result = doc["message"].as<String>();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
http.end();
|
||
return result;
|
||
}
|
||
|
||
// =====================================================================
|
||
// Touch Handling
|
||
// =====================================================================
|
||
void handleTouch() {
|
||
int16_t tx, ty;
|
||
if (!gt911_read(&tx, &ty)) return;
|
||
|
||
unsigned long now = millis();
|
||
static unsigned long lastDebounce = 0;
|
||
if (now - lastDebounce < TOUCH_DEBOUNCE_MS) return;
|
||
lastDebounce = now;
|
||
|
||
Serial.printf("Touch x=%d y=%d state=%d\n", tx, ty, state);
|
||
|
||
switch (state) {
|
||
case ST_ALERTING:
|
||
// Single tap → silence
|
||
state = ST_SILENCED;
|
||
setBacklight(false);
|
||
ntfyPublish(STATUS_TOPIC, "Silenced by touch");
|
||
Serial.println("-> SILENCED (touch)");
|
||
break;
|
||
|
||
case ST_IDLE:
|
||
case ST_SILENCED:
|
||
// Double-tap detection → wake
|
||
if (now - lastTapMs < DOUBLE_TAP_WINDOW_MS)
|
||
tapCount++;
|
||
else
|
||
tapCount = 1;
|
||
lastTapMs = now;
|
||
|
||
if (tapCount >= 2) {
|
||
state = ST_WAKE;
|
||
wakeStart = now;
|
||
setBacklight(true);
|
||
drawStatusScreen();
|
||
Serial.println("-> WAKE (double-tap)");
|
||
tapCount = 0;
|
||
}
|
||
break;
|
||
|
||
case ST_WAKE:
|
||
// Tap while awake → go back to sleep immediately
|
||
state = ST_IDLE;
|
||
setBacklight(false);
|
||
Serial.println("-> IDLE (tap dismiss)");
|
||
break;
|
||
}
|
||
}
|
||
|
||
// =====================================================================
|
||
// WiFi Connection
|
||
// =====================================================================
|
||
void connectWiFi() {
|
||
Serial.println("Connecting WiFi...");
|
||
for (int i = 0; i < NUM_WIFI; i++) {
|
||
wifiMulti.addAP(wifiNetworks[i].ssid, wifiNetworks[i].pass);
|
||
Serial.printf(" + %s\n", wifiNetworks[i].ssid);
|
||
}
|
||
|
||
setBacklight(true);
|
||
gfx->fillScreen(COL_BLACK);
|
||
drawCentered("Connecting to WiFi...", 220, 2, COL_NEON_TEAL);
|
||
|
||
int tries = 0;
|
||
while (wifiMulti.run() != WL_CONNECTED && tries++ < 40) delay(500);
|
||
|
||
if (WiFi.isConnected()) {
|
||
Serial.printf("Connected: %s IP: %s\n",
|
||
WiFi.SSID().c_str(), WiFi.localIP().toString().c_str());
|
||
gfx->fillScreen(COL_BLACK);
|
||
drawCentered("Connected!", 180, 3, COL_GREEN);
|
||
char buf[64];
|
||
snprintf(buf, sizeof(buf), "%s %s",
|
||
WiFi.SSID().c_str(), WiFi.localIP().toString().c_str());
|
||
drawCentered(buf, 250, 2, COL_WHITE);
|
||
delay(2000);
|
||
} else {
|
||
Serial.println("WiFi FAILED");
|
||
gfx->fillScreen(COL_BLACK);
|
||
drawCentered("WiFi FAILED — retrying in background", 220, 2, COL_RED);
|
||
delay(2000);
|
||
}
|
||
}
|
||
|
||
// =====================================================================
|
||
// Hardware Init
|
||
// =====================================================================
|
||
void initHardware() {
|
||
Wire.begin(I2C_SDA, I2C_SCL);
|
||
|
||
// CH422G: enable outputs, assert resets, backlight off
|
||
ch422g_write(CH422G_SYS, CH422G_OE);
|
||
delay(10);
|
||
ioState = 0;
|
||
ch422g_write(CH422G_OUT, ioState);
|
||
delay(100);
|
||
|
||
// Release resets (keep backlight off)
|
||
ioState = IO_TP_RST | IO_LCD_RST;
|
||
ch422g_write(CH422G_OUT, ioState);
|
||
delay(200);
|
||
|
||
// Display
|
||
if (!gfx->begin()) {
|
||
Serial.println("Display init FAILED");
|
||
while (true) delay(1000);
|
||
}
|
||
gfx->fillScreen(COL_BLACK);
|
||
|
||
// Touch
|
||
gt911_init();
|
||
}
|
||
|
||
// =====================================================================
|
||
// Setup
|
||
// =====================================================================
|
||
void setup() {
|
||
Serial.begin(115200);
|
||
unsigned long t = millis();
|
||
while (!Serial && millis() - t < 5000) delay(10);
|
||
delay(500);
|
||
|
||
Serial.println("\n========================================");
|
||
Serial.println(" Doorbell Touch v2.0");
|
||
Serial.println(" Waveshare ESP32-S3-Touch-LCD-4.3");
|
||
Serial.println("========================================");
|
||
Serial.printf("PSRAM: %d MB\n", ESP.getPsramSize() / (1024 * 1024));
|
||
|
||
if (ESP.getPsramSize() == 0) {
|
||
Serial.println("PSRAM required!");
|
||
while (true) delay(1000);
|
||
}
|
||
|
||
initHardware();
|
||
|
||
// Boot splash
|
||
setBacklight(true);
|
||
gfx->fillScreen(COL_BLACK);
|
||
drawCentered("KLUBHAUS", 140, 6, COL_NEON_TEAL);
|
||
drawCentered("DOORBELL", 220, 6, COL_HOT_PINK);
|
||
drawCentered("v2.0", 310, 2, COL_DARK_GRAY);
|
||
delay(1500);
|
||
|
||
connectWiFi();
|
||
|
||
timeClient.begin();
|
||
timeClient.update();
|
||
|
||
bootTime = millis();
|
||
lastPoll = 0;
|
||
|
||
ntfyPublish(STATUS_TOPIC, "Doorbell Touch v2.0 booted");
|
||
|
||
// Enter idle — screen off
|
||
state = ST_IDLE;
|
||
setBacklight(false);
|
||
Serial.println("Ready — monitoring ntfy.sh\n");
|
||
}
|
||
|
||
// =====================================================================
|
||
// Main Loop
|
||
// =====================================================================
|
||
void loop() {
|
||
unsigned long now = millis();
|
||
|
||
timeClient.update();
|
||
handleTouch();
|
||
|
||
// WiFi auto-reconnect
|
||
if (!WiFi.isConnected()) {
|
||
if (wifiMulti.run() == WL_CONNECTED) {
|
||
Serial.println("WiFi reconnected");
|
||
ntfyPublish(STATUS_TOPIC, "WiFi reconnected");
|
||
}
|
||
}
|
||
|
||
// ---- Poll ntfy.sh ----
|
||
if (now - lastPoll >= POLL_INTERVAL_MS) {
|
||
lastPoll = now;
|
||
|
||
// Remote silence
|
||
String sil = ntfyPoll(SILENCE_TOPIC);
|
||
if (sil.length() > 0 && state == ST_ALERTING) {
|
||
state = ST_SILENCED;
|
||
setBacklight(false);
|
||
Serial.println("-> SILENCED (remote)");
|
||
}
|
||
|
||
// Alert
|
||
String alert = ntfyPoll(ALERT_TOPIC);
|
||
if (alert.length() > 0) {
|
||
if (now - bootTime < BOOT_GRACE_MS) {
|
||
Serial.printf("Grace period — ignoring: %s\n", alert.c_str());
|
||
} else {
|
||
alertMessage = alert;
|
||
state = ST_ALERTING;
|
||
alertStart = now;
|
||
blinkTimer = now;
|
||
blinkPhase = false;
|
||
setBacklight(true);
|
||
drawAlertScreen(blinkPhase);
|
||
ntfyPublish(STATUS_TOPIC, ("Alert: " + alert).c_str());
|
||
Serial.printf("-> ALERTING: %s\n", alert.c_str());
|
||
}
|
||
}
|
||
|
||
// Admin commands
|
||
String admin = ntfyPoll(ADMIN_TOPIC);
|
||
if (admin.length() > 0) {
|
||
Serial.printf("Admin cmd: %s\n", admin.c_str());
|
||
|
||
if (admin == "status") {
|
||
char buf[256];
|
||
snprintf(buf, sizeof(buf),
|
||
"State:%s WiFi:%s RSSI:%d Heap:%dKB Up:%lus",
|
||
state == ST_IDLE ? "IDLE" : state == ST_ALERTING ? "ALERT" : "SILENCED",
|
||
WiFi.SSID().c_str(), WiFi.RSSI(),
|
||
ESP.getFreeHeap() / 1024, (now - bootTime) / 1000);
|
||
ntfyPublish(STATUS_TOPIC, buf);
|
||
|
||
} else if (admin == "test") {
|
||
alertMessage = "TEST ALERT";
|
||
state = ST_ALERTING;
|
||
alertStart = now;
|
||
blinkTimer = now;
|
||
blinkPhase = false;
|
||
setBacklight(true);
|
||
drawAlertScreen(blinkPhase);
|
||
|
||
} else if (admin == "wake") {
|
||
state = ST_WAKE;
|
||
wakeStart = now;
|
||
setBacklight(true);
|
||
drawStatusScreen();
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---- State machine ----
|
||
switch (state) {
|
||
case ST_ALERTING:
|
||
if (now - alertStart > (unsigned long)ALERT_TIMEOUT_SEC * 1000) {
|
||
state = ST_SILENCED;
|
||
setBacklight(false);
|
||
ntfyPublish(STATUS_TOPIC, "Auto-silenced (timeout)");
|
||
Serial.println("-> SILENCED (timeout)");
|
||
break;
|
||
}
|
||
if (now - blinkTimer >= BLINK_INTERVAL_MS) {
|
||
blinkTimer = now;
|
||
blinkPhase = !blinkPhase;
|
||
drawAlertScreen(blinkPhase);
|
||
}
|
||
break;
|
||
|
||
case ST_WAKE:
|
||
if (now - wakeStart > WAKE_DISPLAY_MS) {
|
||
state = ST_IDLE;
|
||
setBacklight(false);
|
||
Serial.println("-> IDLE (wake timeout)");
|
||
}
|
||
break;
|
||
|
||
case ST_IDLE:
|
||
case ST_SILENCED:
|
||
break; // backlight off, nothing to draw
|
||
}
|
||
|
||
// Heartbeat
|
||
static unsigned long lastHB = 0;
|
||
if (now - lastHB >= 30000) {
|
||
lastHB = now;
|
||
Serial.printf("[%lu s] %s | WiFi:%s | heap:%dKB\n",
|
||
now / 1000,
|
||
state == ST_IDLE ? "IDLE" : state == ST_ALERTING ? "ALERT" : "SILENCED",
|
||
WiFi.isConnected() ? "OK" : "DOWN",
|
||
ESP.getFreeHeap() / 1024);
|
||
}
|
||
|
||
delay(20); // ~50 Hz touch polling
|
||
}
|