Улучшить Arweave-синхронизацию и ротацию ключей

Улучшено скачивание блоков из Arweave и обработка канонической цепочки.

Ротация ключей переведена на новую схему с пересборкой публичных каналов; личные сообщения пока не меняются.
This commit is contained in:
AidarKC
2026-10-06 16:39:39 +03:00
parent daa221a158
commit 67010a57f2
40 changed files with 2520 additions and 570 deletions
@@ -47,10 +47,13 @@ case "${MODE}" in
lvgl-official-based-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/lvgl_official_based_test" ;;
lvgl-subserver-touch-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/lvgl_subserver_touch_test" ;;
lvgl-russian-font-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/lvgl_russian_font_test" ;;
usb-contact-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_sensor_test" ;;
usb-contact-debug-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_sensor_debug_test" ;;
usb-contact-screen-start-stub) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_screen_start_stub" ;;
lvgl-nav-minimal-test) SKETCH_DIR="${ROOT_DIR}/shine_homeserver_main" ;;
*)
echo "Unknown mode: ${MODE}" >&2
echo "Use one of: hello, widgets, audio, simple, argon2, homeserver-ui, shine-homeserver-main, shine-homeserver-ui-main, legacy-homeserver-ui, text-test, gfx-text-test, gfx-layout-test, lvgl-basic-test, lvgl-interaction-test, lvgl-touch-debug-test, lvgl-official-based-test, lvgl-subserver-touch-test, lvgl-russian-font-test" >&2
echo "Use one of: hello, widgets, audio, simple, argon2, homeserver-ui, shine-homeserver-main, shine-homeserver-ui-main, legacy-homeserver-ui, text-test, gfx-text-test, gfx-layout-test, lvgl-basic-test, lvgl-interaction-test, lvgl-touch-debug-test, lvgl-official-based-test, lvgl-subserver-touch-test, lvgl-russian-font-test, usb-contact-test, usb-contact-debug-test, usb-contact-screen-start-stub" >&2
exit 2
;;
esac
@@ -78,6 +81,7 @@ compile_args=(
--library "${DEMO_BASE}/libraries/XPowersLib"
--library "${DEMO_BASE}/libraries/lvgl"
--library "${DEMO_BASE}/libraries/Mylibrary"
--library "${ROOT_DIR}/simple_av_test"
"${SKETCH_DIR}"
)
@@ -15,6 +15,8 @@
- `lvgl_official_based_test/` - минимальный наш экран поверх максимально близкой к официальному `05_LVGL_Widgets` инициализации
- `lvgl_subserver_touch_test/` - старый гибридный тест: `LVGL`-экран с инициализацией дисплея и чтением touch из старого `shine_homeserver_ui`; подтверждён на реальном устройстве
- `lvgl_russian_font_test/` - тест кастомного кириллического `LVGL`-шрифта с русскими кнопками, длинными строками и рабочим touch
- `usb_contact_sensor_test/` - тест переключения нативных USB D-/D+ (`GPIO19/20`) в режим простого замыкаемого контакта после нажатия Start; после перезагрузки снова обычный USB
- `usb_contact_sensor_debug_test/` - debug-версия теста замыкания контакта: экранная кнопка проверяет touch, а переход в sensor mode выполняется физической кнопкой BOOT
- `lvgl_nav_minimal_test/` - старое тестовое имя, этот скетч перенесён в `shine_homeserver_main/` и теперь является основным
## Запуск
@@ -29,3 +31,5 @@
- `./burn.sh lvgl-official-based-test`
- `./burn.sh lvgl-subserver-touch-test`
- `./burn.sh lvgl-russian-font-test`
- `./burn.sh usb-contact-test`
- `./burn.sh usb-contact-debug-test`
@@ -0,0 +1,459 @@
#include <Arduino.h>
#include <Wire.h>
#include <math.h>
#include <Arduino_GFX_Library.h>
#include <TouchDrvCSTXXX.hpp>
#include "ESP_I2S.h"
#include "es8311.h"
#define PIN_LCD_CS 12
#define PIN_LCD_SCLK 38
#define PIN_LCD_D0 4
#define PIN_LCD_D1 5
#define PIN_LCD_D2 6
#define PIN_LCD_D3 7
#define PIN_LCD_RST 2
#define PIN_I2C_SDA 15
#define PIN_I2C_SCL 14
#define PIN_TP_INT 11
#define PIN_USER_BTN 0
#define PIN_PA 46
#define PIN_I2S_BCLK 9
#define PIN_I2S_LRCK 45
#define PIN_I2S_DOUT 8
#define PIN_I2S_DIN 10
#define PIN_I2S_MCLK 42
#define DISP_W 480
#define DISP_H 480
static constexpr int kUsbDmPin = 19;
static constexpr int kUsbDpPin = 20;
static constexpr uint32_t kContactDebounceMs = 80;
static constexpr uint32_t kButtonDebounceMs = 45;
static constexpr uint32_t kUiPeriodMs = 200;
static constexpr uint32_t kSampleRate = 16000;
#define C_BG 0x0841u
#define C_PANEL 0x1082u
#define C_CARD 0x18C3u
#define C_BORDER 0x39C7u
#define C_TEXT 0xFFFFu
#define C_MUTE 0xBDF7u
#define C_ACCENT 0x5D5Fu
#define C_OK 0x3666u
#define C_BAD 0xD145u
#define C_BUTTON 0x2145u
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
PIN_LCD_CS, PIN_LCD_SCLK, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2, PIN_LCD_D3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, PIN_LCD_RST, 0, DISP_W, DISP_H, 0, 0, 0, 0);
TouchDrvCST92xx gTouch;
I2SClass gI2s;
struct Rect {
int16_t x;
int16_t y;
int16_t w;
int16_t h;
};
static const Rect kStartButton = {96, 348, 288, 78};
static const uint16_t kLimitsSec[] = {5, 7, 10, 15, 20};
static bool gStarted = false;
static bool gAudioReady = false;
static bool gStableClosed = false;
static bool gLastRawClosed = false;
static bool gStaticDrawn = false;
static bool gNeedRedraw = true;
static bool gNeedStaticRedraw = true;
static bool gLastDrawnClosed = false;
static bool gTouchDown = false;
static bool gUserButtonDown = false;
static int16_t gTouchStartX = 0;
static int16_t gTouchStartY = 0;
static int16_t gTouchLastX = 0;
static int16_t gTouchLastY = 0;
static uint32_t gLastRawChangeMs = 0;
static uint32_t gStartedMs = 0;
static uint32_t gLastCycleStartMs = 0;
static uint32_t gLastUiMs = 0;
static uint32_t gUserButtonChangeMs = 0;
static uint32_t gCycleMs[5] = {};
static uint8_t gCycleCount = 0;
static uint8_t gCycleNext = 0;
static uint8_t gLimitIndex = 2;
static uint8_t gShortStreak = 0;
static void drawPanel(int x, int y, int w, int h, uint16_t fill, uint16_t border, int radius = 10) {
gfx->fillRoundRect(x, y, w, h, radius, fill);
gfx->drawRoundRect(x, y, w, h, radius, border);
}
static void drawText(int x, int y, const char *text, uint16_t color, uint8_t size = 2) {
gfx->setFont();
gfx->setTextSize(size);
gfx->setTextColor(color);
gfx->setCursor(x, y);
gfx->print(text);
}
static void drawCenteredText(int x, int y, int w, const char *text, uint16_t color, uint8_t size = 2) {
int textW = strlen(text) * 6 * size;
int textX = x + (w - textW) / 2;
if (textX < x + 8) {
textX = x + 8;
}
drawText(textX, y, text, color, size);
}
static void drawButton(const Rect &rect, const char *label, uint8_t size = 2) {
drawPanel(rect.x, rect.y, rect.w, rect.h, C_BUTTON, C_BORDER, 12);
drawCenteredText(rect.x, rect.y + 18, rect.w, label, C_TEXT, size);
}
static bool contains(const Rect &rect, int16_t x, int16_t y) {
return x >= rect.x && x < rect.x + rect.w && y >= rect.y && y < rect.y + rect.h;
}
static void formatSec(char *out, size_t outSize, uint32_t ms) {
snprintf(out, outSize, "%lu.%01lus", (unsigned long)(ms / 1000), (unsigned long)((ms % 1000) / 100));
}
static void formatClock(char *out, size_t outSize, uint32_t ms) {
uint32_t sec = ms / 1000;
snprintf(out, outSize, "%02lu:%02lu", (unsigned long)(sec / 60), (unsigned long)(sec % 60));
}
static uint32_t averageCycleMs() {
if (gCycleCount == 0) {
return 0;
}
uint32_t sum = 0;
for (uint8_t i = 0; i < gCycleCount; i++) {
sum += gCycleMs[i];
}
return sum / gCycleCount;
}
static esp_err_t codecInit() {
es8311_handle_t esHandle = es8311_create(0, ES8311_ADDRRES_0);
if (!esHandle) {
return ESP_FAIL;
}
const es8311_clock_config_t clk = {
.mclk_inverted = false,
.sclk_inverted = false,
.mclk_from_mclk_pin = true,
.mclk_frequency = (int)kSampleRate * 256,
.sample_frequency = (int)kSampleRate,
};
if (es8311_init(esHandle, &clk, ES8311_RESOLUTION_16, ES8311_RESOLUTION_16) != ESP_OK) {
return ESP_FAIL;
}
es8311_voice_volume_set(esHandle, 100, nullptr);
es8311_voice_mute(esHandle, false);
return ESP_OK;
}
static void initAudio() {
pinMode(PIN_PA, OUTPUT);
digitalWrite(PIN_PA, HIGH);
gI2s.setPins(PIN_I2S_BCLK, PIN_I2S_LRCK, PIN_I2S_DOUT, PIN_I2S_DIN, PIN_I2S_MCLK);
if (!gI2s.begin(I2S_MODE_STD, kSampleRate, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO, I2S_STD_SLOT_BOTH)) {
Serial.println("I2S init failed");
return;
}
gAudioReady = (codecInit() == ESP_OK);
Serial.println(gAudioReady ? "Audio init OK" : "Audio codec init failed");
}
static void playBeep(uint16_t freq, uint16_t samples, int16_t amp) {
if (!gAudioReady) {
return;
}
static int16_t toneBuf[1600 * 2];
if (samples > 1600) {
samples = 1600;
}
for (int i = 0; i < samples; i++) {
float s = sinf(2.0f * 3.1415926f * (float)freq * ((float)i / (float)kSampleRate));
int16_t v = (int16_t)(s * amp);
toneBuf[i * 2] = v;
toneBuf[i * 2 + 1] = v;
}
gI2s.write((uint8_t *)toneBuf, samples * 2 * sizeof(int16_t));
}
static void playCycleTick() {
playBeep(880, 480, 2500);
}
static void playAlertBeep() {
playBeep(1200, 1600, 12000);
}
static void alertIfNeeded() {
if (gShortStreak == 0) {
return;
}
uint8_t count = min<uint8_t>(gShortStreak, 5);
for (uint8_t i = 0; i < count; i++) {
playAlertBeep();
delay(80);
}
}
static void addCycle(uint32_t cycleMs) {
gCycleMs[gCycleNext] = cycleMs;
gCycleNext = (gCycleNext + 1) % 5;
if (gCycleCount < 5) {
gCycleCount++;
}
uint32_t avgMs = averageCycleMs();
if (avgMs > 0 && avgMs < (uint32_t)kLimitsSec[gLimitIndex] * 1000UL) {
if (gShortStreak < 5) {
gShortStreak++;
}
} else {
gShortStreak = 0;
}
}
static void drawReadyScreen() {
gfx->fillScreen(C_BG);
drawPanel(12, 12, 456, 456, C_PANEL, C_BORDER, 16);
drawText(28, 42, "BREATH MONITOR", C_TEXT, 3);
drawText(28, 78, "USB contact sensor", C_MUTE, 2);
drawPanel(34, 132, 412, 160, C_CARD, C_BORDER, 14);
drawCenteredText(34, 166, 412, "READY", C_ACCENT, 4);
drawCenteredText(34, 222, 412, "Closed = exhale", C_TEXT, 2);
drawCenteredText(34, 252, 412, "Open = inhale", C_MUTE, 2);
drawButton(kStartButton, "START", 3);
}
static void clearArea(int x, int y, int w, int h, uint16_t fill) {
gfx->fillRect(x, y, w, h, fill);
}
static void drawMonitorStatic() {
gfx->fillScreen(C_BG);
drawPanel(12, 12, 456, 456, C_PANEL, C_BORDER, 16);
drawText(28, 32, "BREATH MONITOR", C_TEXT, 2);
drawPanel(28, 96, 424, 104, C_CARD, C_BORDER, 14);
drawPanel(28, 216, 200, 72, C_CARD, C_BORDER, 10);
drawText(42, 236, "Current", C_MUTE, 1);
drawPanel(252, 216, 200, 72, C_CARD, C_BORDER, 10);
drawText(266, 236, "Average 5", C_MUTE, 1);
drawPanel(28, 304, 200, 64, C_CARD, C_BORDER, 10);
drawText(42, 322, "From start", C_MUTE, 1);
drawPanel(252, 304, 200, 64, C_CARD, C_BORDER, 10);
drawText(266, 322, "Limit", C_MUTE, 1);
gStaticDrawn = true;
gLastDrawnClosed = !gStableClosed;
}
static void updateMonitorValues(bool force) {
char line[48];
char value[16];
uint32_t now = millis();
uint32_t runMs = now - gStartedMs;
uint32_t currentMs = (gLastCycleStartMs == 0) ? 0 : now - gLastCycleStartMs;
uint32_t avgMs = averageCycleMs();
if (force || gLastDrawnClosed != gStableClosed) {
clearArea(42, 118, 396, 68, C_CARD);
drawCenteredText(28, 122, 424, gStableClosed ? "EXHALE" : "INHALE",
gStableClosed ? C_OK : C_ACCENT, 4);
drawCenteredText(28, 172, 424, gStableClosed ? "contact closed" : "contact open", C_MUTE, 2);
gLastDrawnClosed = gStableClosed;
}
clearArea(28, 58, 424, 28, C_PANEL);
snprintf(line, sizeof(line), "Limit: %us alert by average", kLimitsSec[gLimitIndex]);
drawText(28, 60, line, C_MUTE, 2);
clearArea(42, 254, 160, 28, C_CARD);
formatSec(value, sizeof(value), currentMs);
drawText(42, 256, value, C_TEXT, 3);
clearArea(266, 254, 160, 28, C_CARD);
if (avgMs > 0) {
formatSec(value, sizeof(value), avgMs);
} else {
snprintf(value, sizeof(value), "--");
}
drawText(266, 256, value, C_TEXT, 3);
clearArea(42, 340, 160, 24, C_CARD);
formatClock(value, sizeof(value), runMs);
drawText(42, 342, value, C_TEXT, 2);
clearArea(266, 340, 160, 24, C_CARD);
snprintf(value, sizeof(value), "%us", kLimitsSec[gLimitIndex]);
drawText(266, 342, value, C_TEXT, 2);
clearArea(28, 398, 250, 28, C_PANEL);
snprintf(line, sizeof(line), "Short avg streak: %u", gShortStreak);
drawText(32, 402, line, gShortStreak > 0 ? C_BAD : C_MUTE, 2);
}
static void redrawScreen() {
if (gStarted) {
if (gNeedStaticRedraw || !gStaticDrawn) {
drawMonitorStatic();
gNeedStaticRedraw = false;
}
updateMonitorValues(true);
} else {
drawReadyScreen();
}
gNeedRedraw = false;
gLastUiMs = millis();
}
static void enterSensorMode() {
Serial.flush();
delay(30);
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, LOW);
pinMode(kUsbDpPin, INPUT_PULLUP);
uint32_t now = millis();
gStarted = true;
gStartedMs = now;
gLastCycleStartMs = 0;
gLastRawClosed = (digitalRead(kUsbDpPin) == LOW);
gStableClosed = gLastRawClosed;
gLastRawChangeMs = now;
if (gStableClosed) {
gLastCycleStartMs = now;
playCycleTick();
}
gNeedStaticRedraw = true;
gNeedRedraw = true;
}
static void nextLimit() {
gLimitIndex = (gLimitIndex + 1) % (sizeof(kLimitsSec) / sizeof(kLimitsSec[0]));
gNeedRedraw = true;
}
static void handleStableContact(bool closed) {
uint32_t now = millis();
gStableClosed = closed;
if (closed) {
if (gLastCycleStartMs != 0) {
addCycle(now - gLastCycleStartMs);
playCycleTick();
alertIfNeeded();
} else {
playCycleTick();
}
gLastCycleStartMs = now;
}
gNeedRedraw = true;
}
static void pollContact() {
if (!gStarted) {
return;
}
bool rawClosed = (digitalRead(kUsbDpPin) == LOW);
uint32_t now = millis();
if (rawClosed != gLastRawClosed) {
gLastRawClosed = rawClosed;
gLastRawChangeMs = now;
}
if ((now - gLastRawChangeMs) >= kContactDebounceMs && gStableClosed != gLastRawClosed) {
handleStableContact(gLastRawClosed);
}
}
static void pollUserButton() {
bool down = digitalRead(PIN_USER_BTN) == LOW;
uint32_t now = millis();
if (down != gUserButtonDown && (now - gUserButtonChangeMs) >= kButtonDebounceMs) {
gUserButtonDown = down;
gUserButtonChangeMs = now;
if (down) {
nextLimit();
}
}
}
static void pollTouch() {
int16_t x = 0;
int16_t y = 0;
bool touching = gTouch.getPoint(&x, &y, 1) > 0;
if (touching && !gTouchDown) {
gTouchDown = true;
gTouchStartX = x;
gTouchStartY = y;
gTouchLastX = x;
gTouchLastY = y;
return;
}
if (touching && gTouchDown) {
gTouchLastX = x;
gTouchLastY = y;
return;
}
if (!touching && gTouchDown) {
gTouchDown = false;
int dx = abs(gTouchLastX - gTouchStartX);
int dy = abs(gTouchLastY - gTouchStartY);
if (dx < 14 && dy < 14 && !gStarted && contains(kStartButton, gTouchLastX, gTouchLastY)) {
enterSensorMode();
}
}
}
void setup() {
Serial.begin(115200);
Wire.begin(PIN_I2C_SDA, PIN_I2C_SCL);
pinMode(PIN_USER_BTN, INPUT_PULLUP);
initAudio();
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(C_BG);
gTouch.setPins(PIN_TP_INT, -1);
bool touchOk = gTouch.begin(Wire, CST92XX_SLAVE_ADDRESS, PIN_I2C_SDA, PIN_I2C_SCL);
gTouch.setMaxCoordinates(DISP_W, DISP_H);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
Serial.println("Breath monitor ready.");
Serial.println(touchOk ? "Touch init OK" : "Touch init failed");
gNeedRedraw = true;
}
void loop() {
pollUserButton();
pollTouch();
pollContact();
if (gStarted && millis() - gLastUiMs >= kUiPeriodMs) {
updateMonitorValues(false);
gLastUiMs = millis();
}
if (gNeedRedraw) {
redrawScreen();
}
delay(10);
}
@@ -0,0 +1,407 @@
#include <Arduino.h>
#include <Wire.h>
#include <lvgl.h>
#include <Arduino_GFX_Library.h>
#include "pin_config.h"
#include "TouchDrvCSTXXX.hpp"
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
// ESP32-S3 native USB data pins.
static constexpr int kUsbDmPin = 19; // USB D-
static constexpr int kUsbDpPin = 20; // USB D+
static constexpr int kUserButtonPin = 0; // BOOT/user button, active LOW.
static constexpr uint32_t kDebounceMs = 20;
static constexpr uint32_t kEnterDelayMs = 250;
static constexpr uint32_t kButtonDebounceMs = 35;
static lv_disp_draw_buf_t gDrawBuf;
static lv_color_t *gBuf1 = nullptr;
static lv_color_t *gBuf2 = nullptr;
static lv_obj_t *gRawLabel = nullptr;
static lv_obj_t *gEventLabel = nullptr;
static lv_obj_t *gModeLabel = nullptr;
static lv_obj_t *gStateLabel = nullptr;
static lv_obj_t *gActionButton = nullptr;
static lv_obj_t *gActionButtonLabel = nullptr;
static lv_obj_t *gMarker = nullptr;
static TouchDrvCST92xx gTouch;
static int16_t gTouchX[5];
static int16_t gTouchY[5];
static volatile bool gTouchPressed = false;
static volatile int16_t gLastTouchX = -1;
static volatile int16_t gLastTouchY = -1;
static volatile uint32_t gRawTouchCount = 0;
static uint32_t gButtonPressCount = 0;
static uint32_t gButtonClickCount = 0;
static bool gLastButtonRawPressed = false;
static bool gButtonStablePressed = false;
static uint32_t gLastButtonRawChangeMs = 0;
static bool gSensorMode = false;
static bool gEnterPending = false;
static uint32_t gEnterAtMs = 0;
static bool gStableClosed = false;
static bool gLastRawClosed = false;
static uint32_t gLastRawChangeMs = 0;
static uint32_t gLastUiRefreshMs = 0;
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
LCD_CS, LCD_SCLK, LCD_SDIO0, LCD_SDIO1, LCD_SDIO2, LCD_SDIO3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, LCD_RESET, 0, LCD_WIDTH, LCD_HEIGHT, 0, 0, 0, 0);
static void lvglFlushCb(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *colorP) {
uint32_t w = area->x2 - area->x1 + 1;
uint32_t h = area->y2 - area->y1 + 1;
#if (LV_COLOR_16_SWAP != 0)
gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#else
gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#endif
lv_disp_flush_ready(disp);
}
static void lvglTick(void *arg) {
LV_UNUSED(arg);
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
}
static void lvglTouchRead(lv_indev_drv_t *indevDrv, lv_indev_data_t *data) {
LV_UNUSED(indevDrv);
uint8_t touched = gTouch.getPoint(gTouchX, gTouchY, gTouch.getSupportTouchPoint());
if (touched > 0) {
gTouchPressed = true;
gLastTouchX = gTouchX[0];
gLastTouchY = gTouchY[0];
gRawTouchCount++;
data->state = LV_INDEV_STATE_PR;
data->point.x = gTouchX[0];
data->point.y = gTouchY[0];
return;
}
gTouchPressed = false;
data->state = LV_INDEV_STATE_REL;
}
static void setStateUi(bool closed) {
if (closed) {
lv_label_set_text(gStateLabel, "CLOSED");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x6DFF8B), 0);
} else {
lv_label_set_text(gStateLabel, "OPEN");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0xFFD166), 0);
}
}
static void updateTouchDiagnostics() {
uint32_t now = millis();
if (now - gLastUiRefreshMs < 40) return;
gLastUiRefreshMs = now;
String raw = gTouchPressed ? "RAW: PRESSED" : "RAW: released";
raw += "\nx=" + String((int)gLastTouchX) + " y=" + String((int)gLastTouchY);
raw += " n=" + String((uint32_t)gRawTouchCount);
lv_label_set_text(gRawLabel, raw.c_str());
if (gTouchPressed && gLastTouchX >= 0 && gLastTouchY >= 0) {
int markerX = gLastTouchX - 8;
int markerY = gLastTouchY - 8;
if (markerX < 0) markerX = 0;
if (markerY < 0) markerY = 0;
lv_obj_set_pos(gMarker, markerX, markerY);
lv_obj_clear_flag(gMarker, LV_OBJ_FLAG_HIDDEN);
} else {
lv_obj_add_flag(gMarker, LV_OBJ_FLAG_HIDDEN);
}
}
static void actuallyEnterSensorMode() {
gEnterPending = false;
// Make the visual transition happen BEFORE the USB data pins are repurposed.
lv_label_set_text(gModeLabel, "SENSOR MODE");
lv_label_set_text(gActionButtonLabel, "Restart to USB");
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0xA33D4F), LV_PART_MAIN | LV_STATE_DEFAULT);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0xC94F65), LV_PART_MAIN | LV_STATE_PRESSED);
lv_label_set_text(gEventLabel, "GPIO19=D- LOW GPIO20=D+ INPUT_PULLUP");
lv_label_set_text(gStateLabel, "SWITCHING...");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x72D6FF), 0);
lv_refr_now(nullptr);
delay(60);
// Intentionally repurpose only USB D-/D+. These are not LCD or touch pins.
// Do NOT call Serial.flush() here: USB CDC may already be disappearing.
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, LOW);
pinMode(kUsbDpPin, INPUT_PULLUP);
gSensorMode = true;
gLastRawClosed = (digitalRead(kUsbDpPin) == LOW);
gStableClosed = gLastRawClosed;
gLastRawChangeMs = millis();
setStateUi(gStableClosed);
}
static void actionButtonEventCb(lv_event_t *event) {
lv_event_code_t code = lv_event_get_code(event);
if (code == LV_EVENT_PRESSED) {
gButtonPressCount++;
String text = "BUTTON PRESSED #" + String(gButtonPressCount);
lv_label_set_text(gEventLabel, text.c_str());
if (!gSensorMode && !gEnterPending) {
lv_label_set_text(gActionButtonLabel, "Starting...");
lv_label_set_text(gStateLabel, "TOUCH OK");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x7CFF8A), 0);
}
return;
}
if (code != LV_EVENT_CLICKED) return;
gButtonClickCount++;
if (!gSensorMode) {
lv_label_set_text(gModeLabel, "USB MODE");
lv_label_set_text(gActionButtonLabel, "TOUCH OK");
lv_label_set_text(gStateLabel, "PRESS BOOT");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0xFFD166), 0);
String text = "TOUCH CLICK OK #" + String(gButtonClickCount) + " use BOOT button";
lv_label_set_text(gEventLabel, text.c_str());
lv_refr_now(nullptr);
return;
}
lv_label_set_text(gModeLabel, "RESTARTING TO USB...");
lv_label_set_text(gActionButtonLabel, "Restarting...");
lv_label_set_text(gStateLabel, "USB NEXT BOOT");
lv_refr_now(nullptr);
delay(180);
ESP.restart();
}
static void requestEnterSensorMode(const char *source) {
if (gSensorMode || gEnterPending) {
return;
}
gEnterPending = true;
gEnterAtMs = millis() + kEnterDelayMs;
lv_label_set_text(gModeLabel, "START RECEIVED");
lv_label_set_text(gActionButtonLabel, "Starting sensor...");
String text = String(source) + " OK waiting 250 ms";
lv_label_set_text(gEventLabel, text.c_str());
lv_label_set_text(gStateLabel, "STARTING...");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x7CFF8A), 0);
lv_refr_now(nullptr);
}
static void pollUserButton() {
bool rawPressed = (digitalRead(kUserButtonPin) == LOW);
uint32_t now = millis();
if (rawPressed != gLastButtonRawPressed) {
gLastButtonRawPressed = rawPressed;
gLastButtonRawChangeMs = now;
}
if ((now - gLastButtonRawChangeMs) < kButtonDebounceMs || rawPressed == gButtonStablePressed) {
return;
}
gButtonStablePressed = rawPressed;
if (!gButtonStablePressed) {
return;
}
gButtonClickCount++;
if (!gSensorMode) {
requestEnterSensorMode("BOOT BUTTON");
return;
}
lv_label_set_text(gModeLabel, "RESTARTING TO USB...");
lv_label_set_text(gActionButtonLabel, "Restarting...");
lv_label_set_text(gStateLabel, "USB NEXT BOOT");
lv_refr_now(nullptr);
delay(180);
ESP.restart();
}
static void createUi() {
lv_obj_t *screen = lv_scr_act();
lv_obj_set_style_bg_color(screen, lv_color_hex(0x000000), 0);
lv_obj_set_style_bg_opa(screen, LV_OPA_COVER, 0);
lv_obj_t *title = lv_label_create(screen);
lv_label_set_text(title, "USB CONTACT DEBUG");
lv_obj_set_style_text_font(title, &lv_font_montserrat_22, 0);
lv_obj_set_style_text_color(title, lv_color_hex(0xFFFFFF), 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 10);
gRawLabel = lv_label_create(screen);
lv_label_set_text(gRawLabel, "RAW: released\nx=-1 y=-1 n=0");
lv_obj_set_style_text_font(gRawLabel, &lv_font_montserrat_16, 0);
lv_obj_set_style_text_color(gRawLabel, lv_color_hex(0x9EE493), 0);
lv_obj_align(gRawLabel, LV_ALIGN_TOP_LEFT, 14, 48);
gModeLabel = lv_label_create(screen);
lv_label_set_text(gModeLabel, "USB MODE");
lv_obj_set_style_text_font(gModeLabel, &lv_font_montserrat_18, 0);
lv_obj_set_style_text_color(gModeLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_align(gModeLabel, LV_ALIGN_TOP_RIGHT, -14, 50);
gEventLabel = lv_label_create(screen);
lv_label_set_text(gEventLabel, "Button events: waiting");
lv_obj_set_width(gEventLabel, 440);
lv_label_set_long_mode(gEventLabel, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(gEventLabel, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_font(gEventLabel, &lv_font_montserrat_16, 0);
lv_obj_set_style_text_color(gEventLabel, lv_color_hex(0xFFD166), 0);
lv_obj_align(gEventLabel, LV_ALIGN_TOP_MID, 0, 102);
gStateLabel = lv_label_create(screen);
lv_label_set_text(gStateLabel, "READY");
lv_obj_set_style_text_font(gStateLabel, &lv_font_montserrat_40, 0);
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_align(gStateLabel, LV_ALIGN_CENTER, 0, -52);
// Put the button in almost the same position/size as the known-working touch debug sketch.
gActionButton = lv_btn_create(screen);
lv_obj_set_size(gActionButton, 360, 110);
lv_obj_align(gActionButton, LV_ALIGN_CENTER, 0, 52);
lv_obj_set_style_radius(gActionButton, 18, 0);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x2A9D8F), LV_PART_MAIN | LV_STATE_DEFAULT);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x47C7B6), LV_PART_MAIN | LV_STATE_PRESSED);
lv_obj_set_style_border_width(gActionButton, 3, 0);
lv_obj_set_style_border_color(gActionButton, lv_color_hex(0xBDE0FE), 0);
lv_obj_add_event_cb(gActionButton, actionButtonEventCb, LV_EVENT_ALL, nullptr);
gActionButtonLabel = lv_label_create(gActionButton);
lv_label_set_text(gActionButtonLabel, "START");
lv_obj_set_style_text_font(gActionButtonLabel, &lv_font_montserrat_28, 0);
lv_obj_set_style_text_color(gActionButtonLabel, lv_color_hex(0xFFFFFF), 0);
lv_obj_center(gActionButtonLabel);
lv_obj_t *hint = lv_label_create(screen);
lv_label_set_text(hint, "Press BOOT button to START. Touch button only checks touch UI.");
lv_obj_set_width(hint, 440);
lv_label_set_long_mode(hint, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(hint, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_font(hint, &lv_font_montserrat_14, 0);
lv_obj_set_style_text_color(hint, lv_color_hex(0xD9D9D9), 0);
lv_obj_align(hint, LV_ALIGN_BOTTOM_MID, 0, -18);
gMarker = lv_obj_create(screen);
lv_obj_set_size(gMarker, 16, 16);
lv_obj_set_style_radius(gMarker, LV_RADIUS_CIRCLE, 0);
lv_obj_set_style_bg_color(gMarker, lv_color_hex(0xFF4D6D), 0);
lv_obj_set_style_border_width(gMarker, 2, 0);
lv_obj_set_style_border_color(gMarker, lv_color_hex(0xFFFFFF), 0);
lv_obj_add_flag(gMarker, LV_OBJ_FLAG_HIDDEN);
}
static void pollContact() {
if (!gSensorMode) return;
bool rawClosed = (digitalRead(kUsbDpPin) == LOW);
uint32_t now = millis();
if (rawClosed != gLastRawClosed) {
gLastRawClosed = rawClosed;
gLastRawChangeMs = now;
}
if ((now - gLastRawChangeMs) >= kDebounceMs && gStableClosed != gLastRawClosed) {
gStableClosed = gLastRawClosed;
setStateUi(gStableClosed);
}
}
void setup() {
Serial.begin(115200);
pinMode(kUserButtonPin, INPUT_PULLUP);
Wire.begin(IIC_SDA, IIC_SCL);
pinMode(TP_RST, OUTPUT);
pinMode(TP_INT, INPUT);
digitalWrite(TP_RST, LOW);
delay(30);
digitalWrite(TP_RST, HIGH);
delay(50);
delay(1000);
gTouch.setPins(TP_RST, TP_INT);
bool touchOk = gTouch.begin(Wire, 0x5A, IIC_SDA, IIC_SCL);
if (!touchOk) {
Serial.println("Touch init failed");
} else {
Serial.print("Touch model: ");
Serial.println(gTouch.getModelName());
gTouch.sleep();
gTouch.reset();
gTouch.setMaxCoordinates(480, 480);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
}
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(0x0000);
lv_init();
uint32_t screenWidth = gfx->width();
uint32_t screenHeight = gfx->height();
gBuf1 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
gBuf2 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
lv_disp_draw_buf_init(&gDrawBuf, gBuf1, gBuf2, screenWidth * screenHeight / 4);
static lv_disp_drv_t dispDrv;
lv_disp_drv_init(&dispDrv);
dispDrv.hor_res = screenWidth;
dispDrv.ver_res = screenHeight;
dispDrv.flush_cb = lvglFlushCb;
dispDrv.draw_buf = &gDrawBuf;
lv_disp_drv_register(&dispDrv);
static lv_indev_drv_t indevDrv;
lv_indev_drv_init(&indevDrv);
indevDrv.type = LV_INDEV_TYPE_POINTER;
indevDrv.read_cb = lvglTouchRead;
lv_indev_drv_register(&indevDrv);
const esp_timer_create_args_t lvglTickTimerArgs = {
.callback = &lvglTick,
.name = "lvgl_tick"};
esp_timer_handle_t lvglTickTimer = nullptr;
esp_timer_create(&lvglTickTimerArgs, &lvglTickTimer);
esp_timer_start_periodic(lvglTickTimer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000);
createUi();
Serial.println("USB contact sensor DEBUG ready. USB pins remain untouched until START click.");
}
void loop() {
updateTouchDiagnostics();
pollUserButton();
pollContact();
if (gEnterPending && (int32_t)(millis() - gEnterAtMs) >= 0) {
actuallyEnterSensorMode();
}
lv_timer_handler();
delay(5);
}
@@ -0,0 +1,250 @@
#include <Arduino.h>
#include <Wire.h>
#include <lvgl.h>
#include <Arduino_GFX_Library.h>
#include "pin_config.h"
#include "TouchDrvCSTXXX.hpp"
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
// ESP32-S3 native USB pins.
static constexpr int kUsbDmPin = 19; // USB D-
static constexpr int kUsbDpPin = 20; // USB D+
static constexpr uint32_t kDebounceMs = 20;
static lv_disp_draw_buf_t gDrawBuf;
static lv_color_t *gBuf1 = nullptr;
static lv_color_t *gBuf2 = nullptr;
static lv_obj_t *gModeLabel = nullptr;
static lv_obj_t *gStateLabel = nullptr;
static lv_obj_t *gHintLabel = nullptr;
static lv_obj_t *gActionButton = nullptr;
static lv_obj_t *gActionButtonLabel = nullptr;
static TouchDrvCST92xx gTouch;
static int16_t gTouchX[5];
static int16_t gTouchY[5];
static bool gSensorMode = false;
static bool gStableClosed = false;
static bool gLastRawClosed = false;
static uint32_t gLastRawChangeMs = 0;
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
LCD_CS, LCD_SCLK, LCD_SDIO0, LCD_SDIO1, LCD_SDIO2, LCD_SDIO3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, LCD_RESET, 0, LCD_WIDTH, LCD_HEIGHT, 0, 0, 0, 0);
static void lvglFlushCb(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *colorP) {
uint32_t w = area->x2 - area->x1 + 1;
uint32_t h = area->y2 - area->y1 + 1;
#if (LV_COLOR_16_SWAP != 0)
gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#else
gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#endif
lv_disp_flush_ready(disp);
}
static void lvglTick(void *arg) {
LV_UNUSED(arg);
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
}
static void lvglTouchRead(lv_indev_drv_t *indevDrv, lv_indev_data_t *data) {
LV_UNUSED(indevDrv);
uint8_t touched = gTouch.getPoint(gTouchX, gTouchY, gTouch.getSupportTouchPoint());
if (touched > 0) {
data->state = LV_INDEV_STATE_PR;
data->point.x = gTouchX[0];
data->point.y = gTouchY[0];
return;
}
data->state = LV_INDEV_STATE_REL;
}
static void setStateUi(bool closed) {
if (closed) {
lv_label_set_text(gStateLabel, "CLOSED");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x7CFF8A), 0);
} else {
lv_label_set_text(gStateLabel, "OPEN");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0xFFCC66), 0);
}
}
static void enterSensorMode() {
// From this moment the native USB data pair is no longer USB.
// D- is held LOW, D+ is read with the ESP32-S3 internal pull-up.
// A passive switch between D- and D+ therefore reads LOW when closed.
Serial.flush();
delay(30);
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, LOW);
pinMode(kUsbDpPin, INPUT_PULLUP);
gSensorMode = true;
gLastRawClosed = (digitalRead(kUsbDpPin) == LOW);
gStableClosed = gLastRawClosed;
gLastRawChangeMs = millis();
lv_label_set_text(gModeLabel, "Sensor mode");
lv_label_set_text(gHintLabel, "USB D- / D+ are now the contact input.\nDo not connect this port to a computer.");
lv_label_set_text(gActionButtonLabel, "Restart to USB");
setStateUi(gStableClosed);
}
static void actionButtonEventCb(lv_event_t *event) {
if (lv_event_get_code(event) != LV_EVENT_CLICKED) {
return;
}
if (!gSensorMode) {
enterSensorMode();
return;
}
lv_label_set_text(gModeLabel, "Restarting...");
lv_label_set_text(gHintLabel, "USB mode will return after reboot.");
lv_timer_handler();
delay(150);
ESP.restart();
}
static void createUi() {
lv_obj_t *screen = lv_scr_act();
lv_obj_set_style_bg_color(screen, lv_color_hex(0x0B1320), 0);
lv_obj_set_style_bg_opa(screen, LV_OPA_COVER, 0);
lv_obj_t *title = lv_label_create(screen);
lv_label_set_text(title, "USB CONTACT TEST");
lv_obj_set_style_text_color(title, lv_color_hex(0xFFFFFF), 0);
lv_obj_set_style_text_font(title, &lv_font_montserrat_22, 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 26);
gModeLabel = lv_label_create(screen);
lv_label_set_text(gModeLabel, "USB mode");
lv_obj_set_style_text_color(gModeLabel, lv_color_hex(0xB8C8DC), 0);
lv_obj_set_style_text_font(gModeLabel, &lv_font_montserrat_18, 0);
lv_obj_align(gModeLabel, LV_ALIGN_TOP_MID, 0, 72);
gStateLabel = lv_label_create(screen);
lv_label_set_text(gStateLabel, "READY");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_set_style_text_font(gStateLabel, &lv_font_montserrat_40, 0);
lv_obj_align(gStateLabel, LV_ALIGN_CENTER, 0, -56);
gHintLabel = lv_label_create(screen);
lv_label_set_text(gHintLabel, "USB is normal now.\nTap Start to use D- / D+ as a contact sensor.");
lv_obj_set_width(gHintLabel, 390);
lv_label_set_long_mode(gHintLabel, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(gHintLabel, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_color(gHintLabel, lv_color_hex(0xD5DCE5), 0);
lv_obj_set_style_text_font(gHintLabel, &lv_font_montserrat_16, 0);
lv_obj_align(gHintLabel, LV_ALIGN_CENTER, 0, 18);
gActionButton = lv_btn_create(screen);
lv_obj_set_size(gActionButton, 260, 72);
lv_obj_align(gActionButton, LV_ALIGN_BOTTOM_MID, 0, -48);
lv_obj_set_style_radius(gActionButton, 18, 0);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x2A9D8F), 0);
lv_obj_set_style_border_width(gActionButton, 0, 0);
lv_obj_add_event_cb(gActionButton, actionButtonEventCb, LV_EVENT_CLICKED, nullptr);
gActionButtonLabel = lv_label_create(gActionButton);
lv_label_set_text(gActionButtonLabel, "Start");
lv_obj_set_style_text_color(gActionButtonLabel, lv_color_hex(0xFFFFFF), 0);
lv_obj_set_style_text_font(gActionButtonLabel, &lv_font_montserrat_22, 0);
lv_obj_center(gActionButtonLabel);
}
static void pollContact() {
if (!gSensorMode) {
return;
}
bool rawClosed = (digitalRead(kUsbDpPin) == LOW);
uint32_t now = millis();
if (rawClosed != gLastRawClosed) {
gLastRawClosed = rawClosed;
gLastRawChangeMs = now;
}
if ((now - gLastRawChangeMs) >= kDebounceMs && gStableClosed != gLastRawClosed) {
gStableClosed = gLastRawClosed;
setStateUi(gStableClosed);
}
}
void setup() {
// With the project's FQBN this is the normal ESP32-S3 native USB serial mode.
// No sensor mode is persisted: every reset starts here with normal USB again.
Serial.begin(115200);
Wire.begin(IIC_SDA, IIC_SCL);
pinMode(TP_RST, OUTPUT);
pinMode(TP_INT, INPUT);
digitalWrite(TP_RST, LOW);
delay(30);
digitalWrite(TP_RST, HIGH);
delay(50);
delay(1000);
gTouch.setPins(TP_RST, TP_INT);
bool touchOk = gTouch.begin(Wire, 0x5A, IIC_SDA, IIC_SCL);
if (!touchOk) {
Serial.println("Touch init failed");
} else {
gTouch.sleep();
gTouch.reset();
gTouch.setMaxCoordinates(480, 480);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
}
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(0x0000);
lv_init();
uint32_t screenWidth = gfx->width();
uint32_t screenHeight = gfx->height();
gBuf1 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
gBuf2 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
lv_disp_draw_buf_init(&gDrawBuf, gBuf1, gBuf2, screenWidth * screenHeight / 4);
static lv_disp_drv_t dispDrv;
lv_disp_drv_init(&dispDrv);
dispDrv.hor_res = screenWidth;
dispDrv.ver_res = screenHeight;
dispDrv.flush_cb = lvglFlushCb;
dispDrv.draw_buf = &gDrawBuf;
lv_disp_drv_register(&dispDrv);
static lv_indev_drv_t indevDrv;
lv_indev_drv_init(&indevDrv);
indevDrv.type = LV_INDEV_TYPE_POINTER;
indevDrv.read_cb = lvglTouchRead;
lv_indev_drv_register(&indevDrv);
const esp_timer_create_args_t lvglTickTimerArgs = {
.callback = &lvglTick,
.name = "lvgl_tick"};
esp_timer_handle_t lvglTickTimer = nullptr;
esp_timer_create(&lvglTickTimerArgs, &lvglTickTimer);
esp_timer_start_periodic(lvglTickTimer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000);
createUi();
Serial.println("USB contact sensor test ready; native USB remains active until Start is tapped.");
}
void loop() {
pollContact();
lv_timer_handler();
delay(5);
}