GPS - I2c Refactor, put back missing autodetect from merge, crash on GPSEvent erroneous publish

Author: brentru

examples/Wippersnapper_demo_offline_netiface/Wippersnapper_demo_offline_netiface.ino

@@ -1,5 +1,5 @@
-// Adafruit IO WipperSnapper
-// USE ONLY WITH DEVICES WITHOUT A NETWORK ADAPTER LIKE RP2040 PICO
+// Adafruit IO WipperSnapper - Offline Mode with Network Interface
+// USE ONLY WITH DEVICES WITH A NETWORK ADAPTER LIKE ESP32-x
 //
 // Adafruit invests time and resources providing this open source code.
 // Please support Adafruit and open source hardware by purchasing

examples/Wippersnapper_demo_offline_nonetiface/Wippersnapper_demo_offline_nonetiface.ino

@@ -1,5 +1,5 @@
-// Adafruit IO WipperSnapper - Offline Mode
-// USE ONLY WITH DEVICES WITH A NETWORK ADAPTER LIKE ESP32-x
+// Adafruit IO WipperSnapper - Offline Mode without Network Interface
+// USE ONLY WITH DEVICES WITHOUT A NETWORK ADAPTER LIKE RP2040 PICO
 //
 // Adafruit invests time and resources providing this open source code.
 // Please support Adafruit and open source hardware by purchasing

src/Wippersnapper_demo.ino

@@ -1,27 +1,21 @@
 // Adafruit IO WipperSnapper
+// USE ONLY WITH DEVICES WITHOUT A NETWORK ADAPTER LIKE RP2040 PICO
 //
 // Adafruit invests time and resources providing this open source code.
 // Please support Adafruit and open source hardware by purchasing
 // products from Adafruit!
 //
-// Brent Rubell for Adafruit Industries, 2020-2025
+// Brent Rubell for Adafruit Industries, 2025
 //
 // All text above must be included in any redistribution.
 
 #include "ws_adapters.h"
-#if defined(ARDUINO_RASPBERRY_PI_PICO_2) ||                                  \
-    defined(ARDUINO_RASPBERRY_PI_PICO) ||                                      \
-    defined(ARDUINO_ADAFRUIT_FEATHER_RP2040_ADALOGGER) ||                      \
-    defined(ARDUINO_ADAFRUIT_METRO_RP2350)
-ws_adapter_offline wipper;
-#else
 ws_adapter_wifi wipper;
-#endif
-
 #define WS_DEBUG // Enable debug output!
 
 void setup() {
   Serial.begin(115200);
+  while (!Serial) delay(10);
   wipper.provision();
   wipper.connect();
 }

src/Wippersnapper_demo.ino.cpp

@@ -72,11 +72,10 @@ bool GPSController::AddGPS(TwoWire *wire, uint32_t i2c_addr,
  * @param gps_config Pointer to the GPS configuration message.
  * @return True if the GPS was added successfully, false otherwise.
  */
-bool GPSController::AddGPS(HardwareSerial *serial,
-                           wippersnapper_gps_GPSConfig *gps_config) {
+bool GPSController::AddGPS(HardwareSerial *serial, uint32_t baudrate, wippersnapper_gps_GPSConfig *gps_config) {
   GPSHardware *gps_hw = new GPSHardware();
 
-  if (!gps_hw->SetInterface(serial)) {
+  if (!gps_hw->SetInterface(serial, baudrate)) {
     WS_DEBUG_PRINTLN("[gps] ERROR: Failed to set GPS UART interface!");
     delete gps_hw;
     return false;

src/components/gps/controller.cpp

@@ -31,7 +31,7 @@ class GPSController {
 public:
   GPSController();
   ~GPSController();
-  bool AddGPS(HardwareSerial *serial, wippersnapper_gps_GPSConfig *gps_config);
+  bool AddGPS(HardwareSerial *serial, uint32_t baudrate, wippersnapper_gps_GPSConfig *gps_config);
   bool AddGPS(TwoWire *wire, uint32_t i2c_addr,
               wippersnapper_gps_GPSConfig *gps_config);
   void update();

src/components/gps/controller.h

@@ -177,12 +177,13 @@ bool GPSHardware::Handle_GPSConfig(wippersnapper_gps_GPSConfig *gps_config) {
  *        Pointer to a HardwareSerial instance.
  * @returns True if the interface was set successfully, False otherwise.
  */
-bool GPSHardware::SetInterface(HardwareSerial *serial) {
+bool GPSHardware::SetInterface(HardwareSerial *serial, uint32_t baudrate) {
   if (serial == nullptr)
     return false;
   // Configure the hardware serial interface
   _hw_serial = serial;
   _iface_type = GPS_IFACE_UART_HW;
+  _baudrate = baudrate;
   return true;
 }
 
@@ -357,7 +358,7 @@ bool GPSHardware::DetectMtkUart() {
 
   // Attempt to use Adafruit_GPS
   _ada_gps = new Adafruit_GPS(_hw_serial);
-  if (!_ada_gps->begin(_hw_serial->baudRate())) {
+  if (!_ada_gps->begin(_baudrate)) {
     WS_DEBUG_PRINTLN("[gps] ERROR: Failed to initialize Mediatek!");
     return false;
   }

src/components/gps/hardware.cpp

@@ -68,7 +68,7 @@ class GPSHardware {
   GPSHardware();
   ~GPSHardware();
   bool begin();
-  bool SetInterface(HardwareSerial *serial);
+  bool SetInterface(HardwareSerial *serial, uint32_t baudrate);
   bool SetInterface(TwoWire *wire);
   void SetPollPeriod(ulong poll_period);
   void SetPollPeriodPrv(ulong poll_period_prv);
@@ -114,7 +114,6 @@ class GPSHardware {
   float GetSpeed();
   float GetAngle();
   float GetGeoidHeight();
-
 private:
   bool QueryModuleType();
   bool DetectMtkUart();
@@ -132,14 +131,15 @@ class GPSHardware {
       nullptr;                      ///< Optional Adafruit UBlox DDC instance
   Adafruit_UBX *_ubx_gps = nullptr; ///< Optional Adafruit UBX instance
   uint32_t _addr;                   ///< Optional i2c address
-  ulong _period;     ///< Polling period for GPS data (Specified by IO), in ms
-  ulong _period_prv; ///< Previous period for GPS data (Specified by IO), in ms
-  ulong _kat_prv;    ///< Last time the GPS hardware was polled, in ms
-  int _nmea_update_rate; ///< NMEA update rate for GPS data, in Hz
-  int _nmea_baud_rate;   ///< NMEA baud rate for GPS data, in bits per second
+  ulong _period;                    ///< Polling period for GPS data (Specified by IO), in ms
+  ulong _period_prv;                ///< Previous period for GPS data (Specified by IO), in ms
+  ulong _kat_prv;                   ///< Last time the GPS hardware was polled, in ms
+  uint32_t _baudrate;               ///< Baud rate of UART bus
+  int _nmea_update_rate;            ///< NMEA update rate for GPS data, in Hz
+  int _nmea_baud_rate;              ///< NMEA baud rate for GPS data, in bits per second
   int NmeaBufPush(
-      const char *new_sentence); ///< Push a sentence to the NMEA ring buffer
-  nmea_buffer_t _nmea_buff;      ///< NMEA ring buffer for storing sentences
+      const char *new_sentence);    ///< Push a sentence to the NMEA ring buffer
+  nmea_buffer_t _nmea_buff;         ///< NMEA ring buffer for storing sentences
 };
 extern Wippersnapper_V2 WsV2; ///< Wippersnapper V2 instance
 #endif                        // WS_GPS_HARDWARE_H

src/components/gps/hardware.h

@@ -344,6 +344,71 @@ static const std::map<std::string, FnCreateI2CSensorDriver> I2cFactorySensor = {
        return new drvVl6180x(i2c, addr, mux_channel, driver_name);
      }}}; ///< I2C driver factory
 
+static const std::unordered_map<uint16_t, std::vector<const char *>>
+    map_address_to_drivers = {
+        {0x0B, {"lc709203f"}},
+        {0x12, {"pmsa003i"}},
+        {0x13, {"vncl4020"}},
+        {0x18, {"ds2484", "mcp9808", "mprls"}},
+        {0x19, {"mcp9808"}},
+        {0x1A, {"mcp9808"}},
+        {0x1B, {"mcp9808"}},
+        {0x1C, {"mcp9808"}},
+        {0x1D, {"mcp9808"}},
+        {0x1E, {"mcp9808"}},
+        {0x1F, {"mcp9808"}},
+        {0x23, {"bh1750"}},
+        {0x28, {"pct2075"}},
+        {0x29,
+         {"ltr303", "pct2075", "tsl2591", "veml7700", "vl53l1x", "vl53l4cd",
+          "vl53l4cx", "vl6180x"}},
+        {0x2A, {"nau7802"}},
+        {0x38, {"aht20", "max17048"}},
+        {0x39, {"tsl2591"}},
+        {0x40,
+         {"htu21d", "htu31d", "ina219", "ina260", "ms8607", "si7021",
+          "stemma_soil"}},
+        {0x41, {"htu31d", "ina219", "ina260"}},
+        {0x44, {"hdc302x", "ina260", "sht3x", "sht4x"}},
+        {0x45, {"hdc302x", "ina260", "sht3x"}},
+        {0x46, {"hdc302x"}},
+        {0x47, {"hdc302x"}},
+        {0x48, {"adt7410", "pct2075", "tmp117"}},
+        {0x49, {"adt7410", "pct2075", "tmp117", "tsl2591"}},
+        {0x4A, {"adt7410", "pct2075", "tmp117"}},
+        {0x4B, {"adt7410", "pct2075", "tmp117"}},
+        {0x4C, {"pct2075"}},
+        {0x4D, {"pct2075"}},
+        {0x4E, {"pct2075"}},
+        {0x4F, {"pct2075"}},
+        {0x51, {"vcnl4200"}},
+        {0x52, {"ens160"}},
+        {0x53, {"ens160", "ltr390"}},
+        {0x58, {"sgp30"}},
+        {0x59, {"sgp40"}},
+        {0x5C,
+         {"bh1750", "lps22hb", "lps25hb", "lps28dfw", "lps33hw", "lps35hw"}},
+        {0x5D, {"lps22hb", "lps25hb", "lps28dfw", "lps33hw", "lps35hw"}},
+        {0x5F, {"hts2221"}},
+        {0x60, {"mpl115a2", "vncl4040"}},
+        {0x61, {"scd30"}},
+        {0x62, {"scd40"}},
+        {0x68, {"mcp3421"}},
+        {0x69, {"sen55"}},
+        {0x6B, {"sen66"}},
+        {0x70, {"pct2075", "shtc3"}},
+        {0x71, {"pct2075"}},
+        {0x72, {"pct2075"}},
+        {0x73, {"pct2075"}},
+        {0x74, {"pct2075"}},
+        {0x75, {"pct2075"}},
+        {0x76,
+         {"bme280", "bme680", "bmp280", "bmp388", "bmp390", "dps310", "ms8607",
+          "pct2075"}},
+        {0x77,
+         {"bme280", "bme680", "bmp280", "bmp388", "bmp390", "dps310",
+          "pct2075"}}}; ///< I2C address to driver map
+
 /*!
     @brief     Lambda function to create a drvOutputBase instance
       @param    i2c
@@ -438,6 +503,26 @@ drvOutputBase *CreateI2cOutputDrv(const char *driver_name, TwoWire *i2c,
   return it->second(i2c, addr, i2c_mux_channel, driver_name);
 }
 
+/***********************************************************************/
+/*!
+    @brief  Obtains possible candidate drivers for a given I2C address.
+    @param    addr
+                The desired I2C address.
+    @returns  A vector of pointers to candidate drivers.
+*/
+/***********************************************************************/
+std::vector<const char *> GetDriversForAddress(uint16_t addr) {
+  std::vector<const char *> candidates;
+  std::unordered_map<uint16_t, std::vector<const char *>>::const_iterator
+      candidate = map_address_to_drivers.find(addr);
+
+  if (candidate != map_address_to_drivers.end()) {
+    candidates = candidate->second;
+  }
+
+  return candidates;
+}
+
 /*!
     @brief  I2cController constructor
 */
@@ -882,6 +967,12 @@ bool I2cController::Handle_I2cDeviceAddOrReplace(pb_istream_t *stream) {
 
   // Is this a i2c GPS?
   bool is_gps = _i2c_model->GetI2cDeviceAddOrReplaceMsg()->is_gps;
+  WS_DEBUG_PRINT("[i2c] Device name: ");
+  WS_DEBUG_PRINTLN(device_name);
+  WS_DEBUG_PRINT("[i2c] Device address: 0x");
+  WS_DEBUG_PRINTLN(device_descriptor.i2c_device_address, HEX);
+  WS_DEBUG_PRINT("[i2c] Is GPS? ");
+  WS_DEBUG_PRINTLN(is_gps ? "Yes" : "No");
 
   // TODO [Online]: Handle Replace messages by implementing the Remove handler
   // first...then proceed to adding a new device
@@ -956,7 +1047,58 @@ bool I2cController::Handle_I2cDeviceAddOrReplace(pb_istream_t *stream) {
   drvOutputBase *drv_out = nullptr;
   GPSController *drv_uart_gps = nullptr;
 
-  if (is_output) {
+  if (strcmp(device_name, "UNKNOWN_SCAN") == 0) {
+    WS_DEBUG_PRINTLN("Attempting to autoconfig device found in scan...");
+    if (device_descriptor.i2c_device_address == 0x68 ||
+        device_descriptor.i2c_device_address == 0x70) {
+      WS_DEBUG_PRINTLN("[i2c] Device address is shared with RTC/MUX, can not "
+                       "auto-init, skipping!");
+      return true;
+    }
+    // Get all possible driver candidates for this address
+    WS_DEBUG_PRINT("[i2c] Obtaining driver candidates @ 0x");
+    WS_DEBUG_PRINTLN(device_descriptor.i2c_device_address, HEX);
+
+    // Probe each candidate to see if it communicates
+    bool did_find_driver = false;
+    for (const char *driverName :
+         GetDriversForAddress(device_descriptor.i2c_device_address)) {
+      WS_DEBUG_PRINT("[i2c] Attempting to initialize candidate: ");
+      WS_DEBUG_PRINTLN(driverName);
+      drv = CreateI2cSensorDrv(
+          driverName, bus, device_descriptor.i2c_device_address,
+          device_descriptor.i2c_mux_channel, device_status);
+      // Probe the driver to check if it communicates its init. sequence
+      if (!drv->begin()) {
+        WS_DEBUG_PRINTLN("[i2c] Failed to initialize candidate: ");
+        WS_DEBUG_PRINTLN(driverName);
+        delete drv;
+        drv = nullptr;
+      } else {
+        WS_DEBUG_PRINT("[i2c] Successfully initialized candidate: ");
+        WS_DEBUG_PRINTLN(driverName);
+        // set device_name to driverName
+        strcpy(device_name, driverName);
+        // Use the "default" types from the sensor driver
+        drv->EnableSensorReads(true);
+        drv->SetSensorPeriod(DEFAULT_SENSOR_PERIOD);
+#ifndef OFFLINE_MODE_WOKWI
+        WsV2._fileSystemV2->AddI2cDeviceToFileConfig(
+            device_descriptor.i2c_device_address, driverName,
+            drv->GetSensorTypeStrings(), drv->GetNumSensorTypes());
+#endif
+        did_find_driver = true;
+        _i2c_drivers.push_back(drv);
+        return true;
+      }
+    }
+    if (!did_find_driver) {
+      WS_DEBUG_PRINTLN("[i2c] ERROR - Candidates exhausted, driver not found!");
+      return true; // dont cause an error in the app
+    }
+  }
+
+  else if (is_output) {
     WS_DEBUG_PRINT("[i2c] Creating an I2C output driver...");
     drv_out = CreateI2cOutputDrv(
         device_name, bus, device_descriptor.i2c_device_address,
@@ -1023,11 +1165,12 @@ bool I2cController::Handle_I2cDeviceAddOrReplace(pb_istream_t *stream) {
     }
     WS_DEBUG_PRINTLN("[i2c] Set driver to use Alt I2C bus");
   }
-  // Configure the driver
 
+  // Configure the driver
   if (!is_output) {
     // Configure Input-driver settings
     drv->EnableSensorReads(
+        false,
         _i2c_model->GetI2cDeviceAddOrReplaceMsg()->i2c_device_sensor_types,
         _i2c_model->GetI2cDeviceAddOrReplaceMsg()
             ->i2c_device_sensor_types_count);

src/components/i2c/controller.cpp

@@ -142,10 +142,21 @@ class drvBase {
       @param    sensor_types_count
                 The number of active sensors to read from the device.
   */
-  void EnableSensorReads(bool use_default_types,
-                         wippersnapper_sensor_SensorType *sensor_types,
-                         size_t sensor_types_count) {
-    _sensors_count = sensor_types_count;
+  void
+  EnableSensorReads(bool use_default_types = false,
+                    wippersnapper_sensor_SensorType *sensor_types = nullptr,
+                    size_t sensor_types_count = 0) {
+    // Assign number of sensors
+    if (use_default_types) {
+      // Configure the driver with values from THE DRIVER
+      ConfigureDefaultSensorTypes();
+      _sensors_count = _default_sensor_types_count;
+    } else {
+      // Configure the driver with values from THE CONFIG FILE
+      _sensors_count = sensor_types_count;
+    }
+
+    // Fill sensor types with default values
     for (size_t i = 0; i < _sensors_count; i++) {
       if (use_default_types)
         _sensors[i] = _default_sensor_types[i];
@@ -219,21 +230,6 @@ class drvBase {
 
   size_t GetNumSensorTypes() { return _sensors_count; }
 
-  /*!
-    @brief    Configures an i2c device's sensors.
-    @param    sensor_types
-              Pointer to an array of SensorType objects.
-    @param    sensor_types_count
-              The number of active sensors to read from the device.
-*/
-  void EnableSensorReads(wippersnapper_sensor_SensorType *sensor_types,
-                         size_t sensor_types_count) {
-    _sensors_count = sensor_types_count;
-    for (size_t i = 0; i < _sensors_count; i++) {
-      _sensors[i] = sensor_types[i];
-    }
-  }
-
   /*******************************************************************************/
   /*!
       @brief    Gets the sensor's previous period.