T deck: support keyboard, trackball and touchscreen (#2665)

* add hwid for auto-detection

* fix: heltec-wireless-tracker USB serial

* T-Deck support

* trunk fmt

* set FRAMERATE to 1

* fix some defines

* trunk fmt

* corrected vendor link

* T-Deck: support keyboard, trackball & touch screen

* T-Watch add touchscreen defs, remove getTouch

* fix warnings

* getTouch uint16 -> int16

* fix touch x,y

* fix I2C port

* CannedMsgModule: use entire display height

* trunk fmt

* fix I2C issue for T-Watch

* allow dest selection in canned mode

* fix: allow dest selection in canned mode

* use tft.setBrightness() to poweroff display

* Increased t-watch framerate and added back haptic feedback

* add da ref

* Move to touched

* improved sensitivity and accuracy of touch events

* use double tap to send canned message

* fix warning

* trunk fmt

* Remove extra hapticFeedback()

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

src/input/TouchScreenBase.cpp

@@ -0,0 +1,137 @@
+#include "TouchScreenBase.h"
+#include "main.h"
+
+#ifndef TIME_LONG_PRESS
+#define TIME_LONG_PRESS 400
+#endif
+
+// move a minimum distance over the screen to detect a "swipe"
+#ifndef TOUCH_THRESHOLD_X
+#define TOUCH_THRESHOLD_X 30
+#endif
+
+#ifndef TOUCH_THRESHOLD_Y
+#define TOUCH_THRESHOLD_Y 20
+#endif
+
+TouchScreenBase::TouchScreenBase(const char *name, uint16_t width, uint16_t height)
+    : concurrency::OSThread(name), _display_width(width), _display_height(height), _first_x(0), _last_x(0), _first_y(0),
+      _last_y(0), _start(0), _tapped(false), _originName(name)
+{
+}
+
+void TouchScreenBase::init(bool hasTouch)
+{
+    if (hasTouch) {
+        LOG_INFO("TouchScreen initialized %d %d\n", TOUCH_THRESHOLD_X, TOUCH_THRESHOLD_Y);
+        this->setInterval(100);
+    } else {
+        disable();
+        this->setInterval(UINT_MAX);
+    }
+}
+
+int32_t TouchScreenBase::runOnce()
+{
+    TouchEvent e;
+    e.touchEvent = static_cast<char>(TOUCH_ACTION_NONE);
+
+    // process touch events
+    int16_t x, y;
+    bool touched = getTouch(x, y);
+    if (touched) {
+        hapticFeedback();
+        this->setInterval(20);
+        _last_x = x;
+        _last_y = y;
+    }
+    if (touched != _touchedOld) {
+        if (touched) {
+            _state = TOUCH_EVENT_OCCURRED;
+            _start = millis();
+            _first_x = x;
+            _first_y = y;
+        } else {
+            _state = TOUCH_EVENT_CLEARED;
+            time_t duration = millis() - _start;
+            x = _last_x;
+            y = _last_y;
+            this->setInterval(50);
+
+            // compute distance
+            int16_t dx = x - _first_x;
+            int16_t dy = y - _first_y;
+            uint16_t adx = abs(dx);
+            uint16_t ady = abs(dy);
+
+            // swipe horizontal
+            if (adx > ady && adx > TOUCH_THRESHOLD_X) {
+                if (0 > dx) { // swipe right to left
+                    e.touchEvent = static_cast<char>(TOUCH_ACTION_LEFT);
+                    LOG_DEBUG("action SWIPE: right to left\n");
+                } else { // swipe left to right
+                    e.touchEvent = static_cast<char>(TOUCH_ACTION_RIGHT);
+                    LOG_DEBUG("action SWIPE: left to right\n");
+                }
+            }
+            // swipe vertical
+            else if (ady > adx && ady > TOUCH_THRESHOLD_Y) {
+                if (0 > dy) { // swipe bottom to top
+                    e.touchEvent = static_cast<char>(TOUCH_ACTION_UP);
+                    LOG_DEBUG("action SWIPE: bottom to top\n");
+                } else { // swipe top to bottom
+                    e.touchEvent = static_cast<char>(TOUCH_ACTION_DOWN);
+                    LOG_DEBUG("action SWIPE: top to bottom\n");
+                }
+            }
+            // tap
+            else {
+                if (duration > 0 && duration < TIME_LONG_PRESS) {
+                    if (_tapped) {
+                        _tapped = false;
+                        e.touchEvent = static_cast<char>(TOUCH_ACTION_DOUBLE_TAP);
+                        LOG_DEBUG("action DOUBLE TAP(%d/%d)\n", x, y);
+                    } else {
+                        _tapped = true;
+                    }
+                } else {
+                    _tapped = false;
+                }
+            }
+        }
+    }
+    _touchedOld = touched;
+
+    // fire TAP event when no 2nd tap occured within time
+    if (_tapped && (time_t(millis()) - _start) > TIME_LONG_PRESS - 50) {
+        _tapped = false;
+        e.touchEvent = static_cast<char>(TOUCH_ACTION_TAP);
+        LOG_DEBUG("action TAP(%d/%d)\n", _last_x, _last_y);
+    }
+
+    // fire LONG_PRESS event without the need for release
+    if (touched && (time_t(millis()) - _start) > TIME_LONG_PRESS) {
+        // tricky: prevent reoccurring events and another touch event when releasing
+        _start = millis() + 30000;
+        e.touchEvent = static_cast<char>(TOUCH_ACTION_LONG_PRESS);
+        LOG_DEBUG("action LONG PRESS(%d/%d)\n", _last_x, _last_y);
+    }
+
+    if (e.touchEvent != TOUCH_ACTION_NONE) {
+        e.source = this->_originName;
+        e.x = _last_x;
+        e.y = _last_y;
+        onEvent(e);
+    }
+
+    return interval;
+}
+
+void TouchScreenBase::hapticFeedback()
+{
+#ifdef T_WATCH_S3
+    drv.setWaveform(0, 75);
+    drv.setWaveform(1, 0); // end waveform
+    drv.go();
+#endif
+}

src/input/TouchScreenBase.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "InputBroker.h"
+#include "concurrency/OSThread.h"
+#include "mesh/NodeDB.h"
+
+typedef struct _TouchEvent {
+    const char *source;
+    char touchEvent;
+    uint16_t x;
+    uint16_t y;
+} TouchEvent;
+
+class TouchScreenBase : public Observable<const InputEvent *>, public concurrency::OSThread
+{
+  public:
+    explicit TouchScreenBase(const char *name, uint16_t width, uint16_t height);
+    void init(bool hasTouch);
+
+  protected:
+    enum TouchScreenBaseStateType { TOUCH_EVENT_OCCURRED, TOUCH_EVENT_CLEARED };
+
+    enum TouchScreenBaseEventType {
+        TOUCH_ACTION_NONE,
+        TOUCH_ACTION_UP,
+        TOUCH_ACTION_DOWN,
+        TOUCH_ACTION_LEFT,
+        TOUCH_ACTION_RIGHT,
+        TOUCH_ACTION_TAP,
+        TOUCH_ACTION_DOUBLE_TAP,
+        TOUCH_ACTION_LONG_PRESS
+    };
+
+    virtual int32_t runOnce() override;
+
+    virtual bool getTouch(int16_t &x, int16_t &y) = 0;
+    virtual void onEvent(const TouchEvent &event) = 0;
+
+    volatile TouchScreenBaseStateType _state = TOUCH_EVENT_CLEARED;
+    volatile TouchScreenBaseEventType _action = TOUCH_ACTION_NONE;
+    void hapticFeedback();
+
+  protected:
+    uint16_t _display_width;
+    uint16_t _display_height;
+
+  private:
+    bool _touchedOld = false;  // previous touch state
+    int16_t _first_x, _last_x; // horizontal swipe direction
+    int16_t _first_y, _last_y; // vertical swipe direction
+    time_t _start;             // for LONG_PRESS
+    bool _tapped;              // for DOUBLE_TAP
+
+    const char *_originName;
+};

src/input/TouchScreenImpl1.cpp

@@ -0,0 +1,68 @@
+#include "TouchScreenImpl1.h"
+#include "InputBroker.h"
+#include "configuration.h"
+
+TouchScreenImpl1 *touchScreenImpl1;
+
+TouchScreenImpl1::TouchScreenImpl1(uint16_t width, uint16_t height, bool (*getTouch)(int16_t *, int16_t *))
+    : TouchScreenBase("touchscreen1", width, height), _getTouch(getTouch)
+{
+}
+
+void TouchScreenImpl1::init()
+{
+#if !HAS_TOUCHSCREEN
+    TouchScreenBase::init(false);
+    return;
+#else
+    TouchScreenBase::init(true);
+    inputBroker->registerSource(this);
+#endif
+}
+
+bool TouchScreenImpl1::getTouch(int16_t &x, int16_t &y)
+{
+    return _getTouch(&x, &y);
+}
+
+/**
+ * @brief forward touchscreen event
+ *
+ * @param event
+ *
+ * The touchscreen events are translated to input events and reversed
+ */
+void TouchScreenImpl1::onEvent(const TouchEvent &event)
+{
+    InputEvent e;
+    e.source = event.source;
+    switch (event.touchEvent) {
+    case TOUCH_ACTION_LEFT: {
+        e.inputEvent = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT);
+        break;
+    }
+    case TOUCH_ACTION_RIGHT: {
+        e.inputEvent = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT);
+        break;
+    }
+    case TOUCH_ACTION_UP: {
+        e.inputEvent = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP);
+        break;
+    }
+    case TOUCH_ACTION_DOWN: {
+        e.inputEvent = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN);
+        break;
+    }
+    case TOUCH_ACTION_DOUBLE_TAP: {
+        e.inputEvent = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_SELECT);
+        break;
+    }
+    case TOUCH_ACTION_LONG_PRESS: {
+        e.inputEvent = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL);
+        break;
+    }
+    default:
+        return;
+    }
+    this->notifyObservers(&e);
+}

src/input/TouchScreenImpl1.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "TouchScreenBase.h"
+
+class TouchScreenImpl1 : public TouchScreenBase
+{
+  public:
+    TouchScreenImpl1(uint16_t width, uint16_t height, bool (*getTouch)(int16_t *, int16_t *));
+    void init(void);
+
+  protected:
+    virtual bool getTouch(int16_t &x, int16_t &y);
+    virtual void onEvent(const TouchEvent &event);
+
+    bool (*_getTouch)(int16_t *, int16_t *);
+};
+
+extern TouchScreenImpl1 *touchScreenImpl1;

src/input/TrackballInterruptBase.cpp

@@ -0,0 +1,78 @@
+#include "TrackballInterruptBase.h"
+#include "configuration.h"
+
+TrackballInterruptBase::TrackballInterruptBase(const char *name)
+{
+    this->_originName = name;
+}
+
+void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLeft, uint8_t pinRight, uint8_t pinPress,
+                                  char eventDown, char eventUp, char eventLeft, char eventRight, char eventPressed,
+                                  void (*onIntDown)(), void (*onIntUp)(), void (*onIntLeft)(), void (*onIntRight)(),
+                                  void (*onIntPress)())
+{
+    this->_pinDown = pinDown;
+    this->_pinUp = pinUp;
+    this->_pinLeft = pinLeft;
+    this->_pinRight = pinRight;
+    this->_eventDown = eventDown;
+    this->_eventUp = eventUp;
+    this->_eventLeft = eventLeft;
+    this->_eventRight = eventRight;
+    this->_eventPressed = eventPressed;
+
+    pinMode(pinPress, INPUT_PULLUP);
+    pinMode(this->_pinDown, INPUT_PULLUP);
+    pinMode(this->_pinUp, INPUT_PULLUP);
+    pinMode(this->_pinLeft, INPUT_PULLUP);
+    pinMode(this->_pinRight, INPUT_PULLUP);
+
+    attachInterrupt(pinPress, onIntPress, RISING);
+    attachInterrupt(this->_pinDown, onIntDown, RISING);
+    attachInterrupt(this->_pinUp, onIntUp, RISING);
+    attachInterrupt(this->_pinLeft, onIntLeft, RISING);
+    attachInterrupt(this->_pinRight, onIntRight, RISING);
+
+    LOG_DEBUG("Trackball GPIO initialized (%d, %d, %d, %d, %d)\n", this->_pinUp, this->_pinDown, this->_pinLeft, this->_pinRight,
+              pinPress);
+}
+
+void TrackballInterruptBase::intPressHandler()
+{
+    InputEvent e;
+    e.source = this->_originName;
+    e.inputEvent = this->_eventPressed;
+    this->notifyObservers(&e);
+}
+
+void TrackballInterruptBase::intDownHandler()
+{
+    InputEvent e;
+    e.source = this->_originName;
+    e.inputEvent = this->_eventDown;
+    this->notifyObservers(&e);
+}
+
+void TrackballInterruptBase::intUpHandler()
+{
+    InputEvent e;
+    e.source = this->_originName;
+    e.inputEvent = this->_eventUp;
+    this->notifyObservers(&e);
+}
+
+void TrackballInterruptBase::intLeftHandler()
+{
+    InputEvent e;
+    e.source = this->_originName;
+    e.inputEvent = this->_eventLeft;
+    this->notifyObservers(&e);
+}
+
+void TrackballInterruptBase::intRightHandler()
+{
+    InputEvent e;
+    e.source = this->_originName;
+    e.inputEvent = this->_eventRight;
+    this->notifyObservers(&e);
+}

src/input/TrackballInterruptBase.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "InputBroker.h"
+#include "mesh/NodeDB.h"
+
+class TrackballInterruptBase : public Observable<const InputEvent *>
+{
+  public:
+    explicit TrackballInterruptBase(const char *name);
+    void init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLeft, uint8_t pinRight, uint8_t pinPress, char eventDown, char eventUp,
+              char eventLeft, char eventRight, char eventPressed, void (*onIntDown)(), void (*onIntUp)(), void (*onIntLeft)(),
+              void (*onIntRight)(), void (*onIntPress)());
+    void intPressHandler();
+    void intDownHandler();
+    void intUpHandler();
+    void intLeftHandler();
+    void intRightHandler();
+
+  private:
+    uint8_t _pinDown = 0;
+    uint8_t _pinUp = 0;
+    uint8_t _pinLeft = 0;
+    uint8_t _pinRight = 0;
+    char _eventDown = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventUp = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventLeft = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventRight = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventPressed = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    const char *_originName;
+};

src/input/TrackballInterruptImpl1.cpp

@@ -0,0 +1,54 @@
+#include "TrackballInterruptImpl1.h"
+#include "InputBroker.h"
+#include "configuration.h"
+
+TrackballInterruptImpl1 *trackballInterruptImpl1;
+
+TrackballInterruptImpl1::TrackballInterruptImpl1() : TrackballInterruptBase("trackball1") {}
+
+void TrackballInterruptImpl1::init()
+{
+#if !HAS_TRACKBALL
+    // Input device is disabled.
+    return;
+#else
+    uint8_t pinUp = TB_UP;
+    uint8_t pinDown = TB_DOWN;
+    uint8_t pinLeft = TB_LEFT;
+    uint8_t pinRight = TB_RIGHT;
+    uint8_t pinPress = TB_PRESS;
+
+    char eventDown = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN);
+    char eventUp = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP);
+    char eventLeft = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT);
+    char eventRight = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT);
+    char eventPressed = static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_SELECT);
+
+    TrackballInterruptBase::init(pinDown, pinUp, pinLeft, pinRight, pinPress, eventDown, eventUp, eventLeft, eventRight,
+                                 eventPressed, TrackballInterruptImpl1::handleIntDown, TrackballInterruptImpl1::handleIntUp,
+                                 TrackballInterruptImpl1::handleIntLeft, TrackballInterruptImpl1::handleIntRight,
+                                 TrackballInterruptImpl1::handleIntPressed);
+    inputBroker->registerSource(this);
+#endif
+}
+
+void TrackballInterruptImpl1::handleIntDown()
+{
+    trackballInterruptImpl1->intDownHandler();
+}
+void TrackballInterruptImpl1::handleIntUp()
+{
+    trackballInterruptImpl1->intUpHandler();
+}
+void TrackballInterruptImpl1::handleIntLeft()
+{
+    trackballInterruptImpl1->intLeftHandler();
+}
+void TrackballInterruptImpl1::handleIntRight()
+{
+    trackballInterruptImpl1->intRightHandler();
+}
+void TrackballInterruptImpl1::handleIntPressed()
+{
+    trackballInterruptImpl1->intPressHandler();
+}

src/input/TrackballInterruptImpl1.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "TrackballInterruptBase.h"
+
+class TrackballInterruptImpl1 : public TrackballInterruptBase
+{
+  public:
+    TrackballInterruptImpl1();
+    void init();
+    static void handleIntDown();
+    static void handleIntUp();
+    static void handleIntLeft();
+    static void handleIntRight();
+    static void handleIntPressed();
+};
+
+extern TrackballInterruptImpl1 *trackballInterruptImpl1;

src/input/UpDownInterruptBase.cpp

@@ -23,7 +23,7 @@ void UpDownInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinPress,
     attachInterrupt(this->_pinDown, onIntDown, RISING);
     attachInterrupt(this->_pinUp, onIntUp, RISING);
 
-    LOG_DEBUG("GPIO initialized (%d, %d, %d)\n", this->_pinDown, this->_pinUp, pinPress);
+    LOG_DEBUG("Up/down/press GPIO initialized (%d, %d, %d)\n", this->_pinUp, this->_pinDown, pinPress);
 }
 
 void UpDownInterruptBase::intPressHandler()

src/input/cardKbI2cImpl.cpp

@@ -7,7 +7,7 @@ CardKbI2cImpl::CardKbI2cImpl() : KbI2cBase("cardKB") {}
 
 void CardKbI2cImpl::init()
 {
-    if (cardkb_found.address != CARDKB_ADDR) {
+    if (cardkb_found.address != CARDKB_ADDR && cardkb_found.address != TDECK_KB_ADDR) {
         disable();
         return;
     }

src/input/kbI2cBase.cpp

@@ -41,7 +41,7 @@ void write_to_14004(const TwoWire * i2cBus, uint8_t reg, uint8_t data)
 
 int32_t KbI2cBase::runOnce()
 {
-    if (cardkb_found.address != CARDKB_ADDR) {
+    if (cardkb_found.address != CARDKB_ADDR && cardkb_found.address != TDECK_KB_ADDR) {
         // Input device is not detected.
         return INT32_MAX;
     }
@@ -85,9 +85,9 @@ int32_t KbI2cBase::runOnce()
             e.kbchar = PrintDataBuf;
             this->notifyObservers(&e);
         }
-    } else {
-        // m5 cardkb
-        i2cBus->requestFrom(CARDKB_ADDR, 1);
+    } else if (kb_model == 0x00 || kb_model == 0x10) {
+        // m5 cardkb and T-Deck
+        i2cBus->requestFrom(kb_model == 0x00 ? CARDKB_ADDR : TDECK_KB_ADDR, 1);
 
         while (i2cBus->available()) {
             char c = i2cBus->read();
@@ -132,6 +132,8 @@ int32_t KbI2cBase::runOnce()
                 this->notifyObservers(&e);
             }
         }
+    } else {
+        LOG_WARN("Unknown kb_model 0x%02x\n", kb_model);
     }
-    return 500;
+    return 300;
 }