indicator: RP2040 peripherals for the main firmware

The SenseCAP Indicator RP2040 co-processor serves as a generic
peripheral bridge over a serial protobuf link (interdevice.proto):

- FakeI2C implements TwoWire and tunnels write and read transactions,
  so the standard sensor drivers and the I2C scan work unmodified on
  the bridged second bus (WIRE1)
- FakeUART forwards GPS NMEA to the regular GPS driver
- SD card access with chunked file transfers, paged directory
  listings and card statistics; device-ui loads map tiles and map
  styles from the card behind the RP2040
- link at 2M baud with 4KB chunks, message structs kept off task
  stacks

Log messages carrying their own bracket tag render it like a thread
name. Replaces the earlier IndicatorSensor/COBS approach.

Author: caveman99

platformio.ini

@@ -127,7 +127,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/effbb925a7cbd3ab794dfcc5fa16228217d18408.zip
+	https://github.com/meshtastic/device-ui/archive/dcb45b7d5ab6df2fcc2d66e10df7c2c0fcf3ff51.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]

protobufs

@@ -78,6 +78,17 @@ size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_l
         if (!std::isprint(static_cast<unsigned char>(printBuf[f])) && printBuf[f] != '\n')
             printBuf[f] = '#';
     }
+    // A leading "[Tag] " in the message simulates the thread name tag (used
+    // by contexts without an OSThread, e.g. the device-ui task). Print it
+    // before applying the level color so it renders like a real thread name.
+    size_t tagLen = 0;
+    if (printBuf[0] == '[') {
+        const char *end = (const char *)memchr(printBuf, ']', len < 24 ? len : 24);
+        if (end && (size_t)(end - printBuf) + 1 < len && end[1] == ' ')
+            tagLen = end - printBuf + 2;
+    }
+    if (tagLen)
+        Print::write(printBuf, tagLen);
     if (color && logLevel != nullptr) {
         if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
             Print::write("\u001b[34m", 5);
@@ -88,7 +99,7 @@ size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_l
         if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
             Print::write("\u001b[31m", 5);
     }
-    len = Print::write(printBuf, len);
+    len = tagLen + Print::write(printBuf + tagLen, len - tagLen);
     if (color && logLevel != nullptr) {
         Print::write("\u001b[0m", 4);
     }
@@ -161,7 +172,9 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
 #endif
     }
     auto thread = concurrency::OSThread::currentThread;
-    if (thread) {
+    // A message starting with "[Tag] " brings its own tag (e.g. device-ui
+    // logging from the UI task, where currentThread is unrelated)
+    if (thread && format[0] != '[') {
         print("[");
         // printf("%p ", thread);
         // assert(thread->ThreadName.length());

src/RedirectablePrint.cpp

@@ -395,7 +395,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef WIRE_INTERFACES_COUNT
 // Officially an NRF52 macro
 // Repurposed cross-platform to identify devices using Wire1
-#if defined(I2C_SDA1) || defined(PIN_WIRE1_SDA)
+// The SenseCAP Indicator has a second bus bridged to the RP2040 (FakeI2C)
+#if defined(I2C_SDA1) || defined(PIN_WIRE1_SDA) || defined(SENSECAP_INDICATOR)
 #define WIRE_INTERFACES_COUNT 2
 #elif HAS_WIRE
 #define WIRE_INTERFACES_COUNT 1

src/configuration.h

@@ -8,6 +8,9 @@
 #if defined(ARCH_PORTDUINO)
 #include "linux/LinuxHardwareI2C.h"
 #endif
+#if defined(SENSECAP_INDICATOR)
+#include "mesh/comms/FakeI2C.h"
+#endif
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32)
 #include "meshUtils.h" // vformat
 
@@ -245,7 +248,11 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 
 #if WIRE_INTERFACES_COUNT == 2
     if (port == I2CPort::WIRE1) {
+#if defined(SENSECAP_INDICATOR)
+        i2cBus = FakeWire; // WIRE1 is bridged to the RP2040
+#else
         i2cBus = &Wire1;
+#endif
     } else {
 #endif
         i2cBus = &Wire;
@@ -908,7 +915,9 @@ TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address)
     if (address.port == ScanI2C::I2CPort::WIRE) {
         return &Wire;
     } else {
-#if WIRE_INTERFACES_COUNT == 2
+#if defined(SENSECAP_INDICATOR)
+        return FakeWire; // WIRE1 is bridged to the RP2040
+#elif WIRE_INTERFACES_COUNT == 2
         return &Wire1;
 #else
         return &Wire;

src/detect/ScanI2CTwoWire.cpp

@@ -46,7 +46,9 @@ template <typename T, std::size_t N> std::size_t array_count(const T (&)[N])
 #define GPS_SERIAL_PORT Serial1
 #endif
 
-#if defined(ARCH_NRF52)
+#if defined(SENSECAP_INDICATOR)
+FakeUART *GPS::_serial_gps = FakeSerial;
+#elif defined(ARCH_NRF52)
 Uart *GPS::_serial_gps = &GPS_SERIAL_PORT;
 #elif defined(ARCH_ESP32) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32)
 HardwareSerial *GPS::_serial_gps = &GPS_SERIAL_PORT;
@@ -1428,6 +1430,7 @@ void GPS::publishUpdate()
 
 int32_t GPS::runOnce()
 {
+#if !defined(SENSECAP_INDICATOR)
     if (!GPSInitFinished) {
         if (!_serial_gps || config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
             LOG_INFO("GPS set to not-present. Skip probe");
@@ -1448,6 +1451,7 @@ int32_t GPS::runOnce()
         GPSInitFinished = true;
         publishUpdate();
     }
+#endif
 
     // ======================== GPS_ACTIVE state ========================
     // In GPS_ACTIVE state, GPS is powered on and we're receiving NMEA messages.
@@ -1910,8 +1914,10 @@ std::unique_ptr<GPS> GPS::createGps()
     } else
         return nullptr;
 #endif
+#if !defined(SENSECAP_INDICATOR)
     if (!_rx_gpio || !_serial_gps) // Configured to have no GPS at all
         return nullptr;
+#endif
 
     auto new_gps = std::unique_ptr<GPS>(new GPS());
     new_gps->rx_gpio = _rx_gpio;

src/gps/GPS.cpp

@@ -13,6 +13,10 @@
 #include "input/UpDownInterruptImpl1.h"
 #include "modules/PositionModule.h"
 
+#ifdef SENSECAP_INDICATOR
+#include "mesh/comms/FakeUART.h"
+#endif
+
 // Allow defining the polarity of the ENABLE output.  default is active high
 #ifndef GPS_EN_ACTIVE
 #define GPS_EN_ACTIVE 1
@@ -219,7 +223,9 @@ class GPS : private concurrency::OSThread
     CallbackObserver<GPS, void *> notifyDeepSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
 
     /** If !NULL we will use this serial port to construct our GPS */
-#if defined(ARCH_RP2040)
+#if defined(SENSECAP_INDICATOR)
+    static FakeUART *_serial_gps;
+#elif defined(ARCH_RP2040)
     static SerialUART *_serial_gps;
 #elif defined(ARCH_NRF52)
     static Uart *_serial_gps;

src/gps/GPS.h

@@ -14,6 +14,85 @@
 #include <thread>
 #endif
 
+#ifdef SENSECAP_INDICATOR
+#include "graphics/map/RemoteSDService.h"
+#include "input/I2CKeyboardScanner.h"
+#include "mesh/IndicatorSerial.h"
+#include "mesh/comms/FakeI2C.h"
+
+// Serves the UI map tiles from the SD card behind the RP2040, chunk-wise
+// over the interdevice link
+class IndicatorRemoteFS : public IRemoteFS
+{
+  public:
+    bool readChunk(const char *path, uint32_t offset, uint8_t *buf, uint32_t len, uint32_t *bytesRead,
+                   uint32_t *fileSize) override
+    {
+        if (!sensecapIndicator)
+            return false;
+        memset(&result, 0, sizeof(result));
+        if (!sensecapIndicator->file_read(path, offset, len, &result) || !result.success)
+            return false;
+        uint32_t n = result.filedata.size;
+        if (n > len)
+            n = len;
+        memcpy(buf, result.filedata.bytes, n);
+        *bytesRead = n;
+        // lv_fs positions are 32 bit, map tiles never come close
+        *fileSize = (uint32_t)result.file_size;
+        return true;
+    }
+
+    bool writeChunk(const char *path, uint32_t offset, const uint8_t *buf, uint32_t len, bool create) override
+    {
+        if (!sensecapIndicator)
+            return false;
+        memset(&result, 0, sizeof(result));
+        return sensecapIndicator->file_write(path, offset, buf, len, create, &result) && result.success;
+    }
+
+    bool sdInfo(RemoteSdInfo &info) override
+    {
+        if (!sensecapIndicator)
+            return false;
+        meshtastic_SdCardInfo result = meshtastic_SdCardInfo_init_zero;
+        if (!sensecapIndicator->sd_info(&result))
+            return false;
+        info.present = result.present;
+        info.cardType = (uint8_t)result.card_type;
+        info.fatType = (uint8_t)result.fat_type;
+        info.cardSize = result.card_size;
+        info.usedBytes = result.used_bytes;
+        info.freeBytes = result.free_bytes;
+        return true;
+    }
+
+    bool listDir(const char *path, std::set<std::string> &entries) override
+    {
+        if (!sensecapIndicator)
+            return false;
+        uint32_t offset = 0;
+        while (true) {
+            memset(&listing, 0, sizeof(listing));
+            if (!sensecapIndicator->list_directory(path, offset, &listing) || !listing.success)
+                return false;
+            for (pb_size_t i = 0; i < listing.filenames_count; i++)
+                entries.insert(listing.filenames[i]);
+            offset += listing.filenames_count;
+            if (listing.filenames_count == 0 || offset >= listing.total_count)
+                break;
+        }
+        return true;
+    }
+
+  private:
+    // Several KB each, kept off the UI task stack. All file operations
+    // originate from the single UI task.
+    meshtastic_FileTransfer result;
+    meshtastic_DirectoryListing listing;
+};
+#endif
+
 DeviceScreen *deviceScreen = nullptr;
 
 #ifndef TFT_TASK_STACK_SIZE
@@ -40,6 +119,12 @@ void tft_task_handler(void *param = nullptr)
 
 void tftSetup(void)
 {
+#ifdef SENSECAP_INDICATOR
+    RemoteSDService::setBackend(new IndicatorRemoteFS());
+    // the second bus is bridged to the RP2040, keep the keyboard scan off the
+    // uninitialized local Wire1
+    I2CKeyboardScanner::setSecondaryBus(FakeWire);
+#endif
 #ifndef ARCH_PORTDUINO
     deviceScreen = &DeviceScreen::create();
     PacketAPI::create(PacketServer::init());

src/graphics/tftSetup.cpp

@@ -30,6 +30,11 @@
 #include "detect/ScanI2C.h"
 #include "error.h"
 
+#ifdef SENSECAP_INDICATOR // on the indicator run the additional serial port for the RP2040
+#include "IndicatorSerial.h"
+#include "mesh/comms/FakeI2C.h"
+#endif
+
 #if !MESHTASTIC_EXCLUDE_I2C
 #include "detect/ScanI2CConsumer.h"
 #include "detect/ScanI2CTwoWire.h"
@@ -553,7 +558,10 @@ void setup()
 #endif
 
 #if !MESHTASTIC_EXCLUDE_I2C
-#if defined(I2C_SDA1) && defined(ARCH_RP2040)
+#if defined(SENSECAP_INDICATOR)
+    // The Sensecap Indicator has its second I2C bus on the RP2040, bridged
+    // over serial as FakeWire. No local interface to initialize.
+#elif defined(I2C_SDA1) && defined(ARCH_RP2040)
     Wire1.setSDA(I2C_SDA1);
     Wire1.setSCL(I2C_SCL1);
     Wire1.begin();
@@ -616,6 +624,18 @@ void setup()
     mcp23017EarlyInit();
 #endif
 
+#ifdef SENSECAP_INDICATOR
+    // Power the RP2040 co-processor and start the interdevice link before the
+    // I2C scan, so that its bus can be probed through the bridge
+#ifdef SENSOR_POWER_CTRL_EXPANDER
+    pinMode(SENSOR_POWER_CTRL_EXPANDER, OUTPUT);
+    digitalWrite(SENSOR_POWER_CTRL_EXPANDER, SENSOR_POWER_ON_EXPANDER);
+#endif
+    sensecapIndicator = new SensecapIndicator(Serial2);
+    if (!sensecapIndicator->wait_ready(3000))
+        LOG_WARN("RP2040 co-processor not answering, bridged I2C bus unavailable");
+#endif
+
 #if !MESHTASTIC_EXCLUDE_I2C
     // We need to scan here to decide if we have a screen for nodeDB.init() and because power has been applied to
     // accessories
@@ -624,7 +644,7 @@ void setup()
     LOG_INFO("Scan for i2c devices");
 #endif
 
-#if defined(I2C_SDA1) || (defined(NRF52840_XXAA) && (WIRE_INTERFACES_COUNT == 2))
+#if defined(SENSECAP_INDICATOR) || defined(I2C_SDA1) || (defined(NRF52840_XXAA) && (WIRE_INTERFACES_COUNT == 2))
     i2cScanner->scanPort(ScanI2C::I2CPort::WIRE1);
 #endif