feat: Support Elecrow ThinkNode M9

platformio.ini

@@ -128,7 +128,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/ef573c368767625ffbe8c32cf921ea7366f2dd53.zip
+	https://github.com/meshtastic/device-ui/archive/c868c2adecc210a74931cbd67e9e1ef5b0a874e7.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]

src/PowerFSM.cpp

@@ -173,23 +173,25 @@ static void lsIdle()
                 powerFSM.trigger(EVENT_SERIAL_CONNECTED);
                 break;
 
-            default:
-                // We woke for some other reason (button press, device IRQ interrupt)
-
-#ifdef BUTTON_PIN
-                bool pressed = !digitalRead(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN);
-#else
+            case ESP_SLEEP_WAKEUP_GPIO: {
                 bool pressed = false;
+#if defined(BUTTON_PIN)
+                pressed = !digitalRead(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN);
+#elif defined(KB_INT)
+                // keyboard press (probably) triggered GPIO interrupt
+                pressed = true;
 #endif
-                if (pressed) { // If we woke because of press, instead generate a PRESS event.
+                if (pressed) {
                     powerFSM.trigger(EVENT_PRESS);
-                } else {
-                    // Otherwise let the NB state handle the IRQ (and that state will handle stuff like IRQs etc)
-                    // we lie and say "wake timer" because the interrupt will be handled by the regular IRQ code
-                    powerFSM.trigger(EVENT_WAKE_TIMER);
                 }
                 break;
             }
+            default:
+                // Otherwise let the NB state handle the IRQ (and that state will handle stuff like IRQs etc)
+                // we lie and say "wake timer" because the interrupt will be handled by the regular IRQ code
+                powerFSM.trigger(EVENT_WAKE_TIMER);
+                break;
+            }
         } else {
             // Someone says we can't sleep now, so just save some power by sleeping the CPU for 100ms or so
             delay(100);

src/concurrency/Lock.cpp

@@ -26,6 +26,11 @@ void Lock::lock()
     }
 }
 
+bool Lock::lock(uint32_t timeout)
+{
+    return xSemaphoreTake(handle, pdMS_TO_TICKS(timeout)) == pdTRUE;
+}
+
 void Lock::unlock()
 {
     if (xSemaphoreGive(handle) == false) {

src/concurrency/Lock.h

@@ -22,6 +22,11 @@ class Lock
     // Must not be called from an ISR.
     void lock();
 
+    /// Locks the lock with timeout.
+    //
+    // Must not be called from an ISR.
+    bool lock(uint32_t timeout);
+
     // Unlocks the lock.
     //
     // Must not be called from an ISR.

src/configuration.h

@@ -247,6 +247,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define BBQ10_KB_ADDR 0x1F
 #define MPR121_KB_ADDR 0x5A
 #define TCA8418_KB_ADDR 0x34
+#define TSTC8_KB_ADDR 0x6C // STC8H companion-MCU keypad on the ThinkNode-M9
 
 // -----------------------------------------------------------------------------
 // SENSOR
@@ -264,6 +265,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define QMC5883L_ADDR 0x0D
 #define HMC5883L_ADDR 0x1E
 #define MMC5983MA_ADDR 0x30
+#define QMC6309_ADDR 0x7C
 #define SHTC3_ADDR 0x70
 #define LPS22HB_ADDR 0x5C
 #define LPS22HB_ADDR_ALT 0x5D

src/detect/ScanI2C.cpp

@@ -31,21 +31,21 @@ ScanI2C::FoundDevice ScanI2C::firstRTC() const
 
 ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
 {
-    ScanI2C::DeviceType types[] = {CARDKB, TDECKKB, BBQ10KB, RAK14004, MPR121KB, TCA8418KB};
-    return firstOfOrNONE(6, types);
+    ScanI2C::DeviceType types[] = {CARDKB, TDECKKB, BBQ10KB, RAK14004, MPR121KB, TCA8418KB, STC8HKB};
+    return firstOfOrNONE(7, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const
 {
-    ScanI2C::DeviceType types[] = {MPU6050,  LIS3DH,   BMA423, LSM6DS3, BMX160,    STK8BAXX,
-                                   ICM20948, QMA6100P, BMM150, BMI270,  ICM42607P, ISM330DHCX};
-    return firstOfOrNONE(12, types);
+    ScanI2C::DeviceType types[] = {MPU6050,  LIS3DH, BMA423, LSM6DS3,   BMX160,     STK8BAXX, ICM20948,
+                                   QMA6100P, BMM150, BMI270, ICM42607P, ISM330DHCX, QMI8658};
+    return firstOfOrNONE(13, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstMagnetometer() const
 {
-    ScanI2C::DeviceType types[] = {MMC5983MA, IIS2MDCTR};
-    return firstOfOrNONE(2, types);
+    ScanI2C::DeviceType types[] = {MMC5983MA, IIS2MDCTR, QMC6309};
+    return firstOfOrNONE(3, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstAQI() const

src/detect/ScanI2C.h

@@ -42,6 +42,7 @@ class ScanI2C
         QMC5883L,
         HMC5883L,
         MMC5983MA,
+        QMC6309,
         PMSA003I,
         QMA6100P,
         MPU6050,
@@ -102,6 +103,7 @@ class ScanI2C
         IIS2MDCTR,
         ISM330DHCX,
         SPA06,
+        STC8HKB, // STC8H companion-MCU keypad (ThinkNode-M9)
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;

src/detect/ScanI2CTwoWire.cpp

@@ -406,6 +406,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 }
                 break;
                 SCAN_SIMPLE_CASE(BBQ10_KB_ADDR, BBQ10KB, "BB Q10", (uint8_t)addr.address);
+                SCAN_SIMPLE_CASE(TSTC8_KB_ADDR, STC8HKB, "STC8H KB", (uint8_t)addr.address);
 
                 SCAN_SIMPLE_CASE(ST7567_ADDRESS, SCREEN_ST7567, "ST7567", (uint8_t)addr.address);
 #ifdef HAS_NCP5623
@@ -956,6 +957,20 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
             foundDevices[addr] = type;
         }
     }
+
+    // The QMC6309 magnetometer sits at 0x7C, above the general scan ceiling (the loop above stops at 0x77 to
+    // avoid the reserved 0x78-0x7F block). Probe it explicitly. Gated on the SensorLib driver being present so
+    // only boards that can actually drive the chip poke this reserved address.
+#if __has_include(<SensorQMC6309.hpp>)
+    addr.address = QMC6309_ADDR;
+    i2cBus->beginTransmission(addr.address);
+    if (i2cBus->endTransmission() == 0 &&
+        getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1) == 0x90 /* QMC6309 chip id */) {
+        deviceAddresses[QMC6309] = addr;
+        foundDevices[addr] = QMC6309;
+        logFoundDevice("QMC6309", (uint8_t)addr.address);
+    }
+#endif
 }
 
 void ScanI2CTwoWire::scanPort(I2CPort port)

src/gps/GPS.cpp

@@ -1645,7 +1645,7 @@ GnssModel_t GPS::probe(int serialSpeed)
             {"AG3335", "$PAIR021,AG3335", GNSS_MODEL_AG3335},
             {"AG3352", "$PAIR021,AG3352", GNSS_MODEL_AG3352},
             {"RYS3520", "$PAIR021,REYAX_RYS3520_V2", GNSS_MODEL_AG3352},
-            {"UC6580", "UC6580", GNSS_MODEL_UC6580},
+            {"UC6580", "UC6580", GNSS_MODEL_UC6580}
             // as L76K is sort of a last ditch effort, we won't attempt to detect it by startup messages for now.
             /*{"L76K", "SW=URANUS", GNSS_MODEL_MTK}*/};
         GnssModel_t detectedDriver = getProbeResponse(500, passive_detect, serialSpeed);
@@ -1672,8 +1672,10 @@ GnssModel_t GPS::probe(int serialSpeed)
     case 1: {
 
         // Unicore UFirebirdII Series: UC6580, UM620, UM621, UM670A, UM680A, or UM681A,or CM121
-        std::vector<ChipInfo> unicore = {
-            {"UC6580", "UC6580", GNSS_MODEL_UC6580}, {"UM600", "UM600", GNSS_MODEL_UC6580}, {"CM121", "CM121", GNSS_MODEL_CM121}};
+        std::vector<ChipInfo> unicore = {{"UC6580", "UC6580", GNSS_MODEL_UC6580},
+                                         {"UM600", "UM600", GNSS_MODEL_UC6580},
+                                         {"CM121", "CM121", GNSS_MODEL_CM121},
+                                         {"CC1167Q", "CC1167Q", GNSS_MODEL_CM121}};
         PROBE_FAMILY("Unicore Family", "$PDTINFO", unicore, 500);
         currentDelay = 20;
         currentStep = 2;

src/graphics/draw/UIRenderer.cpp

@@ -23,6 +23,9 @@
 #include "graphics/images.h"
 #include "main.h"
 #include "target_specific.h"
+#ifdef COMPASS_SENSOR_DEBUG
+#include "motion/MotionSensor.h"
+#endif
 #include <OLEDDisplay.h>
 #include <cstring>
 #include <gps/RTC.h>
@@ -1573,6 +1576,26 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
     graphics::drawCommonHeader(display, x, y, titleStr);
     const int *textPos = getTextPositions(display);
 
+#ifdef COMPASS_SENSOR_DEBUG
+    // Optional raw IMU accel + magnetometer x/y/z readout for on-device axis/sign tuning.
+    {
+        char dbg[40];
+        float sx = 0, sy = 0, sz = 0;
+        uint32_t age = 0;
+        if (MotionSensor::getLatestCompassAccelSample(sx, sy, sz, age))
+            snprintf(dbg, sizeof(dbg), "A %.2f %.2f %.2f", sx, sy, sz);
+        else
+            snprintf(dbg, sizeof(dbg), "A ---");
+        display->drawString(x, textPos[line++], dbg);
+
+        if (MotionSensor::getLatestCompassMagSample(sx, sy, sz, age))
+            snprintf(dbg, sizeof(dbg), "M %.2f %.2f %.2f", sx, sy, sz);
+        else
+            snprintf(dbg, sizeof(dbg), "M ---");
+        display->drawString(x, textPos[line++], dbg);
+    }
+#endif
+
     // === First Row: My Location ===
 #if HAS_GPS
     bool origBold = config.display.heading_bold;

src/input/STC8HKeyboard.cpp

@@ -0,0 +1,155 @@
+#include "STC8HKeyboard.h"
+
+#if defined(ELECROW_ThinkNode_M9)
+#include "cardKbI2cImpl.h"
+
+#include "configuration.h"
+
+// ---------------------------------------------------------------------------
+// STC8H companion-MCU keypad driver (ThinkNode-M9).
+//
+// The original STC8HKeyboard.cpp was lost from the reference source tree, so
+// this was recovered from the linked reference firmware.elf (the .o was an LTO
+// object with no machine code; the final ELF had the real inlined bodies).
+//
+// How the hardware works:
+//   - The STC8H raises KB_INT (rising edge, idle-low) when a key is pressed. The ISR
+//     latches key_event; is_key_event() just returns that flag.
+//   - The pressed key code is read over I2C from register 0x05.
+//   - is_key_state() polls KB_INT directly to keep the backlight lit while a
+//     key is held.
+//   - Battery voltage lives in registers 0x01..0x04, little-endian.
+//   - Sleep is requested by writing 0x01 to the STATE register (0x06).
+//   - The keypad backlight (KB_LED) and torch (PIN_LED) are plain host GPIOs,
+//     not I2C commands.
+// ---------------------------------------------------------------------------
+
+STC8HKeyboard Stc8HKeyBoard;
+
+// ISR latched on each KB_INT rising edge (a key was pressed).
+static void has_key_event()
+{
+    Stc8HKeyBoard.key_event = true;
+    if (cardKbI2cImpl) {
+        cardKbI2cImpl->setIntervalFromNow(0);
+        // runASAP = true;
+        BaseType_t higherWake = 0;
+        concurrency::mainDelay.interruptFromISR(&higherWake);
+    }
+}
+
+void STC8HKeyboard::writeRegister(uint8_t reg, uint8_t val)
+{
+    _pWire->beginTransmission(_I2C_addr);
+    _pWire->write(reg);
+    _pWire->write(val);
+    _pWire->endTransmission();
+}
+
+uint8_t STC8HKeyboard::readRegister(uint8_t reg)
+{
+    _pWire->beginTransmission(_I2C_addr);
+    _pWire->write(reg);
+    if (_pWire->endTransmission(false) != 0)
+        return 0xFF;
+    if (_pWire->requestFrom(_I2C_addr, (uint8_t)1) != 1)
+        return 0xFF;
+    return _pWire->read();
+}
+
+void STC8HKeyboard::begin(uint8_t addr, TwoWire *wire)
+{
+    LOG_DEBUG("STC8HKeyboard::begin() addr=0x%02x", addr);
+    _I2C_addr = addr;
+    _pWire = wire;
+    pinMode(KB_INT, INPUT);
+#ifdef KB_LED
+    pinMode(KB_LED, OUTPUT);
+#endif
+#ifdef PIN_LED
+    pinMode(PIN_LED, OUTPUT);
+#endif
+    attachInterrupt(KB_INT, has_key_event, RISING);
+    _pWire->begin();
+    Keyboard_state = true;
+#ifdef ARCH_ESP32
+    // Detach/reattach the key interrupt around ESP32 light sleep
+    lsObserver.observe(&notifyLightSleep);
+    lsEndObserver.observe(&notifyLightSleepEnd);
+#endif
+}
+
+bool STC8HKeyboard::is_Keyboard_begin()
+{
+    return Keyboard_state;
+}
+
+// A key is currently active (KB_INT held); used to wake the keypad backlight.
+bool STC8HKeyboard::is_key_state()
+{
+    return digitalRead(KB_INT);
+}
+
+// A key-press interrupt has been latched since the flag was last cleared.
+bool STC8HKeyboard::is_key_event()
+{
+    return key_event;
+}
+
+uint8_t STC8HKeyboard::bsp_get_key_value()
+{
+    return readRegister(0x01);
+}
+
+// Battery millivolts: registers 0x01..0x04 read little-endian, low 16 bits.
+uint16_t STC8HKeyboard::bsp_get_battery_voltage()
+{
+    if (!Keyboard_state)
+        return 0;
+    uint32_t voltage = 0;
+    for (uint8_t i = 0; i < 4; i++)
+        voltage |= (uint32_t)readRegister(STC8_REG_ADDR_BATTERY + i) << (i * 8);
+    return voltage > 0xFFFF ? 0xFFFF : (uint16_t)voltage;
+}
+
+void STC8HKeyboard::set_keyboard_blight(bool state)
+{
+#ifdef KB_LED
+    digitalWrite(KB_LED, state);
+#else
+    (void)state; // KB_LED pin not defined for this board
+#endif
+}
+
+void STC8HKeyboard::switch_flashlight()
+{
+#ifdef PIN_LED
+    digitalWrite(PIN_LED, !digitalRead(PIN_LED));
+#endif
+    // else: torch pin unresolved on this board (old board used PIN_LED 13,
+    // which the current variant assigns to BATTERY_PIN) -- see variant.h.
+}
+
+void STC8HKeyboard::set_sleep_status(void)
+{
+    writeRegister(STC8_REG_ADDR_STATE, 0x01);
+    _pWire->end();
+}
+
+#ifdef ARCH_ESP32
+// Detach the key interrupt before ESP32 light sleep, so it can't fire while asleep.
+int STC8HKeyboard::beforeLightSleep(void *unused)
+{
+    detachInterrupt(KB_INT);
+    return 0; // Indicates success
+}
+
+// Reattach the key interrupt after waking from light sleep.
+int STC8HKeyboard::afterLightSleep(esp_sleep_wakeup_cause_t cause)
+{
+    attachInterrupt(KB_INT, has_key_event, RISING);
+    return 0; // Indicates success
+}
+#endif
+
+#endif // ELECROW_ThinkNode_M9