Detect SSD1680 automatically

Author: brentru

src/Wippersnapper.cpp

@@ -1684,30 +1684,38 @@ bool cbDecodeDisplayMsg(pb_istream_t *stream, const pb_field_t *field,
     }
 
     // Attempt to add or replace a display component
-    bool did_add = WS._displayController->Handle_Display_AddOrReplace(&msgAddReq);
-    
+    bool did_add =
+        WS._displayController->Handle_Display_AddOrReplace(&msgAddReq);
+
     // Create a DisplayResponse message
-    wippersnapper_signal_v1_DisplayResponse msgResp =  wippersnapper_signal_v1_DisplayResponse_init_zero;
-    msgResp.which_payload =  wippersnapper_signal_v1_DisplayResponse_display_added_tag;
+    wippersnapper_signal_v1_DisplayResponse msgResp =
+        wippersnapper_signal_v1_DisplayResponse_init_zero;
+    msgResp.which_payload =
+        wippersnapper_signal_v1_DisplayResponse_display_added_tag;
     msgResp.payload.display_added.did_add = did_add;
-    strncpy(msgResp.payload.display_added.name, msgAddReq.name, sizeof(msgResp.payload.display_added.name));
+    strncpy(msgResp.payload.display_added.name, msgAddReq.name,
+            sizeof(msgResp.payload.display_added.name));
 
-  // Encode and publish response back to broker
-  memset(WS._buffer_outgoing, 0, sizeof(WS._buffer_outgoing));
-  pb_ostream_t ostream = pb_ostream_from_buffer(WS._buffer_outgoing, sizeof(WS._buffer_outgoing));
-  if (!ws_pb_encode(&ostream, wippersnapper_signal_v1_DisplayResponse_fields, &msgResp)) {
-    WS_DEBUG_PRINTLN("ERROR: Unable to encode display response message!");
-    return false;
-  }
+    // Encode and publish response back to broker
+    memset(WS._buffer_outgoing, 0, sizeof(WS._buffer_outgoing));
+    pb_ostream_t ostream = pb_ostream_from_buffer(WS._buffer_outgoing,
+                                                  sizeof(WS._buffer_outgoing));
+    if (!ws_pb_encode(&ostream, wippersnapper_signal_v1_DisplayResponse_fields,
+                      &msgResp)) {
+      WS_DEBUG_PRINTLN("ERROR: Unable to encode display response message!");
+      return false;
+    }
 
-  size_t msgSz;
-  pb_get_encoded_size(&msgSz, wippersnapper_signal_v1_DisplayResponse_fields, &msgResp);
-  WS_DEBUG_PRINT("Publishing DisplayResponse Message...");
-  if (!WS._mqtt->publish(WS._topic_signal_display_device, WS._buffer_outgoing, msgSz, 1)) {
-    WS_DEBUG_PRINTLN("ERROR: Failed to DisplayResponse Response!");
-  } else {
-    WS_DEBUG_PRINTLN("Published!");
-  }
+    size_t msgSz;
+    pb_get_encoded_size(&msgSz, wippersnapper_signal_v1_DisplayResponse_fields,
+                        &msgResp);
+    WS_DEBUG_PRINT("Publishing DisplayResponse Message...");
+    if (!WS._mqtt->publish(WS._topic_signal_display_device, WS._buffer_outgoing,
+                           msgSz, 1)) {
+      WS_DEBUG_PRINTLN("ERROR: Failed to DisplayResponse Response!");
+    } else {
+      WS_DEBUG_PRINTLN("Published!");
+    }
   } else if (field->tag ==
              wippersnapper_signal_v1_DisplayRequest_display_write_tag) {
     // Decode message into a DisplayAddRequest
@@ -1720,12 +1728,12 @@ bool cbDecodeDisplayMsg(pb_istream_t *stream, const pb_field_t *field,
     }
     // Attempt to write to a display
     WS._displayController->Handle_Display_Write(&msgWrite);
-  } else if (field->tag == wippersnapper_signal_v1_DisplayRequest_display_remove_tag) {
+  } else if (field->tag ==
+             wippersnapper_signal_v1_DisplayRequest_display_remove_tag) {
     // Decode message into a DisplayRemoveRequest
     wippersnapper_display_v1_DisplayRemove msgRemove =
         wippersnapper_display_v1_DisplayRemove_init_zero;
-    if (!ws_pb_decode(stream,
-                      wippersnapper_display_v1_DisplayRemove_fields,
+    if (!ws_pb_decode(stream, wippersnapper_display_v1_DisplayRemove_fields,
                       &msgRemove)) {
       WS_DEBUG_PRINTLN("ERROR: Failure decoding DisplayRemove message!");
       return false;

src/components/display/drivers/dispDrvBase.h

@@ -15,8 +15,8 @@
 #ifndef WS_DISP_DRV_BASE_H
 #define WS_DISP_DRV_BASE_H
 
-#include "Wippersnapper.h"
 #include "Adafruit_ThinkInk.h"
+#include "Wippersnapper.h"
 
 /*!
     @brief  Abstract base class for display drivers.

src/components/display/hardware.cpp

@@ -28,25 +28,12 @@ static const std::map<std::string, FnCreateDispDrv> FactoryDrvDisp = {
         int16_t busy) -> dispDrvBase * {
        return new drvDispThinkInkGrayscale4Eaamfgn(dc, rst, cs, sram_cs, busy);
      }},
-    {"thinkink-magtag-2025",
-     [](int16_t dc, int16_t rst, int16_t cs, int16_t sram_cs,
-        int16_t busy) -> dispDrvBase * {
-       return new drvDispThinkInkGrayscale4Eaamfgn(dc, rst, cs, sram_cs, busy);
-     }},
     {"thinkink-gs4-t5",
      [](int16_t dc, int16_t rst, int16_t cs, int16_t sram_cs,
         int16_t busy) -> dispDrvBase * {
        return new dispDrvThinkInkGrayscale4T5(dc, rst, cs, sram_cs, busy);
-     }},
-    {"thinkink-magtag-pre-2025",
-     [](int16_t dc, int16_t rst, int16_t cs, int16_t sram_cs,
-        int16_t busy) -> dispDrvBase * {
-       return new dispDrvThinkInkGrayscale4T5(dc, rst, cs, sram_cs, busy);
-     }}
-    };
+     }}};
 
-
-     
 /*!
     @brief  Creates a new display driver instance based on the driver name.
     @param  driver_name
@@ -169,6 +156,19 @@ bool DisplayHardware::beginEPD(
 
   // TODO: Configure SPI bus selection (UNUSED AS OF RIGHT NOW)
 
+  // For "magtag" component name, attempt to autodetect the driver
+  if (strncmp(_name, "magtag", 6) == 0) {
+    if (detect_ssd1680(cs, dc, rst)) {
+      // Detected SSD1680, use EAAMFGN driver
+      strncpy(_name, "thinkink-gs4-eaamfgn", sizeof(_name) - 1);
+      _name[sizeof(_name) - 1] = '\0';
+    } else {
+      // Did not detect SSD1680, use T5 driver
+      strncpy(_name, "thinkink-gs4-t5", sizeof(_name) - 1);
+      _name[sizeof(_name) - 1] = '\0';
+    }
+  }
+
   // Create display driver object using the factory function
   _drvDisp = CreateDrvDisp(_name, dc, rst, cs, srcs, busy);
   if (!_drvDisp) {
@@ -210,4 +210,71 @@ void DisplayHardware::writeMessage(const char *message) {
   } else {
     WS_DEBUG_PRINTLN("[display] No display driver initialized!");
   }
+}
+
+/*!
+    @brief  Detects if an SSD1680 EPD is connected using bit-banged SPI.
+    @param  cs
+            Chip Select pin number.
+    @param  dc
+            Data/Command pin number.
+    @param  rst
+            Reset pin number.
+    @return True if an SSD1680 is detected, False otherwise (IL0373 or different
+   EPD).
+*/
+bool DisplayHardware::detect_ssd1680(uint8_t cs, uint8_t dc, uint8_t rst) {
+  // note: for a complete implementation reference, see
+  // https://github.com/adafruit/circuitpython/commit/f4316cb2491c815b128acca47f1bb75519fe306e
+  // Configure SPI pins to bit-bang
+  pinMode(MOSI, OUTPUT);
+  pinMode(SCK, OUTPUT);
+  pinMode(cs, OUTPUT);
+  pinMode(dc, OUTPUT);
+  pinMode(rst, OUTPUT);
+
+  // Begin transaction by pulling cs and dc LOW
+  digitalWrite(cs, LOW);
+  digitalWrite(dc, LOW);
+  digitalWrite(SCK, LOW);
+  digitalWrite(rst, HIGH);
+
+  // Write to read register 0x71
+  uint8_t cmd = 0x71;
+  for (int i = 0; i < 8; i++) {
+    digitalWrite(MOSI, (cmd & (1 << (7 - i))) != 0);
+    digitalWrite(SCK, HIGH);
+    digitalWrite(SCK, LOW);
+  }
+
+  // Set DC high to indicate data and switch MOSI to input with PUR in case
+  // SSD1680 does not send data back
+  digitalWrite(dc, HIGH);
+  delayMicroseconds(1);
+  pinMode(MOSI, INPUT_PULLUP);
+  delayMicroseconds(1);
+
+  // Read response from register
+  uint8_t status = 0;
+  for (int i = 0; i < 8; i++) {
+    status <<= 1;
+    if (digitalRead(MOSI)) {
+      status |= 1;
+    }
+    digitalWrite(SCK, HIGH);
+    delayMicroseconds(1);
+    digitalWrite(SCK, LOW);
+    delayMicroseconds(1);
+  }
+
+  // End transaction by pulling CS high
+  digitalWrite(cs, HIGH);
+
+  // Put back MOSI pin as an output
+  pinMode(MOSI, OUTPUT);
+
+  WS_DEBUG_PRINT("[display] Bitbang read 0x71: 0x");
+  WS_DEBUG_PRINTLN(status, HEX);
+
+  return status == 0xFF;
 }

src/components/display/hardware.h

@@ -15,11 +15,11 @@
 #ifndef WS_DISPLAY_HARDWARE_H
 #define WS_DISPLAY_HARDWARE_H
 #include "Wippersnapper.h"
-#include <functional>
-#include <map>
 #include "drivers/dispDrvBase.h"
 #include "drivers/dispDrvThinkInkGrayscale4Eaamfgn.h"
 #include "drivers/dispDrvThinkInkGrayscale4T5.h"
+#include <functional>
+#include <map>
 
 /*!
     @brief  Interface for interacting with display hardware (TFT, eInk,
@@ -49,6 +49,7 @@ class DisplayHardware {
   void writeMessage(const char *message);
 
 private:
+  bool detect_ssd1680(uint8_t cs, uint8_t dc, uint8_t rst);
   char _name[64]; ///< Identifies the hardware instance
   wippersnapper_display_v1_DisplayType _type; ///< Display type
   dispDrvBase *_drvDisp = nullptr;            ///< Base display driver