1773 lines
56 KiB
Bash
1773 lines
56 KiB
Bash
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ═══════════════════════════════════════════════════════════════
|
||
# Klubhaus Doorbell — Project Scaffold v5.1
|
||
# Creates the full multi-target build with:
|
||
# - Shared Arduino library (KlubhausCore)
|
||
# - Per-board sketch directories
|
||
# - Per-board vendored display libraries
|
||
# - mise.toml multi-target build harness
|
||
# ═══════════════════════════════════════════════════════════════
|
||
|
||
GREEN='\033[0;32m'
|
||
BLUE='\033[0;34m'
|
||
DIM='\033[2m'
|
||
NC='\033[0m'
|
||
|
||
info() { echo -e "${GREEN}[+]${NC} $1"; }
|
||
section() { echo -e "\n${BLUE}━━━ $1 ━━━${NC}"; }
|
||
|
||
section "Creating directory structure"
|
||
|
||
mkdir -p libraries/KlubhausCore/src
|
||
mkdir -p vendor/esp32-32e
|
||
mkdir -p vendor/esp32-s3-lcd-43
|
||
mkdir -p boards/esp32-32e
|
||
mkdir -p boards/esp32-s3-lcd-43
|
||
|
||
info "Directories created"
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
section "Shared Library: KlubhausCore"
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
# ── library.properties ──────────────────────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/library.properties
|
||
name=KlubhausCore
|
||
version=5.1.0
|
||
author=David
|
||
maintainer=David
|
||
sentence=Core logic for Klubhaus doorbell alert system
|
||
paragraph=Shared state machine, ntfy.sh polling, networking, and abstract display interface.
|
||
category=Other
|
||
url=https://git.notsosm.art/david/klubhaus-doorbell
|
||
architectures=esp32
|
||
includes=KlubhausCore.h
|
||
depends=ArduinoJson,NTPClient
|
||
EOF
|
||
info "library.properties"
|
||
|
||
# ── KlubhausCore.h (umbrella include) ──────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/KlubhausCore.h
|
||
#pragma once
|
||
|
||
// Umbrella header — board sketches just #include <KlubhausCore.h>
|
||
#include "Config.h"
|
||
#include "ScreenState.h"
|
||
#include "IDisplayDriver.h"
|
||
#include "DisplayManager.h"
|
||
#include "NetManager.h"
|
||
#include "DoorbellLogic.h"
|
||
EOF
|
||
info "KlubhausCore.h"
|
||
|
||
# ── Config.h (shared constants only — no pins, no secrets) ──
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/Config.h
|
||
#pragma once
|
||
|
||
#define FW_VERSION "5.1"
|
||
|
||
// ── ntfy.sh ──
|
||
#define NTFY_SERVER "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 15000
|
||
#define HEARTBEAT_INTERVAL_MS 300000
|
||
#define BOOT_GRACE_MS 5000
|
||
#define HOLD_TO_SILENCE_MS 3000
|
||
#define ALERT_TIMEOUT_MS 120000
|
||
#define SILENCE_DISPLAY_MS 10000
|
||
#define WIFI_CONNECT_TIMEOUT_MS 15000
|
||
#define HTTP_TIMEOUT_MS 10000
|
||
|
||
// ── WiFi credential struct (populated in each board's secrets.h) ──
|
||
struct WiFiCred {
|
||
const char* ssid;
|
||
const char* pass;
|
||
};
|
||
EOF
|
||
info "Config.h"
|
||
|
||
# ── ScreenState.h ──────────────────────────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/ScreenState.h
|
||
#pragma once
|
||
#include <Arduino.h>
|
||
|
||
enum class DeviceState {
|
||
BOOTED,
|
||
SILENT,
|
||
ALERTING,
|
||
SILENCED
|
||
};
|
||
|
||
enum class ScreenID {
|
||
BOOT,
|
||
OFF,
|
||
ALERT,
|
||
DASHBOARD
|
||
};
|
||
|
||
struct ScreenState {
|
||
DeviceState deviceState = DeviceState::BOOTED;
|
||
ScreenID screen = ScreenID::BOOT;
|
||
|
||
String alertTitle;
|
||
String alertBody;
|
||
uint32_t alertStartMs = 0;
|
||
uint32_t silenceStartMs = 0;
|
||
|
||
bool backlightOn = false;
|
||
int wifiRssi = 0;
|
||
String wifiSsid;
|
||
String ipAddr;
|
||
uint32_t uptimeMs = 0;
|
||
uint32_t lastPollMs = 0;
|
||
uint32_t lastHeartbeatMs= 0;
|
||
};
|
||
|
||
inline const char* deviceStateStr(DeviceState s) {
|
||
switch (s) {
|
||
case DeviceState::BOOTED: return "BOOTED";
|
||
case DeviceState::SILENT: return "SILENT";
|
||
case DeviceState::ALERTING: return "ALERTING";
|
||
case DeviceState::SILENCED: return "SILENCED";
|
||
}
|
||
return "?";
|
||
}
|
||
|
||
inline const char* screenIdStr(ScreenID s) {
|
||
switch (s) {
|
||
case ScreenID::BOOT: return "BOOT";
|
||
case ScreenID::OFF: return "OFF";
|
||
case ScreenID::ALERT: return "ALERT";
|
||
case ScreenID::DASHBOARD: return "DASHBOARD";
|
||
}
|
||
return "?";
|
||
}
|
||
EOF
|
||
info "ScreenState.h"
|
||
|
||
# ── IDisplayDriver.h (pure virtual interface) ──────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/IDisplayDriver.h
|
||
#pragma once
|
||
#include "ScreenState.h"
|
||
|
||
struct TouchEvent {
|
||
bool pressed = false;
|
||
int x = 0;
|
||
int y = 0;
|
||
};
|
||
|
||
struct HoldState {
|
||
bool active = false;
|
||
bool completed = false;
|
||
float progress = 0.0f; // 0.0 – 1.0
|
||
};
|
||
|
||
/// Abstract display driver — implemented per-board.
|
||
class IDisplayDriver {
|
||
public:
|
||
virtual ~IDisplayDriver() = default;
|
||
|
||
virtual void begin() = 0;
|
||
virtual void setBacklight(bool on) = 0;
|
||
|
||
/// Called every loop() iteration; draw the screen described by `state`.
|
||
virtual void render(const ScreenState& state) = 0;
|
||
|
||
// ── Touch ──
|
||
virtual TouchEvent readTouch() = 0;
|
||
/// Returns tile index at (x,y), or -1 if none.
|
||
virtual int dashboardTouch(int x, int y) = 0;
|
||
/// Track a long-press gesture; returns progress/completion.
|
||
virtual HoldState updateHold(unsigned long holdMs) = 0;
|
||
/// Idle hint animation (e.g. pulsing ring) while alert is showing.
|
||
virtual void updateHint() = 0;
|
||
|
||
virtual int width() = 0;
|
||
virtual int height() = 0;
|
||
};
|
||
EOF
|
||
info "IDisplayDriver.h"
|
||
|
||
# ── DisplayManager.h (thin delegation wrapper) ─────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/DisplayManager.h
|
||
#pragma once
|
||
#include "IDisplayDriver.h"
|
||
|
||
/// Owns a pointer to the concrete driver; all calls delegate.
|
||
/// Board sketch creates the concrete driver and passes it in.
|
||
class DisplayManager {
|
||
public:
|
||
DisplayManager() : _drv(nullptr) {}
|
||
explicit DisplayManager(IDisplayDriver* drv) : _drv(drv) {}
|
||
void setDriver(IDisplayDriver* drv) { _drv = drv; }
|
||
|
||
void begin() { if (_drv) _drv->begin(); }
|
||
void setBacklight(bool on) { if (_drv) _drv->setBacklight(on); }
|
||
void render(const ScreenState& st) { if (_drv) _drv->render(st); }
|
||
TouchEvent readTouch() { return _drv ? _drv->readTouch() : TouchEvent{}; }
|
||
int dashboardTouch(int x, int y) { return _drv ? _drv->dashboardTouch(x, y) : -1; }
|
||
HoldState updateHold(unsigned long ms) { return _drv ? _drv->updateHold(ms) : HoldState{}; }
|
||
void updateHint() { if (_drv) _drv->updateHint(); }
|
||
int width() { return _drv ? _drv->width() : 0; }
|
||
int height() { return _drv ? _drv->height() : 0; }
|
||
|
||
private:
|
||
IDisplayDriver* _drv;
|
||
};
|
||
EOF
|
||
info "DisplayManager.h"
|
||
|
||
# ── NetManager.h ───────────────────────────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/NetManager.h
|
||
#pragma once
|
||
#include <Arduino.h>
|
||
#include <WiFi.h>
|
||
#include <WiFiMulti.h>
|
||
#include <WiFiClientSecure.h>
|
||
#include <HTTPClient.h>
|
||
#include <NTPClient.h>
|
||
#include <WiFiUdp.h>
|
||
#include "Config.h"
|
||
|
||
class NetManager {
|
||
public:
|
||
void begin(const WiFiCred* creds, int count);
|
||
bool checkConnection();
|
||
bool isConnected();
|
||
|
||
String getSSID();
|
||
String getIP();
|
||
int getRSSI();
|
||
|
||
bool syncNTP();
|
||
String getTimeStr();
|
||
|
||
bool dnsCheck(const char* host);
|
||
bool tlsCheck(const char* host);
|
||
|
||
/// HTTPS GET; writes body into `response`. Returns HTTP status code.
|
||
int httpGet(const char* url, String& response);
|
||
/// HTTPS POST with text/plain body. Returns HTTP status code.
|
||
int httpPost(const char* url, const String& body);
|
||
|
||
private:
|
||
WiFiMulti _multi;
|
||
WiFiUDP _udp;
|
||
NTPClient* _ntp = nullptr;
|
||
bool _ntpReady = false;
|
||
};
|
||
EOF
|
||
info "NetManager.h"
|
||
|
||
# ── NetManager.cpp ─────────────────────────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/NetManager.cpp
|
||
#include "NetManager.h"
|
||
|
||
// ── WiFi ────────────────────────────────────────────────────
|
||
|
||
void NetManager::begin(const WiFiCred* creds, int count) {
|
||
WiFi.mode(WIFI_STA);
|
||
for (int i = 0; i < count; i++)
|
||
_multi.addAP(creds[i].ssid, creds[i].pass);
|
||
|
||
Serial.println("[WIFI] Connecting...");
|
||
unsigned long t0 = millis();
|
||
while (_multi.run() != WL_CONNECTED) {
|
||
if (millis() - t0 > WIFI_CONNECT_TIMEOUT_MS) {
|
||
Serial.println("[WIFI] Timeout!");
|
||
return;
|
||
}
|
||
delay(250);
|
||
}
|
||
Serial.printf("[WIFI] Connected: %s %s\n",
|
||
getSSID().c_str(), getIP().c_str());
|
||
}
|
||
|
||
bool NetManager::checkConnection() {
|
||
if (WiFi.status() == WL_CONNECTED) return true;
|
||
Serial.println("[WIFI] Reconnecting...");
|
||
return _multi.run(WIFI_CONNECT_TIMEOUT_MS) == WL_CONNECTED;
|
||
}
|
||
|
||
bool NetManager::isConnected() { return WiFi.status() == WL_CONNECTED; }
|
||
String NetManager::getSSID() { return WiFi.SSID(); }
|
||
String NetManager::getIP() { return WiFi.localIP().toString(); }
|
||
int NetManager::getRSSI() { return WiFi.RSSI(); }
|
||
|
||
// ── NTP ─────────────────────────────────────────────────────
|
||
|
||
bool NetManager::syncNTP() {
|
||
Serial.println("[NTP] Starting sync...");
|
||
if (!_ntp) _ntp = new NTPClient(_udp, "pool.ntp.org", 0, 60000);
|
||
_ntp->begin();
|
||
_ntp->forceUpdate();
|
||
_ntpReady = _ntp->isTimeSet();
|
||
Serial.printf("[NTP] %s: %s UTC\n",
|
||
_ntpReady ? "Synced" : "FAILED",
|
||
_ntpReady ? _ntp->getFormattedTime().c_str() : "--");
|
||
return _ntpReady;
|
||
}
|
||
|
||
String NetManager::getTimeStr() {
|
||
return (_ntp && _ntpReady) ? _ntp->getFormattedTime() : "??:??:??";
|
||
}
|
||
|
||
// ── Diagnostics ─────────────────────────────────────────────
|
||
|
||
bool NetManager::dnsCheck(const char* host) {
|
||
IPAddress ip;
|
||
bool ok = WiFi.hostByName(host, ip);
|
||
Serial.printf("[NET] DNS %s: %s\n", ok ? "OK" : "FAIL",
|
||
ok ? ip.toString().c_str() : "");
|
||
return ok;
|
||
}
|
||
|
||
bool NetManager::tlsCheck(const char* host) {
|
||
WiFiClientSecure c;
|
||
c.setInsecure();
|
||
c.setTimeout(HTTP_TIMEOUT_MS);
|
||
bool ok = c.connect(host, 443);
|
||
if (ok) c.stop();
|
||
Serial.printf("[NET] TLS %s\n", ok ? "OK" : "FAIL");
|
||
return ok;
|
||
}
|
||
|
||
// ── HTTP helpers ────────────────────────────────────────────
|
||
|
||
int NetManager::httpGet(const char* url, String& response) {
|
||
WiFiClientSecure client;
|
||
client.setInsecure();
|
||
client.setTimeout(HTTP_TIMEOUT_MS);
|
||
|
||
HTTPClient http;
|
||
http.setTimeout(HTTP_TIMEOUT_MS);
|
||
http.begin(client, url);
|
||
|
||
int code = http.GET();
|
||
if (code > 0) response = http.getString();
|
||
http.end();
|
||
return code;
|
||
}
|
||
|
||
int NetManager::httpPost(const char* url, const String& body) {
|
||
WiFiClientSecure client;
|
||
client.setInsecure();
|
||
client.setTimeout(HTTP_TIMEOUT_MS);
|
||
|
||
HTTPClient http;
|
||
http.setTimeout(HTTP_TIMEOUT_MS);
|
||
http.begin(client, url);
|
||
http.addHeader("Content-Type", "text/plain");
|
||
|
||
int code = http.POST(body);
|
||
http.end();
|
||
return code;
|
||
}
|
||
EOF
|
||
info "NetManager.cpp"
|
||
|
||
# ── DoorbellLogic.h ────────────────────────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/DoorbellLogic.h
|
||
#pragma once
|
||
#include <Arduino.h>
|
||
#include <ArduinoJson.h>
|
||
#include "Config.h"
|
||
#include "ScreenState.h"
|
||
#include "DisplayManager.h"
|
||
#include "NetManager.h"
|
||
|
||
class DoorbellLogic {
|
||
public:
|
||
explicit DoorbellLogic(DisplayManager* display);
|
||
|
||
/// Call from setup(). Pass board-specific WiFi creds.
|
||
void begin(const char* version, const char* boardName,
|
||
const WiFiCred* creds, int credCount);
|
||
/// Call from loop() — polls topics, runs timers, transitions state.
|
||
void update();
|
||
/// Transition out of BOOTED → SILENT. Call at end of setup().
|
||
void finishBoot();
|
||
/// Serial debug console.
|
||
void onSerialCommand(const String& cmd);
|
||
|
||
const ScreenState& getScreenState() const { return _state; }
|
||
|
||
/// Externally trigger silence (e.g. hold-to-silence gesture).
|
||
void silenceAlert();
|
||
|
||
private:
|
||
void pollTopics();
|
||
void pollTopic(const String& url, const char* label);
|
||
void onAlert(const String& title, const String& body);
|
||
void onSilence();
|
||
void onAdmin(const String& command);
|
||
void flushStatus(const String& message);
|
||
void heartbeat();
|
||
void transition(DeviceState s);
|
||
String topicUrl(const char* base);
|
||
|
||
DisplayManager* _display;
|
||
NetManager _net;
|
||
ScreenState _state;
|
||
|
||
const char* _version = "";
|
||
const char* _board = "";
|
||
bool _debug = false;
|
||
|
||
uint32_t _lastPollMs = 0;
|
||
uint32_t _lastHeartbeatMs = 0;
|
||
uint32_t _bootGraceEnd = 0;
|
||
|
||
String _alertUrl;
|
||
String _silenceUrl;
|
||
String _adminUrl;
|
||
String _statusUrl;
|
||
};
|
||
EOF
|
||
info "DoorbellLogic.h"
|
||
|
||
# ── DoorbellLogic.cpp ──────────────────────────────────────
|
||
|
||
cat << 'EOF' > libraries/KlubhausCore/src/DoorbellLogic.cpp
|
||
#include "DoorbellLogic.h"
|
||
|
||
DoorbellLogic::DoorbellLogic(DisplayManager* display)
|
||
: _display(display) {}
|
||
|
||
// ── URL builder ─────────────────────────────────────────────
|
||
|
||
String DoorbellLogic::topicUrl(const char* base) {
|
||
String suffix = _debug ? "_test" : "";
|
||
return String("https://") + NTFY_SERVER + "/" + base + suffix
|
||
+ "/json?since=20s&poll=1";
|
||
}
|
||
|
||
// ── Lifecycle ───────────────────────────────────────────────
|
||
|
||
void DoorbellLogic::begin(const char* version, const char* boardName,
|
||
const WiFiCred* creds, int credCount) {
|
||
_version = version;
|
||
_board = boardName;
|
||
#ifdef DEBUG_MODE
|
||
_debug = true;
|
||
#endif
|
||
|
||
Serial.println(F("========================================"));
|
||
Serial.printf( " KLUBHAUS ALERT v%s — %s\n", _version, _board);
|
||
if (_debug) Serial.println(F(" *** DEBUG MODE — _test topics ***"));
|
||
Serial.println(F("========================================\n"));
|
||
|
||
// Display
|
||
_display->begin();
|
||
|
||
// Network
|
||
_net.begin(creds, credCount);
|
||
|
||
if (_net.isConnected()) {
|
||
_net.syncNTP();
|
||
Serial.printf("[NET] WiFi:%s RSSI:%d IP:%s\n",
|
||
_net.getSSID().c_str(), _net.getRSSI(),
|
||
_net.getIP().c_str());
|
||
_net.dnsCheck(NTFY_SERVER);
|
||
_net.tlsCheck(NTFY_SERVER);
|
||
}
|
||
|
||
// Topic URLs
|
||
_alertUrl = topicUrl(ALERT_TOPIC);
|
||
_silenceUrl = topicUrl(SILENCE_TOPIC);
|
||
_adminUrl = topicUrl(ADMIN_TOPIC);
|
||
String sfx = _debug ? "_test" : "";
|
||
_statusUrl = String("https://") + NTFY_SERVER + "/" + STATUS_TOPIC + sfx;
|
||
|
||
Serial.printf("[CONFIG] ALERT_URL: %s\n", _alertUrl.c_str());
|
||
Serial.printf("[CONFIG] SILENCE_URL: %s\n", _silenceUrl.c_str());
|
||
Serial.printf("[CONFIG] ADMIN_URL: %s\n", _adminUrl.c_str());
|
||
|
||
// Boot status
|
||
flushStatus(String("BOOTED — ") + _net.getSSID() + " "
|
||
+ _net.getIP() + " RSSI:" + String(_net.getRSSI()));
|
||
}
|
||
|
||
void DoorbellLogic::finishBoot() {
|
||
transition(DeviceState::SILENT);
|
||
_state.screen = ScreenID::OFF;
|
||
_display->setBacklight(false);
|
||
_state.backlightOn = false;
|
||
_bootGraceEnd = millis() + BOOT_GRACE_MS;
|
||
Serial.printf("[BOOT] Grace period: %d ms\n", BOOT_GRACE_MS);
|
||
Serial.printf("[BOOT] Ready — monitoring %s\n", NTFY_SERVER);
|
||
}
|
||
|
||
// ── Main loop tick ──────────────────────────────────────────
|
||
|
||
void DoorbellLogic::update() {
|
||
uint32_t now = millis();
|
||
_state.uptimeMs = now;
|
||
|
||
if (_net.isConnected()) {
|
||
_state.wifiRssi = _net.getRSSI();
|
||
_state.wifiSsid = _net.getSSID();
|
||
_state.ipAddr = _net.getIP();
|
||
}
|
||
if (!_net.checkConnection()) return;
|
||
|
||
// Poll
|
||
if (now - _lastPollMs >= POLL_INTERVAL_MS) {
|
||
_lastPollMs = now;
|
||
pollTopics();
|
||
}
|
||
|
||
// Heartbeat
|
||
if (now - _lastHeartbeatMs >= HEARTBEAT_INTERVAL_MS) {
|
||
_lastHeartbeatMs = now;
|
||
heartbeat();
|
||
}
|
||
|
||
// Auto-transitions
|
||
switch (_state.deviceState) {
|
||
case DeviceState::ALERTING:
|
||
if (now - _state.alertStartMs > ALERT_TIMEOUT_MS) {
|
||
Serial.println("[STATE] Alert timed out → SILENT");
|
||
transition(DeviceState::SILENT);
|
||
_state.screen = ScreenID::OFF;
|
||
_display->setBacklight(false);
|
||
_state.backlightOn = false;
|
||
}
|
||
break;
|
||
case DeviceState::SILENCED:
|
||
if (now - _state.silenceStartMs > SILENCE_DISPLAY_MS) {
|
||
Serial.println("[STATE] Silence display done → SILENT");
|
||
transition(DeviceState::SILENT);
|
||
_state.screen = ScreenID::OFF;
|
||
_display->setBacklight(false);
|
||
_state.backlightOn = false;
|
||
}
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
|
||
// ── Polling ─────────────────────────────────────────────────
|
||
|
||
void DoorbellLogic::pollTopics() {
|
||
pollTopic(_alertUrl, "ALERT");
|
||
pollTopic(_silenceUrl, "SILENCE");
|
||
pollTopic(_adminUrl, "ADMIN");
|
||
_state.lastPollMs = millis();
|
||
}
|
||
|
||
void DoorbellLogic::pollTopic(const String& url, const char* label) {
|
||
String body;
|
||
int code = _net.httpGet(url.c_str(), body);
|
||
if (code != 200 || body.length() == 0) return;
|
||
|
||
// ntfy returns newline-delimited JSON
|
||
int pos = 0;
|
||
while (pos < (int)body.length()) {
|
||
int nl = body.indexOf('\n', pos);
|
||
if (nl < 0) nl = body.length();
|
||
String line = body.substring(pos, nl);
|
||
line.trim();
|
||
pos = nl + 1;
|
||
if (line.length() == 0) continue;
|
||
|
||
JsonDocument doc;
|
||
if (deserializeJson(doc, line)) continue;
|
||
|
||
const char* evt = doc["event"] | "";
|
||
if (strcmp(evt, "message") != 0) continue;
|
||
|
||
const char* title = doc["title"] | "";
|
||
const char* message = doc["message"] | "";
|
||
Serial.printf("[%s] title=\"%s\" message=\"%s\"\n",
|
||
label, title, message);
|
||
|
||
if (strcmp(label, "ALERT") == 0) onAlert(String(title), String(message));
|
||
else if (strcmp(label, "SILENCE") == 0) onSilence();
|
||
else if (strcmp(label, "ADMIN") == 0) onAdmin(String(message));
|
||
}
|
||
}
|
||
|
||
// ── Event handlers ──────────────────────────────────────────
|
||
|
||
void DoorbellLogic::onAlert(const String& title, const String& body) {
|
||
if (millis() < _bootGraceEnd) {
|
||
Serial.println("[ALERT] Ignored (boot grace)");
|
||
return;
|
||
}
|
||
Serial.printf("[ALERT] %s: %s\n", title.c_str(), body.c_str());
|
||
_state.alertTitle = title;
|
||
_state.alertBody = body;
|
||
_state.alertStartMs = millis();
|
||
transition(DeviceState::ALERTING);
|
||
_state.screen = ScreenID::ALERT;
|
||
_display->setBacklight(true);
|
||
_state.backlightOn = true;
|
||
flushStatus("ALERT: " + title);
|
||
}
|
||
|
||
void DoorbellLogic::onSilence() {
|
||
if (_state.deviceState != DeviceState::ALERTING) return;
|
||
Serial.println("[SILENCE] Alert silenced");
|
||
_state.silenceStartMs = millis();
|
||
transition(DeviceState::SILENCED);
|
||
_state.screen = ScreenID::OFF;
|
||
_display->setBacklight(false);
|
||
_state.backlightOn = false;
|
||
flushStatus("SILENCED");
|
||
}
|
||
|
||
void DoorbellLogic::silenceAlert() { onSilence(); }
|
||
|
||
void DoorbellLogic::onAdmin(const String& cmd) {
|
||
Serial.printf("[ADMIN] %s\n", cmd.c_str());
|
||
if (cmd == "reboot") {
|
||
flushStatus("REBOOTING (admin)");
|
||
delay(500);
|
||
ESP.restart();
|
||
} else if (cmd == "dashboard") {
|
||
_state.screen = ScreenID::DASHBOARD;
|
||
_display->setBacklight(true);
|
||
_state.backlightOn = true;
|
||
} else if (cmd == "off") {
|
||
_state.screen = ScreenID::OFF;
|
||
_display->setBacklight(false);
|
||
_state.backlightOn = false;
|
||
} else if (cmd == "status") {
|
||
heartbeat(); // re-uses heartbeat message format
|
||
}
|
||
}
|
||
|
||
// ── Status / heartbeat ─────────────────────────────────────
|
||
|
||
void DoorbellLogic::flushStatus(const String& message) {
|
||
Serial.printf("[STATUS] Queued: %s\n", message.c_str());
|
||
String full = String(_board) + " " + message;
|
||
int code = _net.httpPost(_statusUrl.c_str(), full);
|
||
Serial.printf("[STATUS] Sent (%d): %s\n", code, message.c_str());
|
||
_state.lastHeartbeatMs = millis();
|
||
}
|
||
|
||
void DoorbellLogic::heartbeat() {
|
||
String m = String("HEARTBEAT ") + deviceStateStr(_state.deviceState)
|
||
+ " up:" + String(millis() / 1000) + "s"
|
||
+ " RSSI:" + String(_net.getRSSI())
|
||
+ " heap:" + String(ESP.getFreeHeap());
|
||
#ifdef BOARD_HAS_PSRAM
|
||
m += " psram:" + String(ESP.getFreePsram());
|
||
#endif
|
||
flushStatus(m);
|
||
}
|
||
|
||
void DoorbellLogic::transition(DeviceState s) {
|
||
Serial.printf("-> %s\n", deviceStateStr(s));
|
||
_state.deviceState = s;
|
||
}
|
||
|
||
// ── Serial console ──────────────────────────────────────────
|
||
|
||
void DoorbellLogic::onSerialCommand(const String& cmd) {
|
||
Serial.printf("[CMD] %s\n", cmd.c_str());
|
||
if (cmd == "alert") onAlert("Test Alert", "Serial test");
|
||
else if (cmd == "silence") onSilence();
|
||
else if (cmd == "reboot") ESP.restart();
|
||
else if (cmd == "dashboard") onAdmin("dashboard");
|
||
else if (cmd == "off") onAdmin("off");
|
||
else if (cmd == "status") {
|
||
Serial.printf("[STATE] %s screen:%s bl:%s\n",
|
||
deviceStateStr(_state.deviceState),
|
||
screenIdStr(_state.screen),
|
||
_state.backlightOn ? "ON" : "OFF");
|
||
Serial.printf("[MEM] heap:%d", ESP.getFreeHeap());
|
||
#ifdef BOARD_HAS_PSRAM
|
||
Serial.printf(" psram:%d", ESP.getFreePsram());
|
||
#endif
|
||
Serial.println();
|
||
Serial.printf("[NET] %s RSSI:%d IP:%s\n",
|
||
_state.wifiSsid.c_str(), _state.wifiRssi,
|
||
_state.ipAddr.c_str());
|
||
}
|
||
else Serial.println(F("[CMD] alert|silence|reboot|dashboard|off|status"));
|
||
}
|
||
EOF
|
||
info "DoorbellLogic.h + .cpp"
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
section "Board: ESP32-S3-LCD-4.3"
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
# ── board_config.h ─────────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-s3-lcd-43/board_config.h
|
||
#pragma once
|
||
|
||
#define BOARD_NAME "WS_S3_43"
|
||
#define DISPLAY_WIDTH 800
|
||
#define DISPLAY_HEIGHT 480
|
||
#define DISPLAY_ROTATION 0 // landscape, USB-C on left
|
||
|
||
// ── RGB parallel bus pins (directly to ST7262 panel) ──
|
||
#define LCD_DE 40
|
||
#define LCD_VSYNC 41
|
||
#define LCD_HSYNC 39
|
||
#define LCD_PCLK 42
|
||
|
||
#define LCD_R0 45
|
||
#define LCD_R1 48
|
||
#define LCD_R2 47
|
||
#define LCD_R3 21
|
||
#define LCD_R4 14
|
||
|
||
#define LCD_G0 5
|
||
#define LCD_G1 6
|
||
#define LCD_G2 7
|
||
#define LCD_G3 15
|
||
#define LCD_G4 16
|
||
#define LCD_G5 4
|
||
|
||
#define LCD_B0 8
|
||
#define LCD_B1 3
|
||
#define LCD_B2 46
|
||
#define LCD_B3 9
|
||
#define LCD_B4 1
|
||
|
||
// ── CH422G I2C IO expander ──
|
||
// Controls LCD_RST, TP_RST, LCD_BL, SD_CS via I2C
|
||
#define I2C_SDA 17
|
||
#define I2C_SCL 18
|
||
#define I2C_FREQ 100000
|
||
|
||
// CH422G I2C command addresses
|
||
#define CH422G_WRITE_OC 0x46
|
||
#define CH422G_SET_MODE 0x48
|
||
#define CH422G_READ_IN 0x4C
|
||
|
||
// EXIO bit positions
|
||
#define EXIO_TP_RST (1 << 0) // EXIO1
|
||
#define EXIO_LCD_BL (1 << 1) // EXIO2 — also drives DISP signal!
|
||
#define EXIO_LCD_RST (1 << 2) // EXIO3
|
||
#define EXIO_SD_CS (1 << 3) // EXIO4
|
||
|
||
// ── GT911 Touch ──
|
||
#define GT911_ADDR 0x5D
|
||
#define TOUCH_INT -1 // not wired to a readable GPIO on this board
|
||
EOF
|
||
info "board_config.h"
|
||
|
||
# ── secrets.h.example ─────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-s3-lcd-43/secrets.h.example
|
||
#pragma once
|
||
#include <KlubhausCore.h>
|
||
|
||
// Copy this file to secrets.h and fill in your credentials.
|
||
// secrets.h is gitignored.
|
||
|
||
static const WiFiCred wifiNetworks[] = {
|
||
{ "Your_SSID_1", "password1" },
|
||
{ "Your_SSID_2", "password2" },
|
||
};
|
||
static const int wifiNetworkCount = sizeof(wifiNetworks) / sizeof(wifiNetworks[0]);
|
||
EOF
|
||
|
||
cp boards/esp32-s3-lcd-43/secrets.h.example boards/esp32-s3-lcd-43/secrets.h
|
||
info "secrets.h.example (copied to secrets.h — edit before building)"
|
||
|
||
# ── DisplayDriverGFX.h ────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-s3-lcd-43/DisplayDriverGFX.h
|
||
#pragma once
|
||
|
||
#include <KlubhausCore.h>
|
||
#include <Arduino_GFX_Library.h>
|
||
#include <Wire.h>
|
||
#include "board_config.h"
|
||
|
||
class DisplayDriverGFX : public IDisplayDriver {
|
||
public:
|
||
void begin() override;
|
||
void setBacklight(bool on) override;
|
||
void render(const ScreenState& state) override;
|
||
TouchEvent readTouch() override;
|
||
int dashboardTouch(int x, int y) override;
|
||
HoldState updateHold(unsigned long holdMs) override;
|
||
void updateHint() override;
|
||
int width() override { return DISPLAY_WIDTH; }
|
||
int height() override { return DISPLAY_HEIGHT; }
|
||
|
||
private:
|
||
// CH422G helpers
|
||
void ch422gInit();
|
||
void ch422gWrite(uint8_t val);
|
||
uint8_t _exioBits = 0;
|
||
void exioSet(uint8_t bit, bool on);
|
||
|
||
// GT911 helpers
|
||
void gt911Init();
|
||
bool gt911Read(int& x, int& y);
|
||
|
||
// Rendering
|
||
void drawBoot();
|
||
void drawAlert(const ScreenState& st);
|
||
void drawDashboard(const ScreenState& st);
|
||
|
||
Arduino_GFX* _gfx = nullptr;
|
||
|
||
// Hold-to-silence tracking
|
||
bool _holdActive = false;
|
||
uint32_t _holdStartMs = 0;
|
||
bool _lastTouched = false;
|
||
|
||
// Render-change tracking
|
||
ScreenID _lastScreen = ScreenID::BOOT;
|
||
bool _needsRedraw = true;
|
||
};
|
||
EOF
|
||
info "DisplayDriverGFX.h"
|
||
|
||
# ── DisplayDriverGFX.cpp ──────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-s3-lcd-43/DisplayDriverGFX.cpp
|
||
#include "DisplayDriverGFX.h"
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// CH422G IO Expander
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
void DisplayDriverGFX::ch422gInit() {
|
||
Wire.begin(I2C_SDA, I2C_SCL, I2C_FREQ);
|
||
|
||
// Enable OC output mode
|
||
Wire.beginTransmission(CH422G_SET_MODE >> 1);
|
||
Wire.write(0x01); // OC output enable
|
||
Wire.endTransmission();
|
||
|
||
// Deassert resets, backlight OFF initially
|
||
_exioBits = EXIO_TP_RST | EXIO_LCD_RST | EXIO_SD_CS;
|
||
ch422gWrite(_exioBits);
|
||
|
||
delay(100);
|
||
Serial.println("[IO] CH422G initialized");
|
||
}
|
||
|
||
void DisplayDriverGFX::ch422gWrite(uint8_t val) {
|
||
Wire.beginTransmission(CH422G_WRITE_OC >> 1);
|
||
Wire.write(val);
|
||
Wire.endTransmission();
|
||
}
|
||
|
||
void DisplayDriverGFX::exioSet(uint8_t bit, bool on) {
|
||
if (on) _exioBits |= bit;
|
||
else _exioBits &= ~bit;
|
||
ch422gWrite(_exioBits);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// GT911 Touch (minimal implementation)
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
void DisplayDriverGFX::gt911Init() {
|
||
// GT911 is on the same I2C bus (Wire), already started by ch422gInit.
|
||
// Reset sequence: pull TP_RST low then high (via CH422G EXIO1).
|
||
exioSet(EXIO_TP_RST, false);
|
||
delay(10);
|
||
exioSet(EXIO_TP_RST, true);
|
||
delay(50);
|
||
Serial.println("[TOUCH] GT911 initialized");
|
||
}
|
||
|
||
bool DisplayDriverGFX::gt911Read(int& x, int& y) {
|
||
// Read status register 0x814E
|
||
Wire.beginTransmission(GT911_ADDR);
|
||
Wire.write(0x81); Wire.write(0x4E);
|
||
if (Wire.endTransmission() != 0) return false;
|
||
|
||
Wire.requestFrom((uint8_t)GT911_ADDR, (uint8_t)1);
|
||
if (!Wire.available()) return false;
|
||
uint8_t status = Wire.read();
|
||
|
||
uint8_t touches = status & 0x0F;
|
||
bool ready = status & 0x80;
|
||
|
||
if (!ready || touches == 0 || touches > 5) {
|
||
// Clear status
|
||
Wire.beginTransmission(GT911_ADDR);
|
||
Wire.write(0x81); Wire.write(0x4E); Wire.write(0x00);
|
||
Wire.endTransmission();
|
||
return false;
|
||
}
|
||
|
||
// Read first touch point (0x8150..0x8157)
|
||
Wire.beginTransmission(GT911_ADDR);
|
||
Wire.write(0x81); Wire.write(0x50);
|
||
Wire.endTransmission();
|
||
Wire.requestFrom((uint8_t)GT911_ADDR, (uint8_t)4);
|
||
if (Wire.available() >= 4) {
|
||
uint8_t xl = Wire.read();
|
||
uint8_t xh = Wire.read();
|
||
uint8_t yl = Wire.read();
|
||
uint8_t yh = Wire.read();
|
||
x = (xh << 8) | xl;
|
||
y = (yh << 8) | yl;
|
||
}
|
||
|
||
// Clear status
|
||
Wire.beginTransmission(GT911_ADDR);
|
||
Wire.write(0x81); Wire.write(0x4E); Wire.write(0x00);
|
||
Wire.endTransmission();
|
||
|
||
return true;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Display Init
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
void DisplayDriverGFX::begin() {
|
||
// 1. IO expander first (controls resets + backlight)
|
||
ch422gInit();
|
||
|
||
// 2. Create RGB bus with corrected Waveshare timing
|
||
Arduino_ESP32RGBPanel* rgbPanel = new Arduino_ESP32RGBPanel(
|
||
LCD_DE, LCD_VSYNC, LCD_HSYNC, LCD_PCLK,
|
||
LCD_R0, LCD_R1, LCD_R2, LCD_R3, LCD_R4,
|
||
LCD_G0, LCD_G1, LCD_G2, LCD_G3, LCD_G4, LCD_G5,
|
||
LCD_B0, LCD_B1, LCD_B2, LCD_B3, LCD_B4,
|
||
// ─── Corrected timing for ST7262 / Waveshare 4.3" ───
|
||
1, // hsync_polarity
|
||
10, // hsync_front_porch
|
||
8, // hsync_pulse_width
|
||
50, // hsync_back_porch
|
||
1, // vsync_polarity
|
||
10, // vsync_front_porch
|
||
8, // vsync_pulse_width
|
||
20, // vsync_back_porch
|
||
1, // pclk_active_neg *** CRITICAL — must be 1 ***
|
||
16000000 // prefer_speed = 16 MHz PCLK
|
||
);
|
||
|
||
// 3. Create display
|
||
_gfx = new Arduino_RGB_Display(
|
||
DISPLAY_WIDTH, DISPLAY_HEIGHT, rgbPanel,
|
||
DISPLAY_ROTATION,
|
||
true // auto_flush
|
||
);
|
||
|
||
if (!_gfx->begin()) {
|
||
Serial.println("[GFX] *** Display init FAILED ***");
|
||
return;
|
||
}
|
||
|
||
Serial.printf("[GFX] Display OK: %dx%d\n", DISPLAY_WIDTH, DISPLAY_HEIGHT);
|
||
|
||
// PSRAM diagnostic
|
||
Serial.printf("[MEM] Free heap: %d | Free PSRAM: %d\n",
|
||
ESP.getFreeHeap(), ESP.getFreePsram());
|
||
if (ESP.getFreePsram() == 0) {
|
||
Serial.println("[MEM] *** WARNING: PSRAM not detected! "
|
||
"Display will likely be blank. "
|
||
"Ensure PSRAM=opi in board config. ***");
|
||
}
|
||
|
||
// 4. Init touch
|
||
gt911Init();
|
||
|
||
// 5. Show boot screen (backlight still off)
|
||
_gfx->fillScreen(BLACK);
|
||
drawBoot();
|
||
|
||
// 6. Backlight ON
|
||
exioSet(EXIO_LCD_BL, true);
|
||
Serial.println("[GFX] Backlight ON");
|
||
}
|
||
|
||
void DisplayDriverGFX::setBacklight(bool on) {
|
||
exioSet(EXIO_LCD_BL, on);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Rendering
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
void DisplayDriverGFX::render(const ScreenState& st) {
|
||
if (st.screen != _lastScreen) {
|
||
_needsRedraw = true;
|
||
_lastScreen = st.screen;
|
||
}
|
||
|
||
switch (st.screen) {
|
||
case ScreenID::BOOT:
|
||
if (_needsRedraw) { drawBoot(); _needsRedraw = false; }
|
||
break;
|
||
case ScreenID::ALERT:
|
||
drawAlert(st); // redraws every frame (pulse animation)
|
||
break;
|
||
case ScreenID::DASHBOARD:
|
||
if (_needsRedraw) { drawDashboard(st); _needsRedraw = false; }
|
||
break;
|
||
case ScreenID::OFF:
|
||
if (_needsRedraw) { _gfx->fillScreen(BLACK); _needsRedraw = false; }
|
||
break;
|
||
}
|
||
}
|
||
|
||
void DisplayDriverGFX::drawBoot() {
|
||
_gfx->fillScreen(BLACK);
|
||
_gfx->setTextColor(WHITE);
|
||
_gfx->setTextSize(3);
|
||
_gfx->setCursor(40, 40);
|
||
_gfx->printf("KLUBHAUS ALERT v%s", FW_VERSION);
|
||
_gfx->setTextSize(2);
|
||
_gfx->setCursor(40, 100);
|
||
_gfx->print(BOARD_NAME);
|
||
_gfx->setCursor(40, 140);
|
||
_gfx->print("Booting...");
|
||
}
|
||
|
||
void DisplayDriverGFX::drawAlert(const ScreenState& st) {
|
||
// Pulsing red background
|
||
uint32_t elapsed = millis() - st.alertStartMs;
|
||
uint8_t pulse = 180 + (uint8_t)(75.0f * sinf(elapsed / 300.0f));
|
||
uint16_t bg = _gfx->color565(pulse, 0, 0);
|
||
|
||
_gfx->fillScreen(bg);
|
||
_gfx->setTextColor(WHITE);
|
||
|
||
// Title
|
||
_gfx->setTextSize(5);
|
||
_gfx->setCursor(40, 80);
|
||
_gfx->print(st.alertTitle.length() > 0 ? st.alertTitle : "ALERT");
|
||
|
||
// Body
|
||
_gfx->setTextSize(3);
|
||
_gfx->setCursor(40, 200);
|
||
_gfx->print(st.alertBody);
|
||
|
||
// Hold hint
|
||
_gfx->setTextSize(2);
|
||
_gfx->setCursor(40, DISPLAY_HEIGHT - 60);
|
||
_gfx->print("Hold to silence...");
|
||
}
|
||
|
||
void DisplayDriverGFX::drawDashboard(const ScreenState& st) {
|
||
_gfx->fillScreen(BLACK);
|
||
_gfx->setTextColor(WHITE);
|
||
|
||
// Title bar
|
||
_gfx->setTextSize(2);
|
||
_gfx->setCursor(20, 10);
|
||
_gfx->printf("KLUBHAUS — %s", deviceStateStr(st.deviceState));
|
||
|
||
// Info tiles (simple text grid)
|
||
int y = 60;
|
||
int dy = 50;
|
||
_gfx->setTextSize(2);
|
||
|
||
_gfx->setCursor(20, y);
|
||
_gfx->printf("WiFi: %s RSSI: %d", st.wifiSsid.c_str(), st.wifiRssi);
|
||
y += dy;
|
||
|
||
_gfx->setCursor(20, y);
|
||
_gfx->printf("IP: %s", st.ipAddr.c_str());
|
||
y += dy;
|
||
|
||
_gfx->setCursor(20, y);
|
||
_gfx->printf("Uptime: %lus", st.uptimeMs / 1000);
|
||
y += dy;
|
||
|
||
_gfx->setCursor(20, y);
|
||
_gfx->printf("Heap: %d PSRAM: %d", ESP.getFreeHeap(), ESP.getFreePsram());
|
||
y += dy;
|
||
|
||
_gfx->setCursor(20, y);
|
||
_gfx->printf("Last poll: %lus ago",
|
||
st.lastPollMs > 0 ? (millis() - st.lastPollMs) / 1000 : 0);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Touch
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TouchEvent DisplayDriverGFX::readTouch() {
|
||
TouchEvent evt;
|
||
int x, y;
|
||
if (gt911Read(x, y)) {
|
||
evt.pressed = true;
|
||
evt.x = x;
|
||
evt.y = y;
|
||
}
|
||
return evt;
|
||
}
|
||
|
||
int DisplayDriverGFX::dashboardTouch(int x, int y) {
|
||
// Simple 2-column, 4-row tile grid
|
||
int col = x / (DISPLAY_WIDTH / 2);
|
||
int row = (y - 60) / 80;
|
||
if (row < 0 || row > 3) return -1;
|
||
return row * 2 + col;
|
||
}
|
||
|
||
HoldState DisplayDriverGFX::updateHold(unsigned long holdMs) {
|
||
HoldState h;
|
||
TouchEvent t = readTouch();
|
||
|
||
if (t.pressed) {
|
||
if (!_holdActive) {
|
||
_holdActive = true;
|
||
_holdStartMs = millis();
|
||
}
|
||
uint32_t held = millis() - _holdStartMs;
|
||
h.active = true;
|
||
h.progress = constrain((float)held / (float)holdMs, 0.0f, 1.0f);
|
||
h.completed = (held >= holdMs);
|
||
|
||
// Draw progress arc
|
||
if (h.active && !h.completed) {
|
||
int cx = DISPLAY_WIDTH / 2;
|
||
int cy = DISPLAY_HEIGHT / 2;
|
||
int r = 100;
|
||
float angle = h.progress * 360.0f;
|
||
// Simple progress: draw filled arc sector
|
||
for (float a = 0; a < angle; a += 2.0f) {
|
||
float rad = a * PI / 180.0f;
|
||
int px = cx + (int)(r * cosf(rad - PI / 2));
|
||
int py = cy + (int)(r * sinf(rad - PI / 2));
|
||
_gfx->fillCircle(px, py, 4, WHITE);
|
||
}
|
||
}
|
||
} else {
|
||
_holdActive = false;
|
||
}
|
||
|
||
_lastTouched = t.pressed;
|
||
return h;
|
||
}
|
||
|
||
void DisplayDriverGFX::updateHint() {
|
||
// Subtle pulsing ring to hint "hold here"
|
||
float t = (millis() % 2000) / 2000.0f;
|
||
uint8_t alpha = (uint8_t)(60.0f + 40.0f * sinf(t * 2 * PI));
|
||
uint16_t col = _gfx->color565(alpha, alpha, alpha);
|
||
int cx = DISPLAY_WIDTH / 2;
|
||
int cy = DISPLAY_HEIGHT / 2 + 60;
|
||
_gfx->drawCircle(cx, cy, 80, col);
|
||
_gfx->drawCircle(cx, cy, 81, col);
|
||
}
|
||
EOF
|
||
info "DisplayDriverGFX.h + .cpp"
|
||
|
||
# ── Main sketch (S3) ──────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-s3-lcd-43/esp32-s3-lcd-43.ino
|
||
//
|
||
// Klubhaus Doorbell — ESP32-S3-Touch-LCD-4.3 target
|
||
//
|
||
|
||
#include <KlubhausCore.h>
|
||
#include "board_config.h"
|
||
#include "secrets.h"
|
||
#include "DisplayDriverGFX.h"
|
||
|
||
DisplayDriverGFX gfxDriver;
|
||
DisplayManager display(&gfxDriver);
|
||
DoorbellLogic logic(&display);
|
||
|
||
void setup() {
|
||
Serial.begin(115200);
|
||
delay(500);
|
||
|
||
logic.begin(FW_VERSION, BOARD_NAME, wifiNetworks, wifiNetworkCount);
|
||
logic.finishBoot();
|
||
}
|
||
|
||
void loop() {
|
||
// ── State machine tick ──
|
||
logic.update();
|
||
|
||
// ── Render current screen ──
|
||
display.render(logic.getScreenState());
|
||
|
||
// ── Touch handling ──
|
||
const ScreenState& st = logic.getScreenState();
|
||
|
||
if (st.deviceState == DeviceState::ALERTING) {
|
||
HoldState h = display.updateHold(HOLD_TO_SILENCE_MS);
|
||
if (h.completed) {
|
||
logic.silenceAlert();
|
||
}
|
||
if (!h.active) {
|
||
display.updateHint();
|
||
}
|
||
} else {
|
||
TouchEvent evt = display.readTouch();
|
||
if (evt.pressed && st.screen == ScreenID::DASHBOARD) {
|
||
int tile = display.dashboardTouch(evt.x, evt.y);
|
||
if (tile >= 0) Serial.printf("[DASH] Tile %d tapped\n", tile);
|
||
}
|
||
}
|
||
|
||
// ── Serial console ──
|
||
if (Serial.available()) {
|
||
String cmd = Serial.readStringUntil('\n');
|
||
cmd.trim();
|
||
if (cmd.length() > 0) logic.onSerialCommand(cmd);
|
||
}
|
||
}
|
||
EOF
|
||
info "esp32-s3-lcd-43.ino"
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
section "Board: ESP32-32E"
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
# ── board_config.h ─────────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-32e/board_config.h
|
||
#pragma once
|
||
|
||
#define BOARD_NAME "WS_32E"
|
||
|
||
// ══════════════════════════════════════════════════════════
|
||
// TODO: Set these to match YOUR display + wiring.
|
||
// Defaults below are for a common ILI9341 320×240 SPI TFT.
|
||
// The actual pin mapping must also be set in tft_user_setup.h
|
||
// (which gets copied into the vendored TFT_eSPI library).
|
||
// ══════════════════════════════════════════════════════════
|
||
|
||
#define DISPLAY_WIDTH 320
|
||
#define DISPLAY_HEIGHT 240
|
||
#define DISPLAY_ROTATION 1 // landscape
|
||
|
||
// Backlight GPIO (directly wired)
|
||
#define PIN_LCD_BL 22
|
||
|
||
// Touch — if using XPT2046 via TFT_eSPI, set TOUCH_CS in tft_user_setup.h
|
||
// If using capacitive touch (e.g. FT6236), configure I2C pins here:
|
||
// #define TOUCH_SDA 21
|
||
// #define TOUCH_SCL 22
|
||
EOF
|
||
info "board_config.h"
|
||
|
||
# ── tft_user_setup.h (copied into vendored TFT_eSPI) ──────
|
||
|
||
cat << 'EOF' > boards/esp32-32e/tft_user_setup.h
|
||
// ═══════════════════════════════════════════════════════════
|
||
// TFT_eSPI User_Setup for ESP32-32E target
|
||
// This file is copied over vendor/esp32-32e/TFT_eSPI/User_Setup.h
|
||
// by the install-libs-32e task.
|
||
//
|
||
// TODO: Change the driver, pins, and dimensions to match your display.
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
#define USER_SETUP_ID 200
|
||
|
||
// ── Driver ──
|
||
#define ILI9341_DRIVER
|
||
// #define ST7789_DRIVER
|
||
// #define ILI9488_DRIVER
|
||
|
||
// ── Resolution ──
|
||
#define TFT_WIDTH 240
|
||
#define TFT_HEIGHT 320
|
||
|
||
// ── SPI Pins ──
|
||
#define TFT_MOSI 23
|
||
#define TFT_SCLK 18
|
||
#define TFT_CS 5
|
||
#define TFT_DC 27
|
||
#define TFT_RST 33
|
||
|
||
// ── Backlight (optional, can also use GPIO directly) ──
|
||
// #define TFT_BL 22
|
||
// #define TFT_BACKLIGHT_ON HIGH
|
||
|
||
// ── Touch (XPT2046 resistive) ──
|
||
#define TOUCH_CS 14
|
||
|
||
// ── SPI speed ──
|
||
#define SPI_FREQUENCY 40000000
|
||
#define SPI_READ_FREQUENCY 20000000
|
||
#define SPI_TOUCH_FREQUENCY 2500000
|
||
|
||
// ── Misc ──
|
||
#define LOAD_GLCD
|
||
#define LOAD_FONT2
|
||
#define LOAD_FONT4
|
||
#define LOAD_FONT6
|
||
#define LOAD_FONT7
|
||
#define LOAD_FONT8
|
||
#define LOAD_GFXFF
|
||
#define SMOOTH_FONT
|
||
EOF
|
||
info "tft_user_setup.h"
|
||
|
||
# ── secrets.h.example ─────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-32e/secrets.h.example
|
||
#pragma once
|
||
#include <KlubhausCore.h>
|
||
|
||
// Copy this file to secrets.h and fill in your credentials.
|
||
// secrets.h is gitignored.
|
||
|
||
static const WiFiCred wifiNetworks[] = {
|
||
{ "Your_SSID_1", "password1" },
|
||
{ "Your_SSID_2", "password2" },
|
||
};
|
||
static const int wifiNetworkCount = sizeof(wifiNetworks) / sizeof(wifiNetworks[0]);
|
||
EOF
|
||
|
||
cp boards/esp32-32e/secrets.h.example boards/esp32-32e/secrets.h
|
||
info "secrets.h.example (copied to secrets.h — edit before building)"
|
||
|
||
# ── DisplayDriverTFT.h ────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-32e/DisplayDriverTFT.h
|
||
#pragma once
|
||
|
||
#include <KlubhausCore.h>
|
||
#include <TFT_eSPI.h>
|
||
#include "board_config.h"
|
||
|
||
class DisplayDriverTFT : public IDisplayDriver {
|
||
public:
|
||
void begin() override;
|
||
void setBacklight(bool on) override;
|
||
void render(const ScreenState& state) override;
|
||
TouchEvent readTouch() override;
|
||
int dashboardTouch(int x, int y) override;
|
||
HoldState updateHold(unsigned long holdMs) override;
|
||
void updateHint() override;
|
||
int width() override { return DISPLAY_WIDTH; }
|
||
int height() override { return DISPLAY_HEIGHT; }
|
||
|
||
private:
|
||
void drawBoot();
|
||
void drawAlert(const ScreenState& st);
|
||
void drawDashboard(const ScreenState& st);
|
||
|
||
TFT_eSPI _tft;
|
||
|
||
bool _holdActive = false;
|
||
uint32_t _holdStartMs = 0;
|
||
ScreenID _lastScreen = ScreenID::BOOT;
|
||
bool _needsRedraw = true;
|
||
};
|
||
EOF
|
||
info "DisplayDriverTFT.h"
|
||
|
||
# ── DisplayDriverTFT.cpp ──────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-32e/DisplayDriverTFT.cpp
|
||
#include "DisplayDriverTFT.h"
|
||
|
||
void DisplayDriverTFT::begin() {
|
||
// Backlight
|
||
pinMode(PIN_LCD_BL, OUTPUT);
|
||
digitalWrite(PIN_LCD_BL, LOW);
|
||
|
||
_tft.init();
|
||
_tft.setRotation(DISPLAY_ROTATION);
|
||
_tft.fillScreen(TFT_BLACK);
|
||
|
||
Serial.printf("[GFX] Display OK: %dx%d\n", DISPLAY_WIDTH, DISPLAY_HEIGHT);
|
||
|
||
drawBoot();
|
||
|
||
digitalWrite(PIN_LCD_BL, HIGH);
|
||
Serial.println("[GFX] Backlight ON");
|
||
}
|
||
|
||
void DisplayDriverTFT::setBacklight(bool on) {
|
||
digitalWrite(PIN_LCD_BL, on ? HIGH : LOW);
|
||
}
|
||
|
||
// ── Rendering ───────────────────────────────────────────────
|
||
|
||
void DisplayDriverTFT::render(const ScreenState& st) {
|
||
if (st.screen != _lastScreen) {
|
||
_needsRedraw = true;
|
||
_lastScreen = st.screen;
|
||
}
|
||
|
||
switch (st.screen) {
|
||
case ScreenID::BOOT:
|
||
if (_needsRedraw) { drawBoot(); _needsRedraw = false; }
|
||
break;
|
||
case ScreenID::ALERT:
|
||
drawAlert(st);
|
||
break;
|
||
case ScreenID::DASHBOARD:
|
||
if (_needsRedraw) { drawDashboard(st); _needsRedraw = false; }
|
||
break;
|
||
case ScreenID::OFF:
|
||
if (_needsRedraw) { _tft.fillScreen(TFT_BLACK); _needsRedraw = false; }
|
||
break;
|
||
}
|
||
}
|
||
|
||
void DisplayDriverTFT::drawBoot() {
|
||
_tft.fillScreen(TFT_BLACK);
|
||
_tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||
_tft.setTextSize(2);
|
||
_tft.setCursor(10, 10);
|
||
_tft.printf("KLUBHAUS v%s", FW_VERSION);
|
||
_tft.setTextSize(1);
|
||
_tft.setCursor(10, 40);
|
||
_tft.print(BOARD_NAME);
|
||
_tft.setCursor(10, 60);
|
||
_tft.print("Booting...");
|
||
}
|
||
|
||
void DisplayDriverTFT::drawAlert(const ScreenState& st) {
|
||
uint32_t elapsed = millis() - st.alertStartMs;
|
||
uint8_t pulse = 180 + (uint8_t)(75.0f * sinf(elapsed / 300.0f));
|
||
uint16_t bg = _tft.color565(pulse, 0, 0);
|
||
|
||
_tft.fillScreen(bg);
|
||
_tft.setTextColor(TFT_WHITE, bg);
|
||
|
||
_tft.setTextSize(3);
|
||
_tft.setCursor(10, 20);
|
||
_tft.print(st.alertTitle.length() > 0 ? st.alertTitle : "ALERT");
|
||
|
||
_tft.setTextSize(2);
|
||
_tft.setCursor(10, 80);
|
||
_tft.print(st.alertBody);
|
||
|
||
_tft.setTextSize(1);
|
||
_tft.setCursor(10, DISPLAY_HEIGHT - 20);
|
||
_tft.print("Hold to silence...");
|
||
}
|
||
|
||
void DisplayDriverTFT::drawDashboard(const ScreenState& st) {
|
||
_tft.fillScreen(TFT_BLACK);
|
||
_tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||
|
||
_tft.setTextSize(1);
|
||
_tft.setCursor(5, 5);
|
||
_tft.printf("KLUBHAUS — %s", deviceStateStr(st.deviceState));
|
||
|
||
int y = 30;
|
||
_tft.setCursor(5, y); y += 18;
|
||
_tft.printf("WiFi: %s %ddBm", st.wifiSsid.c_str(), st.wifiRssi);
|
||
|
||
_tft.setCursor(5, y); y += 18;
|
||
_tft.printf("IP: %s", st.ipAddr.c_str());
|
||
|
||
_tft.setCursor(5, y); y += 18;
|
||
_tft.printf("Up: %lus Heap: %d", st.uptimeMs / 1000, ESP.getFreeHeap());
|
||
|
||
_tft.setCursor(5, y); y += 18;
|
||
_tft.printf("Last poll: %lus ago",
|
||
st.lastPollMs > 0 ? (millis() - st.lastPollMs) / 1000 : 0);
|
||
}
|
||
|
||
// ── Touch ───────────────────────────────────────────────────
|
||
|
||
TouchEvent DisplayDriverTFT::readTouch() {
|
||
TouchEvent evt;
|
||
uint16_t tx, ty;
|
||
if (_tft.getTouch(&tx, &ty)) {
|
||
evt.pressed = true;
|
||
evt.x = tx;
|
||
evt.y = ty;
|
||
}
|
||
return evt;
|
||
}
|
||
|
||
int DisplayDriverTFT::dashboardTouch(int x, int y) {
|
||
// 2-column, 4-row
|
||
int col = x / (DISPLAY_WIDTH / 2);
|
||
int row = (y - 30) / 40;
|
||
if (row < 0 || row > 3) return -1;
|
||
return row * 2 + col;
|
||
}
|
||
|
||
HoldState DisplayDriverTFT::updateHold(unsigned long holdMs) {
|
||
HoldState h;
|
||
TouchEvent t = readTouch();
|
||
|
||
if (t.pressed) {
|
||
if (!_holdActive) {
|
||
_holdActive = true;
|
||
_holdStartMs = millis();
|
||
}
|
||
uint32_t held = millis() - _holdStartMs;
|
||
h.active = true;
|
||
h.progress = constrain((float)held / (float)holdMs, 0.0f, 1.0f);
|
||
h.completed = (held >= holdMs);
|
||
|
||
// Simple progress bar at bottom of screen
|
||
int barW = (int)(DISPLAY_WIDTH * h.progress);
|
||
_tft.fillRect(0, DISPLAY_HEIGHT - 8, barW, 8, TFT_WHITE);
|
||
_tft.fillRect(barW, DISPLAY_HEIGHT - 8, DISPLAY_WIDTH - barW, 8, TFT_DARKGREY);
|
||
} else {
|
||
_holdActive = false;
|
||
}
|
||
return h;
|
||
}
|
||
|
||
void DisplayDriverTFT::updateHint() {
|
||
float t = (millis() % 2000) / 2000.0f;
|
||
uint8_t v = (uint8_t)(30.0f + 30.0f * sinf(t * 2 * PI));
|
||
uint16_t col = _tft.color565(v, v, v);
|
||
_tft.drawRect(DISPLAY_WIDTH / 2 - 40, DISPLAY_HEIGHT / 2 + 20, 80, 40, col);
|
||
}
|
||
EOF
|
||
info "DisplayDriverTFT.h + .cpp"
|
||
|
||
# ── Main sketch (32E) ─────────────────────────────────────
|
||
|
||
cat << 'EOF' > boards/esp32-32e/esp32-32e.ino
|
||
//
|
||
// Klubhaus Doorbell — ESP32-32E target
|
||
//
|
||
|
||
#include <KlubhausCore.h>
|
||
#include "board_config.h"
|
||
#include "secrets.h"
|
||
#include "DisplayDriverTFT.h"
|
||
|
||
DisplayDriverTFT tftDriver;
|
||
DisplayManager display(&tftDriver);
|
||
DoorbellLogic logic(&display);
|
||
|
||
void setup() {
|
||
Serial.begin(115200);
|
||
delay(500);
|
||
|
||
logic.begin(FW_VERSION, BOARD_NAME, wifiNetworks, wifiNetworkCount);
|
||
logic.finishBoot();
|
||
}
|
||
|
||
void loop() {
|
||
// ── State machine tick ──
|
||
logic.update();
|
||
|
||
// ── Render current screen ──
|
||
display.render(logic.getScreenState());
|
||
|
||
// ── Touch handling ──
|
||
const ScreenState& st = logic.getScreenState();
|
||
|
||
if (st.deviceState == DeviceState::ALERTING) {
|
||
HoldState h = display.updateHold(HOLD_TO_SILENCE_MS);
|
||
if (h.completed) {
|
||
logic.silenceAlert();
|
||
}
|
||
if (!h.active) {
|
||
display.updateHint();
|
||
}
|
||
} else {
|
||
TouchEvent evt = display.readTouch();
|
||
if (evt.pressed && st.screen == ScreenID::DASHBOARD) {
|
||
int tile = display.dashboardTouch(evt.x, evt.y);
|
||
if (tile >= 0) Serial.printf("[DASH] Tile %d tapped\n", tile);
|
||
}
|
||
}
|
||
|
||
// ── Serial console ──
|
||
if (Serial.available()) {
|
||
String cmd = Serial.readStringUntil('\n');
|
||
cmd.trim();
|
||
if (cmd.length() > 0) logic.onSerialCommand(cmd);
|
||
}
|
||
}
|
||
EOF
|
||
info "esp32-32e.ino"
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
section "Build Harness: mise.toml"
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
cat << 'MISE_EOF' > mise.toml
|
||
# ═══════════════════════════════════════════════════════════
|
||
# Klubhaus Doorbell — Multi-Target Build Harness
|
||
# ═══════════════════════════════════════════════════════════
|
||
|
||
[tasks.install-libs-shared]
|
||
description = "Install shared (platform-independent) libraries"
|
||
run = """
|
||
arduino-cli lib install "ArduinoJson@7.4.1"
|
||
arduino-cli lib install "NTPClient@3.2.1"
|
||
echo "[OK] Shared libraries installed"
|
||
"""
|
||
|
||
[tasks.install-libs-32e]
|
||
description = "Vendor TFT_eSPI into vendor/esp32-32e"
|
||
run = """
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
if [ ! -d "vendor/esp32-32e/TFT_eSPI" ]; then
|
||
echo "Cloning TFT_eSPI..."
|
||
git clone --depth 1 --branch 2.5.43 \
|
||
https://github.com/Bodmer/TFT_eSPI.git \
|
||
vendor/esp32-32e/TFT_eSPI
|
||
fi
|
||
echo "Copying board-specific User_Setup.h..."
|
||
cp boards/esp32-32e/tft_user_setup.h vendor/esp32-32e/TFT_eSPI/User_Setup.h
|
||
echo "[OK] TFT_eSPI 2.5.43 vendored + configured"
|
||
"""
|
||
|
||
[tasks.install-libs-s3-43]
|
||
description = "Vendor Arduino_GFX into vendor/esp32-s3-lcd-43"
|
||
run = """
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
if [ ! -d "vendor/esp32-s3-lcd-43/GFX_Library_for_Arduino" ]; then
|
||
echo "Cloning Arduino_GFX..."
|
||
git clone --depth 1 --branch v1.6.5 \
|
||
https://github.com/moononournation/Arduino_GFX.git \
|
||
vendor/esp32-s3-lcd-43/GFX_Library_for_Arduino
|
||
fi
|
||
echo "[OK] Arduino_GFX 1.6.5 vendored"
|
||
"""
|
||
|
||
[tasks.install-libs]
|
||
description = "Install all libraries (shared + vendored)"
|
||
depends = ["install-libs-shared", "install-libs-32e", "install-libs-s3-43"]
|
||
|
||
# ── ESP32-32E ────────────────────────────────────────────
|
||
|
||
[tasks.compile-32e]
|
||
description = "Compile ESP32-32E sketch"
|
||
depends = ["install-libs"]
|
||
run = """
|
||
arduino-cli compile \
|
||
--fqbn "esp32:esp32:esp32:FlashSize=4M,PartitionScheme=default" \
|
||
--libraries ./libraries \
|
||
--libraries ./vendor/esp32-32e \
|
||
--build-property "compiler.cpp.extra_flags=-DDEBUG_MODE" \
|
||
--warnings default \
|
||
./boards/esp32-32e
|
||
"""
|
||
|
||
[tasks.upload-32e]
|
||
description = "Upload to ESP32-32E"
|
||
run = """
|
||
arduino-cli upload \
|
||
--fqbn "esp32:esp32:esp32:FlashSize=4M,PartitionScheme=default" \
|
||
--port "${PORT:-/dev/ttyUSB0}" \
|
||
./boards/esp32-32e
|
||
"""
|
||
|
||
[tasks.monitor-32e]
|
||
description = "Serial monitor for ESP32-32E"
|
||
run = """
|
||
arduino-cli monitor --port "${PORT:-/dev/ttyUSB0}" --config baudrate=115200
|
||
"""
|
||
|
||
# ── ESP32-S3-LCD-4.3 ────────────────────────────────────
|
||
|
||
[tasks.compile-s3-43]
|
||
description = "Compile ESP32-S3-LCD-4.3 sketch"
|
||
depends = ["install-libs"]
|
||
run = """
|
||
arduino-cli compile \
|
||
--fqbn "esp32:esp32:waveshare_esp32_s3_touch_lcd_43:PSRAM=opi,FlashSize=16M,USBMode=hwcdc,PartitionScheme=app3M_fat9M_16MB" \
|
||
--libraries ./libraries \
|
||
--libraries ./vendor/esp32-s3-lcd-43 \
|
||
--build-property "compiler.cpp.extra_flags=-DDEBUG_MODE -DBOARD_HAS_PSRAM" \
|
||
--warnings default \
|
||
./boards/esp32-s3-lcd-43
|
||
"""
|
||
|
||
[tasks.upload-s3-43]
|
||
description = "Upload to ESP32-S3-LCD-4.3"
|
||
run = """
|
||
arduino-cli upload \
|
||
--fqbn "esp32:esp32:waveshare_esp32_s3_touch_lcd_43:PSRAM=opi,FlashSize=16M,USBMode=hwcdc,PartitionScheme=app3M_fat9M_16MB" \
|
||
--port "${PORT:-/dev/ttyACM0}" \
|
||
./boards/esp32-s3-lcd-43
|
||
"""
|
||
|
||
[tasks.monitor-s3-43]
|
||
description = "Serial monitor for ESP32-S3-LCD-4.3"
|
||
run = """
|
||
arduino-cli monitor --port "${PORT:-/dev/ttyACM0}" --config baudrate=115200
|
||
"""
|
||
|
||
# ── Convenience ──────────────────────────────────────────
|
||
|
||
[tasks.clean]
|
||
description = "Remove build artifacts"
|
||
run = """
|
||
rm -rf boards/esp32-32e/build
|
||
rm -rf boards/esp32-s3-lcd-43/build
|
||
echo "[OK] Build artifacts cleaned"
|
||
"""
|
||
MISE_EOF
|
||
info "mise.toml"
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
section "Project Files"
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
cat << 'EOF' > .gitignore
|
||
# Secrets (WiFi passwords etc.)
|
||
**/secrets.h
|
||
|
||
# Build artifacts
|
||
**/build/
|
||
|
||
# Vendored libraries (re-created by install-libs)
|
||
vendor/esp32-32e/TFT_eSPI/
|
||
vendor/esp32-s3-lcd-43/GFX_Library_for_Arduino/
|
||
|
||
# IDE
|
||
.vscode/
|
||
*.swp
|
||
*.swo
|
||
*~
|
||
.DS_Store
|
||
EOF
|
||
info ".gitignore"
|
||
|
||
cat << 'EOF' > README.md
|
||
# Klubhaus Doorbell
|
||
|
||
Multi-target doorbell alert system powered by [ntfy.sh](https://ntfy.sh).
|
||
|
||
## Targets
|
||
|
||
| Board | Display | Library | Build Task |
|
||
|---|---|---|---|
|
||
| ESP32-32E | SPI TFT (ILI9341 etc.) | TFT_eSPI | `mise run compile-32e` |
|
||
| ESP32-S3-Touch-LCD-4.3 | 800×480 RGB parallel | Arduino_GFX | `mise run compile-s3-43` |
|
||
|
||
## Quick Start
|
||
|
||
```bash
|
||
# 1. Install prerequisites
|
||
# - arduino-cli (with esp32:esp32 platform installed)
|
||
# - mise (https://mise.jdx.dev)
|
||
|
||
# 2. Edit WiFi credentials
|
||
cp boards/esp32-32e/secrets.h.example boards/esp32-32e/secrets.h
|
||
cp boards/esp32-s3-lcd-43/secrets.h.example boards/esp32-s3-lcd-43/secrets.h
|
||
# Edit both secrets.h files with your WiFi SSIDs/passwords.
|
||
|
||
# 3. Build & upload
|
||
mise run compile-s3-43
|
||
mise run upload-s3-43
|
||
|
||
mise run compile-32e
|
||
mise run upload-32e
|