Add capacitive touch-button test optimized from btntest.

TTP223-style debounce (majority, min touch, rearm), SoftSPI+LVGL shell, flashable firmware/cyd.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
2026-10-23 13:15:39 +08:00
commit 7f0f391705
23 changed files with 2014 additions and 0 deletions

131
src/button.cpp Normal file
View File

@@ -0,0 +1,131 @@
#include "button.h"
#include "pins.h"
#include <Arduino.h>
/**
* 触控感应(电容触摸,如 TTP223)相对机械轻触:
* - 无机械弹跳,但接近阈值时会抖沿
* - 手指悬停/缓慢离开易连计
* 策略:多数表决 + 积分迟滞 + 最短确认时间 + 松手再武装
*/
static uint32_t g_count = 0;
static bool g_stable_down = false;
static bool g_counted_this_touch = false;
static int g_active_level = HIGH;
static int g_idle_level = LOW;
static int8_t g_score = 0;
static uint32_t g_down_since_ms = 0;
static uint32_t g_rearm_until_ms = 0;
static uint32_t g_hold_start_ms = 0;
// 比机械键更稳:更宽迟滞、更长确认、松手后再武装
static constexpr int8_t SCORE_MAX = 8;
static constexpr int8_t DOWN_TH = 5; // 约需连续多次“触摸”采样
static constexpr int8_t UP_TH = -4; // 离开要更干净才算松开
static constexpr uint32_t MIN_TOUCH_MS = 35; // 稳定触摸至少这么久才 +1
static constexpr uint32_t REARM_MS = 120; // 松手后冷却,防悬停连计
static constexpr int MAJORITY_N = 5;
static bool raw_is_down(int raw) { return raw == g_active_level; }
static int read_majority() {
int high_n = 0;
for (int i = 0; i < MAJORITY_N; i++) {
if (digitalRead(BTN_PIN) == HIGH) {
high_n++;
}
delayMicroseconds(30);
}
return (high_n >= ((MAJORITY_N / 2) + 1)) ? HIGH : LOW;
}
void button_init() {
// 电容模块多为推挽输出:用浮空 INPUT,避免上/下拉与模块打架
pinMode(BTN_PIN, INPUT);
delay(30);
int high_n = 0;
for (int i = 0; i < 40; i++) {
if (digitalRead(BTN_PIN) == HIGH) {
high_n++;
}
delay(2);
}
g_idle_level = (high_n >= 20) ? HIGH : LOW;
g_active_level = (g_idle_level == HIGH) ? LOW : HIGH;
g_stable_down = false;
g_counted_this_touch = false;
g_score = -SCORE_MAX;
g_down_since_ms = 0;
g_rearm_until_ms = 0;
g_hold_start_ms = 0;
g_count = 0;
Serial.printf("TouchBtn GPIO%d idle=%s active=%s (capacitive, float INPUT)\n",
BTN_PIN, g_idle_level == HIGH ? "HIGH" : "LOW",
g_active_level == HIGH ? "HIGH" : "LOW");
}
bool button_poll_press() {
const int raw = read_majority();
if (raw_is_down(raw)) {
if (g_score < SCORE_MAX) {
g_score++;
}
} else if (g_score > -SCORE_MAX) {
g_score--;
}
const uint32_t now = millis();
bool fired = false;
if (!g_stable_down && g_score >= DOWN_TH) {
g_stable_down = true;
g_counted_this_touch = false;
g_down_since_ms = now;
g_hold_start_ms = now;
} else if (g_stable_down && g_score <= UP_TH) {
g_stable_down = false;
g_hold_start_ms = 0;
g_down_since_ms = 0;
// 松手后冷却:悬停/回弹不会立刻再计
g_rearm_until_ms = now + REARM_MS;
g_counted_this_touch = false;
}
if (g_stable_down && !g_counted_this_touch && now >= g_rearm_until_ms) {
if ((now - g_down_since_ms) >= MIN_TOUCH_MS) {
g_count++;
g_counted_this_touch = true;
fired = true;
Serial.printf("Touch press count=%lu hold>=%lums score=%d\n",
(unsigned long)g_count, (unsigned long)MIN_TOUCH_MS,
(int)g_score);
}
}
return fired;
}
uint32_t button_count() { return g_count; }
void button_reset_count() {
g_count = 0;
Serial.println("TouchBtn count reset");
}
bool button_is_down() { return g_stable_down; }
uint32_t button_hold_ms() {
if (!g_stable_down || g_hold_start_ms == 0) {
return 0;
}
return millis() - g_hold_start_ms;
}
int button_raw_level() { return digitalRead(BTN_PIN); }
int button_active_level() { return g_active_level; }

70
src/main.cpp Normal file
View File

@@ -0,0 +1,70 @@
#include <Arduino.h>
#include <lvgl.h>
#include "button.h"
#include "pins.h"
#include "touch.h"
#include "ui.h"
static constexpr uint32_t DRAW_BUF_SIZE =
(SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8));
static uint32_t draw_buf[DRAW_BUF_SIZE / 4];
void setup() {
Serial.begin(460800);
delay(200);
Serial.println();
Serial.printf("LVGL %d.%d.%d | Capacitive touch btn GPIO%d\n",
lv_version_major(), lv_version_minor(), lv_version_patch(),
BTN_PIN);
Serial.println("BOOT_OK");
pinMode(TFT_BL_PIN, OUTPUT);
digitalWrite(TFT_BL_PIN, HIGH);
touch_init();
button_init();
lv_init();
lv_display_t *disp =
lv_tft_espi_create(SCREEN_WIDTH, SCREEN_HEIGHT, draw_buf, sizeof(draw_buf));
lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_270);
lv_indev_t *indev = lv_indev_create();
lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
lv_indev_set_read_cb(indev, touch_read_cb);
lv_indev_set_display(indev, disp);
ui_create();
}
void loop() {
// 电容模块沿抖更慢:每圈多采几次,配合积分+最短确认
bool pressed = false;
for (int i = 0; i < 4; i++) {
if (button_poll_press()) {
pressed = true;
}
delayMicroseconds(250);
}
static bool last_down = false;
static int last_raw = -1;
static uint32_t last_hold_bucket = 0;
const bool down = button_is_down();
const int raw = button_raw_level();
// hold 每 ~50ms 刷新一次,触摸条能平滑走
const uint32_t hold_bucket = button_hold_ms() / 50;
if (pressed || down != last_down || raw != last_raw ||
(down && hold_bucket != last_hold_bucket)) {
last_down = down;
last_raw = raw;
last_hold_bucket = hold_bucket;
ui_refresh_count();
}
lv_timer_handler();
lv_tick_inc(5);
delay(5);
}

125
src/touch.cpp Normal file
View File

@@ -0,0 +1,125 @@
#include "touch.h"
#include "pins.h"
#include <Arduino.h>
/**
* SoftSPI XPT2046
* BL↔TR 是矩形主对角线镜像(XY 对调),不是 180°(180° 会搞成 TL↔BR)。
* 先按 rot2 得到旧 UI,再做对角修正,反变换喂给 LVGL 270。
*/
int16_t g_dbg_phys_x = -1;
int16_t g_dbg_phys_y = -1;
int16_t g_dbg_logic_x = -1;
int16_t g_dbg_logic_y = -1;
bool g_dbg_touch_down = false;
static void soft_write(uint8_t data) {
for (int i = 7; i >= 0; --i) {
digitalWrite(CYD_TOUCH_MOSI, (data >> i) & 1);
digitalWrite(CYD_TOUCH_CLK, HIGH);
delayMicroseconds(2);
digitalWrite(CYD_TOUCH_CLK, LOW);
delayMicroseconds(2);
}
}
static uint16_t soft_read12() {
uint16_t v = 0;
digitalWrite(CYD_TOUCH_CLK, HIGH);
delayMicroseconds(2);
digitalWrite(CYD_TOUCH_CLK, LOW);
delayMicroseconds(2);
for (int i = 0; i < 12; ++i) {
digitalWrite(CYD_TOUCH_CLK, HIGH);
delayMicroseconds(2);
v = (uint16_t)((v << 1) | (digitalRead(CYD_TOUCH_MISO) ? 1u : 0u));
digitalWrite(CYD_TOUCH_CLK, LOW);
delayMicroseconds(2);
}
return v;
}
static uint16_t xpt_read(uint8_t cmd) {
digitalWrite(CYD_TOUCH_CS, LOW);
soft_write(cmd);
uint16_t v = soft_read12();
digitalWrite(CYD_TOUCH_CS, HIGH);
return v;
}
static int16_t clampi(int32_t v, int32_t lo, int32_t hi) {
if (v < lo) {
return (int16_t)lo;
}
if (v > hi) {
return (int16_t)hi;
}
return (int16_t)v;
}
void touch_init() {
pinMode(CYD_TOUCH_CS, OUTPUT);
pinMode(CYD_TOUCH_CLK, OUTPUT);
pinMode(CYD_TOUCH_MOSI, OUTPUT);
pinMode(CYD_TOUCH_MISO, INPUT);
pinMode(CYD_TOUCH_IRQ, INPUT);
digitalWrite(CYD_TOUCH_CS, HIGH);
digitalWrite(CYD_TOUCH_CLK, LOW);
Serial.println("Touch: SoftSPI + diagonal fix (BL/TR)");
}
void touch_read_cb(lv_indev_t * /*indev*/, lv_indev_data_t *data) {
uint16_t adc_x = xpt_read(0x90);
uint16_t adc_y = xpt_read(0xD0);
adc_x = (uint16_t)((adc_x + xpt_read(0x90)) / 2);
adc_y = (uint16_t)((adc_y + xpt_read(0xD0)) / 2);
const bool irq = (digitalRead(CYD_TOUCH_IRQ) == LOW);
const bool in_range =
(adc_x > 80 && adc_x < 4000 && adc_y > 80 && adc_y < 4000);
if (!in_range || (!irq && (adc_x < 200 || adc_y < 200))) {
data->state = LV_INDEV_STATE_RELEASED;
g_dbg_touch_down = false;
return;
}
const int16_t p_x = (int16_t)adc_x;
const int16_t p_y = (int16_t)(4095 - adc_y);
int16_t x = map(p_x, 200, 3700, 1, SCREEN_WIDTH);
int16_t y = map(p_y, 240, 3800, 1, SCREEN_HEIGHT);
x = clampi(x, 0, SCREEN_WIDTH - 1);
y = clampi(y, 0, SCREEN_HEIGHT - 1);
// 旧 UI(LVGL270):(y, 239-x) — 该空间里 BL↔TR,做主对角线镜像
// (ux,uy) -> (uy*(319/239), ux*(239/319))
const int32_t old_ux = y;
const int32_t old_uy = (SCREEN_WIDTH - 1) - x;
int16_t ui_x = clampi((old_uy * (UI_HOR_RES - 1)) / (UI_VER_RES - 1), 0,
UI_HOR_RES - 1);
int16_t ui_y = clampi((old_ux * (UI_VER_RES - 1)) / (UI_HOR_RES - 1), 0,
UI_VER_RES - 1);
// 反变换喂 LVGL,使最终落在 (ui_x, ui_y)
const int16_t feed_x = (int16_t)((SCREEN_WIDTH - 1) - ui_y);
const int16_t feed_y = ui_x;
g_dbg_phys_x = x;
g_dbg_phys_y = y;
g_dbg_logic_x = ui_x;
g_dbg_logic_y = ui_y;
g_dbg_touch_down = true;
static uint32_t last_log = 0;
if (millis() - last_log > 80) {
last_log = millis();
Serial.printf("Touch UI(%d,%d)\n", ui_x, ui_y);
}
data->point.x = feed_x;
data->point.y = feed_y;
data->state = LV_INDEV_STATE_PRESSED;
}

161
src/ui.cpp Normal file
View File

@@ -0,0 +1,161 @@
#include "ui.h"
#include "button.h"
#include "pins.h"
#include <Arduino.h>
#include <lvgl.h>
#include <stdio.h>
static constexpr uint32_t COL_BG = 0x0A1016;
static constexpr uint32_t COL_INK = 0xEAF0F6;
static constexpr uint32_t COL_MUTED = 0x7A8B9C;
static constexpr uint32_t COL_BTN = 0x243140;
static constexpr uint32_t COL_ACCENT = 0x4FC3F7;
static constexpr uint32_t COL_TOUCH = 0x3DDC97;
static lv_obj_t *lbl_title;
static lv_obj_t *lbl_pin;
static lv_obj_t *lbl_count;
static lv_obj_t *lbl_hint;
static lv_obj_t *lbl_state;
static lv_obj_t *lbl_hold;
static lv_obj_t *lbl_raw;
static lv_obj_t *bar_touch;
static lv_obj_t *btn_reset;
static lv_obj_t *lbl_reset;
static void style_btn(lv_obj_t *btn, uint32_t bg) {
lv_obj_set_style_radius(btn, 10, 0);
lv_obj_set_style_bg_color(btn, lv_color_hex(bg), 0);
lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
lv_obj_set_style_shadow_width(btn, 0, 0);
lv_obj_set_style_border_width(btn, 0, 0);
lv_obj_set_style_pad_all(btn, 0, 0);
}
void ui_refresh_count() {
if (lbl_count) {
lv_label_set_text_fmt(lbl_count, "%lu", (unsigned long)button_count());
}
const bool down = button_is_down();
const uint32_t hold = button_hold_ms();
if (lbl_state) {
lv_label_set_text(lbl_state, down ? "TOUCHING" : "IDLE");
lv_obj_set_style_text_color(lbl_state,
lv_color_hex(down ? COL_TOUCH : COL_MUTED), 0);
}
if (lbl_hold) {
if (down) {
lv_label_set_text_fmt(lbl_hold, "hold %lu ms", (unsigned long)hold);
} else {
lv_label_set_text(lbl_hold, "hold --");
}
lv_obj_set_style_text_color(lbl_hold,
lv_color_hex(down ? COL_ACCENT : COL_MUTED), 0);
}
if (bar_touch) {
// 触摸条:IDLE 空;触摸后按 hold 缓升(约 800ms 满)
int32_t v = 0;
if (down) {
v = (int32_t)((hold > 800) ? 100 : (hold * 100) / 800);
}
lv_bar_set_value(bar_touch, v, LV_ANIM_OFF);
lv_obj_set_style_bg_color(bar_touch,
lv_color_hex(down ? COL_TOUCH : 0x1A2430),
LV_PART_INDICATOR);
}
if (lbl_raw) {
const int lv = button_raw_level();
lv_label_set_text_fmt(lbl_raw, "OUT %s act=%s", lv ? "HIGH" : "LOW",
button_active_level() ? "HIGH" : "LOW");
lv_obj_set_style_text_color(lbl_raw,
lv_color_hex(lv == button_active_level()
? COL_TOUCH
: COL_MUTED),
0);
}
}
static void on_reset(lv_event_t *e) {
if (lv_event_get_code(e) != LV_EVENT_CLICKED) {
return;
}
button_reset_count();
ui_refresh_count();
}
void ui_create() {
lv_obj_t *scr = lv_screen_active();
lv_obj_set_style_bg_color(scr, lv_color_hex(COL_BG), 0);
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, 0);
lbl_title = lv_label_create(scr);
lv_label_set_text(lbl_title, "Touch");
lv_obj_set_style_text_color(lbl_title, lv_color_hex(COL_INK), 0);
lv_obj_set_style_text_font(lbl_title, &lv_font_montserrat_28, 0);
lv_obj_align(lbl_title, LV_ALIGN_TOP_MID, 0, 2);
lbl_pin = lv_label_create(scr);
lv_label_set_text_fmt(lbl_pin, "Cap OUT->GPIO%d 3.3V", BTN_PIN);
lv_obj_set_style_text_color(lbl_pin, lv_color_hex(COL_MUTED), 0);
lv_obj_set_style_text_font(lbl_pin, &lv_font_montserrat_14, 0);
lv_obj_align(lbl_pin, LV_ALIGN_TOP_MID, 0, 32);
lbl_count = lv_label_create(scr);
lv_label_set_text(lbl_count, "0");
lv_obj_set_style_text_color(lbl_count, lv_color_hex(COL_ACCENT), 0);
lv_obj_set_style_text_font(lbl_count, &lv_font_montserrat_28, 0);
lv_obj_align(lbl_count, LV_ALIGN_TOP_MID, 0, 56);
lbl_hint = lv_label_create(scr);
lv_label_set_text(lbl_hint, "count");
lv_obj_set_style_text_color(lbl_hint, lv_color_hex(COL_MUTED), 0);
lv_obj_set_style_text_font(lbl_hint, &lv_font_montserrat_14, 0);
lv_obj_align(lbl_hint, LV_ALIGN_TOP_MID, 0, 90);
lbl_state = lv_label_create(scr);
lv_label_set_text(lbl_state, "IDLE");
lv_obj_set_style_text_color(lbl_state, lv_color_hex(COL_MUTED), 0);
lv_obj_set_style_text_font(lbl_state, &lv_font_montserrat_20, 0);
lv_obj_align(lbl_state, LV_ALIGN_TOP_MID, 0, 110);
lbl_hold = lv_label_create(scr);
lv_label_set_text(lbl_hold, "hold --");
lv_obj_set_style_text_color(lbl_hold, lv_color_hex(COL_MUTED), 0);
lv_obj_set_style_text_font(lbl_hold, &lv_font_montserrat_14, 0);
lv_obj_align(lbl_hold, LV_ALIGN_TOP_MID, 0, 134);
bar_touch = lv_bar_create(scr);
lv_obj_set_size(bar_touch, UI_HOR_RES - 64, 10);
lv_obj_align(bar_touch, LV_ALIGN_TOP_MID, 0, 154);
lv_bar_set_range(bar_touch, 0, 100);
lv_bar_set_value(bar_touch, 0, LV_ANIM_OFF);
lv_obj_set_style_radius(bar_touch, 5, 0);
lv_obj_set_style_bg_color(bar_touch, lv_color_hex(0x1A2430), 0);
lv_obj_set_style_bg_opa(bar_touch, LV_OPA_COVER, 0);
lv_obj_set_style_bg_color(bar_touch, lv_color_hex(COL_TOUCH),
LV_PART_INDICATOR);
lv_obj_set_style_radius(bar_touch, 5, LV_PART_INDICATOR);
lbl_raw = lv_label_create(scr);
lv_label_set_text(lbl_raw, "OUT --");
lv_obj_set_style_text_color(lbl_raw, lv_color_hex(COL_MUTED), 0);
lv_obj_set_style_text_font(lbl_raw, &lv_font_montserrat_14, 0);
lv_obj_align(lbl_raw, LV_ALIGN_TOP_MID, 0, 170);
btn_reset = lv_button_create(scr);
lv_obj_set_size(btn_reset, UI_HOR_RES - 48, 40);
lv_obj_align(btn_reset, LV_ALIGN_TOP_MID, 0, 192);
style_btn(btn_reset, COL_BTN);
lv_obj_set_ext_click_area(btn_reset, 12);
lv_obj_add_event_cb(btn_reset, on_reset, LV_EVENT_CLICKED, nullptr);
lbl_reset = lv_label_create(btn_reset);
lv_label_set_text(lbl_reset, "Reset");
lv_obj_set_style_text_color(lbl_reset, lv_color_hex(COL_INK), 0);
lv_obj_set_style_text_font(lbl_reset, &lv_font_montserrat_20, 0);
lv_obj_center(lbl_reset);
ui_refresh_count();
}