Make the 4-way on the L1 work on press instead of release (#7108)

src/input/TrackballInterruptBase.cpp

@@ -12,6 +12,7 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef
     this->_pinUp = pinUp;
     this->_pinLeft = pinLeft;
     this->_pinRight = pinRight;
+    this->_pinPress = pinPress;
     this->_eventDown = eventDown;
     this->_eventUp = eventUp;
     this->_eventLeft = eventLeft;
@@ -20,23 +21,23 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef
 
     if (pinPress != 255) {
         pinMode(pinPress, INPUT_PULLUP);
-        attachInterrupt(pinPress, onIntPress, RISING);
+        attachInterrupt(pinPress, onIntPress, TB_DIRECTION);
     }
     if (this->_pinDown != 255) {
         pinMode(this->_pinDown, INPUT_PULLUP);
-        attachInterrupt(this->_pinDown, onIntDown, RISING);
+        attachInterrupt(this->_pinDown, onIntDown, TB_DIRECTION);
     }
     if (this->_pinUp != 255) {
         pinMode(this->_pinUp, INPUT_PULLUP);
-        attachInterrupt(this->_pinUp, onIntUp, RISING);
+        attachInterrupt(this->_pinUp, onIntUp, TB_DIRECTION);
     }
     if (this->_pinLeft != 255) {
         pinMode(this->_pinLeft, INPUT_PULLUP);
-        attachInterrupt(this->_pinLeft, onIntLeft, RISING);
+        attachInterrupt(this->_pinLeft, onIntLeft, TB_DIRECTION);
     }
     if (this->_pinRight != 255) {
         pinMode(this->_pinRight, INPUT_PULLUP);
-        attachInterrupt(this->_pinRight, onIntRight, RISING);
+        attachInterrupt(this->_pinRight, onIntRight, TB_DIRECTION);
     }
 
     LOG_DEBUG("Trackball GPIO initialized (%d, %d, %d, %d, %d)", this->_pinUp, this->_pinDown, this->_pinLeft, this->_pinRight,
@@ -67,19 +68,19 @@ int32_t TrackballInterruptBase::runOnce()
         e.inputEvent = this->_eventRight;
     }
 #else
-    if (this->action == TB_ACTION_PRESSED) {
+    if (this->action == TB_ACTION_PRESSED && !digitalRead(_pinPress)) {
         // LOG_DEBUG("Trackball event Press");
         e.inputEvent = this->_eventPressed;
-    } else if (this->action == TB_ACTION_UP) {
+    } else if (this->action == TB_ACTION_UP && !digitalRead(_pinUp)) {
         // LOG_DEBUG("Trackball event UP");
         e.inputEvent = this->_eventUp;
-    } else if (this->action == TB_ACTION_DOWN) {
+    } else if (this->action == TB_ACTION_DOWN && !digitalRead(_pinDown)) {
         // LOG_DEBUG("Trackball event DOWN");
         e.inputEvent = this->_eventDown;
-    } else if (this->action == TB_ACTION_LEFT) {
+    } else if (this->action == TB_ACTION_LEFT && !digitalRead(_pinLeft)) {
         // LOG_DEBUG("Trackball event LEFT");
         e.inputEvent = this->_eventLeft;
-    } else if (this->action == TB_ACTION_RIGHT) {
+    } else if (this->action == TB_ACTION_RIGHT && !digitalRead(_pinRight)) {
         // LOG_DEBUG("Trackball event RIGHT");
         e.inputEvent = this->_eventRight;
     }

src/input/TrackballInterruptBase.h

@@ -3,6 +3,10 @@
 #include "InputBroker.h"
 #include "mesh/NodeDB.h"
 
+#ifndef TB_DIRECTION
+#define TB_DIRECTION RISING
+#endif
+
 class TrackballInterruptBase : public Observable<const InputEvent *>, public concurrency::OSThread
 {
   public:
@@ -16,6 +20,7 @@ class TrackballInterruptBase : public Observable<const InputEvent *>, public con
     void intUpHandler();
     void intLeftHandler();
     void intRightHandler();
+    uint32_t lastTime = 0;
 
     virtual int32_t runOnce() override;
 
@@ -28,14 +33,15 @@ class TrackballInterruptBase : public Observable<const InputEvent *>, public con
         TB_ACTION_LEFT,
         TB_ACTION_RIGHT
     };
-
-    volatile TrackballInterruptBaseActionType action = TB_ACTION_NONE;
-
-  private:
     uint8_t _pinDown = 0;
     uint8_t _pinUp = 0;
     uint8_t _pinLeft = 0;
     uint8_t _pinRight = 0;
+    uint8_t _pinPress = 0;
+
+    volatile TrackballInterruptBaseActionType action = TB_ACTION_NONE;
+
+  private:
     input_broker_event _eventDown = INPUT_BROKER_NONE;
     input_broker_event _eventUp = INPUT_BROKER_NONE;
     input_broker_event _eventLeft = INPUT_BROKER_NONE;

src/input/TrackballInterruptImpl1.cpp

@@ -23,21 +23,41 @@ void TrackballInterruptImpl1::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLe
 
 void TrackballInterruptImpl1::handleIntDown()
 {
-    trackballInterruptImpl1->intDownHandler();
+    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
+        trackballInterruptImpl1->lastTime = millis();
+        trackballInterruptImpl1->intDownHandler();
+        trackballInterruptImpl1->setIntervalFromNow(20);
+    }
 }
 void TrackballInterruptImpl1::handleIntUp()
 {
-    trackballInterruptImpl1->intUpHandler();
+    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
+        trackballInterruptImpl1->lastTime = millis();
+        trackballInterruptImpl1->intUpHandler();
+        trackballInterruptImpl1->setIntervalFromNow(20);
+    }
 }
 void TrackballInterruptImpl1::handleIntLeft()
 {
-    trackballInterruptImpl1->intLeftHandler();
+    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
+        trackballInterruptImpl1->lastTime = millis();
+        trackballInterruptImpl1->intLeftHandler();
+        trackballInterruptImpl1->setIntervalFromNow(20);
+    }
 }
 void TrackballInterruptImpl1::handleIntRight()
 {
-    trackballInterruptImpl1->intRightHandler();
+    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
+        trackballInterruptImpl1->lastTime = millis();
+        trackballInterruptImpl1->intRightHandler();
+        trackballInterruptImpl1->setIntervalFromNow(20);
+    }
 }
 void TrackballInterruptImpl1::handleIntPressed()
 {
-    trackballInterruptImpl1->intPressHandler();
+    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
+        trackballInterruptImpl1->lastTime = millis();
+        trackballInterruptImpl1->intPressHandler();
+        trackballInterruptImpl1->setIntervalFromNow(20);
+    }
 }

variants/seeed_wio_tracker_L1/variant.h

@@ -169,6 +169,7 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 #define TB_LEFT 27
 #define TB_RIGHT 28
 #define TB_PRESS 29
+#define TB_DIRECTION FALLING
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 //  Compatibility Definitions
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━