Add write commands for quadalphanum

Author: brentru

src/Wippersnapper.cpp

@@ -871,6 +871,21 @@ bool cbDecodeSignalRequestI2C(pb_istream_t *stream, const pb_field_t *field,
     if (!encodeI2CResponse(&msgi2cResponse)) {
       return false;
     }
+  } else if (field->tag ==
+             wippersnapper_signal_v1_I2CRequest_req_i2c_device_out_write_tag) {
+    WS_DEBUG_PRINTLN("[app] I2C Device Output Write");
+    // Decode stream into an I2CDeviceDeinitRequest
+    wippersnapper_i2c_v1_I2CDeviceOutputWrite msgDeviceWrite =
+        wippersnapper_i2c_v1_I2CDeviceOutputWrite_init_zero;
+    // Decode stream into struct, msgI2CDeviceDeinitRequest
+    if (!ws_pb_decode(stream, wippersnapper_i2c_v1_I2CDeviceOutputWrite_fields,
+                      &msgDeviceWrite)) {
+      WS_DEBUG_PRINTLN(
+          "[app] ERROR: Failed decoding I2CDeviceOutputWrite message.");
+      return false;
+    }
+    WS._i2cPort0->Handle_I2cDeviceOutputWrite(&msgDeviceWrite);
+    WS_DEBUG_PRINTLN("[app] I2C Device Output Write Done");
   } else {
     WS_DEBUG_PRINTLN("ERROR: Undefined I2C message tag");
     return false; // fail out, we didn't encode anything to publish

src/components/i2c/WipperSnapper_I2C.cpp

@@ -839,8 +839,11 @@ bool WipperSnapper_Component_I2C::initI2CDevice(
     drivers.push_back(_adt7410);
     WS_DEBUG_PRINTLN("ADT7410 Initialized Successfully!");
   } else if (strcmp("quadalphanum", msgDeviceInitReq->i2c_device_name) == 0) {
-    _quadAlphaNum = new WipperSnapper_I2C_Driver_Out_QuadAlphaNum(this->_i2c, i2cAddress);
-    // _quadAlphaNum->ConfigureI2CBackpack(msgDeviceInitReq->i2c_output_add.config.led_backpack_config);
+    _quadAlphaNum =
+        new WipperSnapper_I2C_Driver_Out_QuadAlphaNum(this->_i2c, i2cAddress);
+    _quadAlphaNum->ConfigureI2CBackpack(
+        msgDeviceInitReq->i2c_output_add.config.led_backpack_config.brightness,
+        msgDeviceInitReq->i2c_output_add.config.led_backpack_config.alignment);
     if (!_quadAlphaNum->begin()) {
       WS_DEBUG_PRINTLN("ERROR: Failed to initialize Quad Alphanum. Display!");
       _busStatusResponse =
@@ -1087,6 +1090,48 @@ void WipperSnapper_Component_I2C::displayDeviceEventMessage(
   }
 }
 
+/*******************************************************************************/
+/*!
+    @brief    Handles an I2CDeviceOutputWrite message.
+    @param    msgDeviceWrite
+              A decoded I2CDeviceOutputWrite message.
+    @returns  True if the message was handled successfully, false otherwise.
+*/
+/*******************************************************************************/
+bool WipperSnapper_Component_I2C::Handle_I2cDeviceOutputWrite(
+    wippersnapper_i2c_v1_I2CDeviceOutputWrite *msgDeviceWrite) {
+
+  // Create a ptr to the base driver out
+  WipperSnapper_I2C_Driver_Out *driver_out = nullptr;
+  // Find the matching driver by address in the _drivers_out vector
+  WS_DEBUG_PRINT("Searching for i2c output driver with address: ");
+  WS_DEBUG_PRINT(msgDeviceWrite->i2c_device_address);
+  for (size_t i = 0; i < _drivers_out.size(); i++) {
+    if (_drivers_out[i]->getI2CAddress() ==
+        msgDeviceWrite->i2c_device_address) {
+      driver_out = _drivers_out[i];
+      break;
+    }
+  }
+  if (driver_out == nullptr) {
+    WS_DEBUG_PRINTLN("ERROR: Driver not found within drivers_out!");
+    return false;
+  }
+
+  // Call the output_msg
+  if (msgDeviceWrite->which_output_msg ==
+      wippersnapper_i2c_v1_I2CDeviceOutputWrite_write_led_backpack_tag) {
+    driver_out->WriteLedBackpack(&msgDeviceWrite->output_msg.write_led_backpack);
+  } else if (msgDeviceWrite->which_output_msg ==
+             wippersnapper_i2c_v1_I2CDeviceOutputWrite_write_char_lcd_tag) {
+    // TODO: Write to the char LCD
+  } else {
+    WS_DEBUG_PRINTLN("ERROR: Unknown output message type!");
+    return false;
+  }
+  return true;
+}
+
 /*******************************************************************************/
 /*!
     @brief    Queries all I2C device drivers for new values. Fills and sends an

src/components/i2c/WipperSnapper_I2C.h

@@ -20,8 +20,6 @@
 #include <Wire.h>
 
 #include "drivers/WipperSnapper_I2C_Driver.h"
-#include "drivers/WipperSnapper_I2C_Driver_Out.h"
-#include "drivers/WipperSnapper_I2C_Driver_Out_QuadAlphaNum.h"
 #include "drivers/WipperSnapper_I2C_Driver_ADT7410.h"
 #include "drivers/WipperSnapper_I2C_Driver_AHTX0.h"
 #include "drivers/WipperSnapper_I2C_Driver_BH1750.h"
@@ -52,6 +50,8 @@
 #include "drivers/WipperSnapper_I2C_Driver_MPRLS.h"
 #include "drivers/WipperSnapper_I2C_Driver_MS8607.h"
 #include "drivers/WipperSnapper_I2C_Driver_NAU7802.h"
+#include "drivers/WipperSnapper_I2C_Driver_Out.h"
+#include "drivers/WipperSnapper_I2C_Driver_Out_QuadAlphaNum.h"
 #include "drivers/WipperSnapper_I2C_Driver_PCT2075.h"
 #include "drivers/WipperSnapper_I2C_Driver_PM25.h"
 #include "drivers/WipperSnapper_I2C_Driver_SCD30.h"
@@ -106,6 +106,9 @@ class WipperSnapper_Component_I2C {
 
   void update();
 
+  bool Handle_I2cDeviceOutputWrite(
+      wippersnapper_i2c_v1_I2CDeviceOutputWrite *msgDeviceWrite);
+
   void sensorEventRead(
       std::vector<WipperSnapper_I2C_Driver *>::iterator &iter,
       unsigned long curTime,
@@ -136,8 +139,10 @@ class WipperSnapper_Component_I2C {
   int32_t _portNum;
   TwoWire *_i2c = nullptr;
   wippersnapper_i2c_v1_BusResponse _busStatusResponse;
-  std::vector<WipperSnapper_I2C_Driver *> drivers; ///< List of i2c sensor drivers
-  std::vector<WipperSnapper_I2C_Driver_Out *> _drivers_out; ///< List of i2c output drivers
+  std::vector<WipperSnapper_I2C_Driver *>
+      drivers; ///< List of i2c sensor drivers
+  std::vector<WipperSnapper_I2C_Driver_Out *>
+      _drivers_out; ///< List of i2c output drivers
   // Sensor driver objects
   WipperSnapper_I2C_Driver_AHTX0 *_ahtx0 = nullptr;
   WipperSnapper_I2C_Driver_DPS310 *_dps310 = nullptr;

src/components/i2c/drivers/WipperSnapper_I2C_Driver_Out.h

@@ -32,7 +32,8 @@ class WipperSnapper_I2C_Driver_Out : public WipperSnapper_I2C_Driver {
       @param    sensorAddress
                 The I2C sensor's unique address.
   */
-  WipperSnapper_I2C_Driver_Out(TwoWire *i2c, uint16_t sensorAddress):WipperSnapper_I2C_Driver(i2c, sensorAddress) {
+  WipperSnapper_I2C_Driver_Out(TwoWire *i2c, uint16_t sensorAddress)
+      : WipperSnapper_I2C_Driver(i2c, sensorAddress) {
     // No-op constructor
   }
 
@@ -43,11 +44,11 @@ class WipperSnapper_I2C_Driver_Out : public WipperSnapper_I2C_Driver {
     // No-op destructor
   }
 
-    /*!
-      @brief    Writes a message to an i2c output device.
-      @param    message
-                The message to be displayed.
-  */
+  /*!
+    @brief    Writes a message to an i2c output device.
+    @param    message
+              The message to be displayed.
+*/
   virtual void WriteMessage(const char *message) {
     // noop
   }
@@ -92,6 +93,32 @@ class WipperSnapper_I2C_Driver_Out : public WipperSnapper_I2C_Driver {
     // noop
   }
 
+  bool WriteLedBackpack(wippersnapper_i2c_v1_LedBackpackWrite *msg_write) {
+    // Check if we should adjust brightness
+    if (msg_write->adjust_brightness)
+      SetLedBackpackBrightness((uint8_t)msg_write->brightness);
+
+    // Write the message to a LED backpack
+    switch (msg_write->which_message) {
+    case wippersnapper_i2c_v1_LedBackpackWrite_text_tag:
+      WS_DEBUG_PRINTLN("[i2c] Writing text to LED backpack...");
+      WriteMessage(msg_write->message.text);
+      break;
+    case wippersnapper_i2c_v1_LedBackpackWrite_number_int_tag:
+      WS_DEBUG_PRINTLN("[i2c] Writing int to LED backpack...");
+      WriteValue(msg_write->message.number_int);
+      break;
+    case wippersnapper_i2c_v1_LedBackpackWrite_number_float_tag:
+      WS_DEBUG_PRINTLN("[i2c] Writing float to LED backpack...");
+      WriteValue(msg_write->message.number_float);
+      break;
+    default:
+      WS_DEBUG_PRINTLN("[i2c] ERROR: Unable to determine message type!");
+      return false;
+      break;
+    }
+    return true;
+  }
 };
 
 #endif // WIPPERSNAPPER_I2C_DRIVER_OUT_H

src/components/i2c/drivers/WipperSnapper_I2C_Driver_Out_QuadAlphaNum.h

@@ -87,7 +87,97 @@ class WipperSnapper_I2C_Driver_Out_QuadAlphaNum : public WipperSnapper_I2C_Drive
     _brightness = brightness;
   }
 
+  /*!
+      @brief    Sets the brightness of the LED backpack.
+      @param    b
+                  The brightness value, from 0 (off) to 15 (full brightness).
+  */
+  void SetLedBackpackBrightness(uint8_t b) {
+    if (_alpha4 == nullptr) {
+      return;
+    }
+    _alpha4->setBrightness(b);
+  }
+
+  /*!
+      @brief    Writes the first four characters of a message to the quad
+     alphanumeric display.
+      @param    message
+                  The message to be displayed.
+  */
+  void WriteMessage(const char *message) {
+    if (_alpha4 == nullptr || message == nullptr) {
+      return;
+    }
+    // Clear before writing
+    _alpha4->clear();
+
+    // Calculate the number of characters to display
+    size_t len_display = min(strlen(message), (size_t)LED_MAX_CHARS);
+
+    // Set the starting position based on alignment
+    int pos_start;
+    if (_alignment == LED_BACKPACK_ALIGNMENT_LEFT) {
+      pos_start = 0; // start at the leftmost position of the display
+    } else {
+      // Exclude decimal points from the character count because those get
+      // displayed on a "special" segment of the LED display
+      int seg_chars = 0;
+      for (size_t i = 0; i < len_display; i++) {
+        if (message[i] != '.') {
+          seg_chars++;
+        }
+      }
+      // start at the rightmost position of the display
+      pos_start = LED_MAX_CHARS - seg_chars;
+    }
 
+    // Write to the display's buffer
+    int cur_idx = pos_start;
+    for (size_t i = 0; i < len_display; i++) {
+      // Save the character because if there's a decimal, we need to skip it in
+      // the buffer
+      char ch = message[i];
+
+      // Look-ahead for a decimal point to attach to the current character
+      bool display_dot = false;
+      if (i + 1 < len_display && message[i + 1] == '.') {
+        display_dot = true;
+        i++;
+        len_display++;
+      }
+
+      // Write the character to the display buffer
+      _alpha4->writeDigitAscii(cur_idx, ch, display_dot);
+      cur_idx++;
+    }
+    // Issue the buffered data in RAM to the display
+    _alpha4->writeDisplay();
+  }
+
+  /*!
+      @brief    Writes a floating point value to the quad alphanumeric display.
+      @param    value
+                  The value to be displayed. Only the first four digits are
+      displayed.
+  */
+  void WriteValue(float value) {
+    char message[8 + 1];
+    snprintf(message, sizeof(message), "%.5f", value);
+    WriteMessage(message);
+  }
+
+  /*!
+      @brief    Writes an integer value to the quad alphanumeric display.
+      @param    value
+                  The value to be displayed. Only the first four digits are
+      displayed.
+  */
+  void WriteValue(int32_t value) {
+    char message[LED_MAX_CHARS + 1];
+    snprintf(message, sizeof(message), "%ld", value);
+    WriteMessage(message);
+  }
 
 protected:
   Adafruit_AlphaNum4 *_alpha4 = nullptr;         ///< ptr to a 4-digit alphanumeric display object