denko 0.13.6 → 0.15.0

data/src/lib/Denko.h

@@ -13,14 +13,6 @@ class Denko {
     // Store it and call ->print, ->write, ->available, ->read etc. on it.
     Stream* stream;
 
-    // Callback hooks for local logic (defined in main sketch) based on listeners.
-    // These should be used if:
-    //   1) a round-trip to the remote client is too slow, or
-    //   2) something needs to happen regardless of remote client connection.
-    // Eg. Instant feedback from a smart light switch.
-    void (*digitalListenCallback)(byte p, byte v);
-    void (*analogListenCallback)(byte p, int v);
-
     // Core IO API Functions
     // Functions with a cmd value can be called through the remote API.
     //
@@ -35,10 +27,10 @@ class Denko {
     void dacWrite    (byte p, int v,  boolean echo=true);  //cmd = 4
     int  aRead       (byte p);                             //cmd = 5
     void setListener (byte p, boolean enabled, byte analog, byte exponent, boolean local=true); //cmd = 6
-    
+
     // Read value of micros() every loop.
     unsigned long currentTime;
-    
+
     // Counts 1ms ticks based on currentTime. Rolls over every 256ms.
     byte tickCount;
 
@@ -53,19 +45,10 @@ class Denko {
     void clearCoreListeners    ();
     void findLastActiveListener();
 
-    //
-    // Tanslating aWrite to ledcWrite for PWM out on the ESP32.
-    //
-    // Track which pin is assigned to each LEDC channel.
-    // Byte 0 = enabled or disabled
-    // Byte 1 = pin number attached to that channel
-    //
     #ifdef ESP32
-    byte ledcPins[LEDC_CHANNEL_COUNT][2];
-    byte ledcChannel(byte p);
-    byte assignLEDC(byte channel, byte pin);
-    void releaseLEDC(byte p);
-    void clearLedcChannels();
+      // 8-bit global PWM resolution by default, to match other boards. Reconfigurable.
+      uint8_t esp32AnalogWRes = 8;
+      void ledcDetachAll();
     #endif
 
     //
@@ -136,8 +119,8 @@ class Denko {
     void showLEDArray       (); //cmd = 19
 
     // Bit Bang SPI
-    void spiBBtransfer         (uint8_t clock, uint8_t input, uint8_t output, uint8_t select, uint8_t settings, 
-                                uint8_t rLength, uint8_t wLength, byte *data);                                                          //cmd = 21
+    void spiBBtransfer         (uint8_t clock, uint8_t input, uint8_t output, uint8_t select, uint8_t settings,
+                                uint16_t rLength, uint16_t wLength, byte *data);                                                        //cmd = 21
     byte spiBBtransferByte     (uint8_t clock, uint8_t input, uint8_t output, uint8_t select,
                                 uint8_t mode, uint8_t bitOrder, byte data);
     void spiBBaddListener      ();                                                                                                      //cmd = 22
@@ -146,10 +129,10 @@ class Denko {
     // Hardware SPI
     void spiBegin              (byte settings, uint32_t clockRate);
     void spiEnd                ();
-    void spiTransfer           (uint32_t clockRate, uint8_t select, uint8_t settings, uint8_t rLength, uint8_t wLength, byte *data);    //cmd = 26
+    void spiTransfer           (uint32_t clockRate, uint8_t select, uint8_t settings, uint16_t rLength, uint16_t wLength, byte *data);  //cmd = 26
     void spiAddListener        ();                                                                                                      //cmd = 27
     void spiReadListener       (uint8_t i);
- 
+
     // SPI Listeners (both hardware and bit bang)
     void spiRemoveListener     ();                                                                                                      //cmd = 28
     void spiUpdateListeners    ();
@@ -182,6 +165,7 @@ class Denko {
     void setRegisterDivider             ();  //cmd = 97
     void setAnalogWriteResolution       ();  //cmd = 96
     void setAnalogReadResolution        ();  //cmd = 97
+    void binaryEcho                     ();  //cmd = 98
     void microDelay(uint32_t microseconds);  //cmd = 99, Platform specific microsecond delay
     unsigned long lastTime;
     unsigned long timeDiff;
@@ -211,7 +195,12 @@ class Denko {
     //
     // Notify computer that board has received bytes.
     void rxNotify();
-    uint8_t rxBytes  = 0;
+    // 8-bit counter on AVR for efficiency, 32-bit otherwise.
+    #ifdef __AVR__
+      uint8_t  rxBytes = 0;
+    #else
+      uint32_t rxBytes = 0;
+    #endif
     //
     // Tell the computer to halt or resume sending data to the board.
     //
@@ -232,19 +221,46 @@ class Denko {
 
     //
     // Shared SPI listeners that can be used by either hardware or bit bang SPI.
-    // 
+    //
     #if defined(DENKO_SPI) || defined(DENKO_SPI_BB)
       // How many SPI lsiteners.
       #define SPI_LISTENER_COUNT 4
 
       // How to store a SPI listener.
       struct SpiListener{
-        uint32_t clock;     // Clock rate if hardware SPI. If bit bang: bits[0..7] = clock pin, bits [8..15] = input pin.
+        uint32_t freq;      // Frequency if hardware SPI. If bit bang: bits[0..7] = SCK pin, bits [8..15] = MOSI pin.
         uint8_t  select;    // Select pin.
         uint8_t  settings;  // Settings mask as given in request.
-        uint8_t  length;    // Read length as given in request.
+        uint16_t length;    // Read length as given in request.
         uint8_t  enabled;   // 0 = disabled, 1 = hardware, 2 = bit bang.
       };
       SpiListener spiListeners[SPI_LISTENER_COUNT];
     #endif
+
+    // I2C Bit Bang Interface
+    #if defined(DENKO_I2C_BB)
+      uint8_t i2c_bb_scl_pin;
+      uint8_t i2c_bb_sda_pin;
+      uint8_t i2c_bb_quarter_period = 1;
+
+      // Internal stuff
+      void    i2c_bb_delay_quarter_period();
+      void    i2c_bb_delay_half_period();
+      void    i2c_bb_sda_high   ();
+      void    i2c_bb_sda_low    ();
+      void    i2c_bb_scl_high   ();
+      void    i2c_bb_scl_low    ();
+      void    i2c_bb_start      ();
+      void    i2c_bb_stop       ();
+      uint8_t i2c_bb_read_bit   ();
+      void    i2c_bb_write_bit  (uint8_t  bit );
+      uint8_t i2c_bb_read_byte  (bool     back);
+      int     i2c_bb_write_byte (uint8_t  data);
+      void    i2c_bb_init       (uint8_t scl, uint8_t sda);
+
+      // Remote exposed interface
+      void i2c_bb_search ();
+      void i2c_bb_write  ();
+      void i2c_bb_read   ();
+    #endif
 };

data/src/lib/DenkoCoreIO.cpp

@@ -4,62 +4,82 @@
 // Set up a single pin for the desired type of input or output.
 void Denko::setMode(byte p, byte m) {
   //
-  // Use the lowest 3 bits of m to set different input/output modes, and enable 
-  // or disable needed peripherals on different platforms.
+  // Use the lowest 4 bits of m to set different input/output modes.
+  // Also enables/disables peripherals for certain targets.
   //
-  // OUTPUT MODES:  
-  // 000 = Digital Output
-  // 010 = PWM Ouptut
-  // 100 = DAC Output
+  // OUTPUT MODES:
+  // 0000 = Digital Output
+  // 0010 = PWM Ouptut
+  // 0100 = DAC Output
+  // 0110 = Open Drain Output  (Only ESP32 implements this, and we don't really use it)
+  // 1000 = Open Source Output (Nothing implements this yet)
   //
   // INPUT MODES
-  // 001 = Digital Input
-  // 011 = Digital Input with internal pulldown if available.
-  // 101 = Digital Input with internal pullup if available.
-  // 111 = Digital Input/Output (ESP32 Only?)
-  m = m & 0b00000111;
+  // 0001 = Input with no pull bias
+  // 0011 = Input with internal pulldown, if available.
+  // 0101 = Input with internal pullup, if available.
+  m = m & 0b00001111;
 
   #if defined(ESP32)
-    // Free the LEDC channel if leaving PWM mode.
-    if (m != 0b010) releaseLEDC(p);
-    
     // Disable attached DAC if leaving DAC mode.
     #if defined(SOC_DAC_SUPPORTED)
-      if (m != 0b100) dacDisable(p);
+        if (m != 0b0100) dacDisable(p);
     #endif
+
+    // Attach or detach LEDC channel whether entering or leaving PWM mode.
+    if (m == 0b0010) {
+      // auxMsg[0..3] is frequency, [4..7] is resolution.
+      uint32_t freq = *reinterpret_cast<uint32_t *>(auxMsg);
+      uint8_t  res  = *reinterpret_cast<uint8_t *>(auxMsg + 4);
+      // Fallback to defaults.
+      if (freq == 0) freq = 1000;
+      if (res  == 0) res  = esp32AnalogWRes;
+      ledcAttach(p, freq, res);
+      return;
+    } else {
+      ledcDetach(p);
+    }
   #endif
-      
+
   // On the SAMD21 and RA4M1, mode needs to be INPUT when using the DAC.
   #if defined(__SAMD21G18A__) || defined(_RENESAS_RA_)
-    if (m == 0b100){
+    if (m == 0b0100){
       pinMode(p, INPUT);
       return;
     }
   #endif
-  
-  // Handle the named INPUT_* states on boards implementing them.
+
+  // Handle INPUT_* states on boards implementing them.
   #ifdef INPUT_PULLDOWN
-  if (m == 0b011) {
+  if (m == 0b0011) {
     pinMode(p, INPUT_PULLDOWN);
     return;
   }
   #endif
-  
-  #ifdef INPUT_OUTPUT
-  if (m == 0b111) {
-    pinMode(p, INPUT_OUTPUT);
+
+  #ifdef INPUT_PULLUP
+  if (m == 0b0101) {
+    pinMode(p, INPUT_PULLUP);
     return;
   }
   #endif
-  
-  #ifdef INPUT_PULLUP
-  if (m == 0b101) {
-    pinMode(p, INPUT_PULLUP);
+
+  // Handle OUTPUT_* states on boards implementing them.
+  #ifdef OUTPUT_OPEN_DRAIN
+  if (m == 0b0110) {
+    pinMode(p, OUTPUT_OPEN_DRAIN);
+    return;
+  }
+  #endif
+
+  #ifdef OUTPUT_OPEN_SOURCE
+  if (m == 0b1000) {
+    pinMode(p, OUTPUT_OPEN_SOURCE);
     return;
   }
   #endif
-  
-  // Handle the standard INPUT and OUTPUT states.
+
+  // Handle standard INPUT and OUTPUT states.
   // Allows INPUT_* to fallback to INPUT when not implemented.
   if (bitRead(m, 0) == 0) {
     pinMode(p, OUTPUT);
@@ -69,7 +89,7 @@ void Denko::setMode(byte p, byte m) {
 
   // Write high to set pullup for AVRs that use this method.
   #ifdef __AVR__
-    if (m == 0b101) digitalWrite(p, HIGH);
+    if (m == 0b0101) digitalWrite(p, HIGH);
   #endif
 }
 
@@ -89,9 +109,9 @@ void Denko::dWrite(byte p, byte v, boolean echo) {
     #if defined(SOC_DAC_SUPPORTED)
       dacDisable(p);
     #endif
-    ledcDetachPin(p);
+    ledcDetach(p);
   #endif
-    
+
   if (v == 0) {
     digitalWrite(p, LOW);
   }
@@ -113,13 +133,7 @@ byte Denko::dRead(byte p) {
 // Write an analog output pin. 0 for LOW, up to 255 for HIGH @ 8-bit resolution.
 void Denko::pwmWrite(byte p, int v, boolean echo) {
   #ifdef ESP32
-    // Assign new or find existing LEDC channel for this pin.
-    byte channel = ledcChannel(p);
-    
-    // Reattach the pin in case dWrite detached it.
-    ledcAttachPin(p, channel);
-    
-    ledcWrite(channel, v);
+    ledcWrite(p, v);
   #else
     analogWrite(p,v);
   #endif
@@ -127,66 +141,9 @@ void Denko::pwmWrite(byte p, int v, boolean echo) {
   if (echo) coreResponse(p, v);
 }
 
-//
-// Manage ESP32 LEDC channels so we can do PWM write.
-//
 #ifdef ESP32
-byte Denko::ledcChannel(byte p) {
-  // Search for enabled LEDC channel with given pin and use that if found.
-  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
-    if ((ledcPins[i][0] == 1) && (ledcPins[i][1] == p)){
-      return i;
-    }
-  }
-
-  // We didn't find a channel to reuse.
-  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
-    // If the channel isn't initialized and it isn't marked as used, use it.
-    // should find some way to check if the channel itslef is being used
-    if ((ledcPins[i][0] == 0)) {
-      assignLEDC(i, p);
-      return i;
-    }
-  }
-  
-  // Return a useless channel if none available.
-  return 255;
-};
-
-// Assign a LEDC channel to a pin and save it.
-byte Denko::assignLEDC(byte channel, byte p){
-  // First 8 channels: up to 40Mhz @ 16-bits
-  // Last 8 channels: up to 500kHz @ 13-bits
-  // Just use similar settings to ATmega for now.
-  ledcSetup(channel, 1000, 8);
-  ledcAttachPin(p, channel);
-  
-  // Save the pin and mark it as in use.
-  ledcPins[channel][0] = 1;
-  ledcPins[channel][1] = p;
-  return channel;
-}
-
-// Release a LEDC channel when done with it.
-void Denko::releaseLEDC(byte p){
-  // Detach the pin from the channel.
-  ledcDetachPin(p);
-  
-  // Mark any channel associated with the pin as unused.
-  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
-    if (ledcPins[i][1] == p) ledcPins[i][0] = 0;
-  }
-}
-
-// Clear all the LEDC channels on reset.
-void Denko::clearLedcChannels(){
-  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
-    // Stop the channel if it was still enabled.
-    if (ledcPins[i][0] != 0) ledcDetachPin(ledcPins[i][1]);
-    
-    // Mark the channel as unused.
-    ledcPins[i][0] = 0;
-  }
+void Denko::ledcDetachAll() {
+  for(byte i=0; i++; i<256) ledcDetach(i);
 }
 #endif
 
@@ -197,7 +154,7 @@ void Denko::dacWrite(byte p, int v, boolean echo) {
   #if defined(ESP32) && defined(SOC_DAC_SUPPORTED)
     ::dacWrite(p, v);
   #endif
-    
+
   #if defined(__SAM3X8E__) || defined(__SAMD21G18A__) || defined(_RENESAS_RA_)
     analogWrite(p, v);
   #endif
@@ -284,7 +241,6 @@ void Denko::updateCoreListeners() {
 // Handle a single analog listener when it needs to read.
 void Denko::analogListenerUpdate(byte i){
   int rval = analogRead(listeners[i][1]);
-  analogListenCallback(listeners[i][1], rval);
   coreResponse(listeners[i][1], rval);
 }
 
@@ -295,7 +251,6 @@ void Denko::digitalListenerUpdate(byte i){
   if (rval != bitRead(listeners[i][0], 5)){
     // State for digital listeners is stored in byte 5 of the listener itself.
     bitWrite(listeners[i][0], 5, rval);
-    digitalListenCallback(listeners[i][1], rval);
     coreResponse(listeners[i][1], rval);
   }
 }

data/src/lib/DenkoDefines.h

@@ -11,6 +11,7 @@
 // #define DENKO_EEPROM
 // #define DENKO_ONE_WIRE
 // #define DENKO_TONE
+// #define DENKO_I2C_BB
 // #define DENKO_SPI_BB
 // #define DENKO_I2C
 // #define DENKO_SPI
@@ -26,29 +27,15 @@
 #endif
 
 // Define number of pins to set up listener storage.
-#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
-  #define PIN_COUNT 70
-#elif defined(__SAM3X8E__)
-  #define PIN_COUNT 72
-#elif defined(ESP8266)
-  #define PIN_COUNT 18
-#elif defined(ESP32)
-  #define PIN_COUNT 40
-#elif defined(ARDUINO_ARCH_RP2040)
-  #define PIN_COUNT 26
+#if defined(ESP32)
+  #define PIN_COUNT SOC_GPIO_PIN_COUNT
 #else
-  #define PIN_COUNT 22
+  #define PIN_COUNT NUM_DIGITAL_PINS
 #endif
 
 // Figure out how many LEDC channels are available on ESP32 boards.
 #ifdef ESP32
-  #if CONFIG_IDF_TARGET_ESP32
-    #define LEDC_CHANNEL_COUNT 16
-  #elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
-    #define LEDC_CHANNEL_COUNT 8
-  #elif CONFIG_IDF_TARGET_ESP32C3
-    #define LEDC_CHANNEL_COUNT 6
-  #endif
+  #define LEDC_CHANNEL_COUNT SOC_LEDC_CHANNEL_NUM
 #endif
 
 // Filter for boards that can set their analog write resolution.
@@ -70,14 +57,10 @@
     #elif defined(PIN_SERIAL_1_TX)
       #define DENKO_UARTS 1
     #endif
-  
+
   // ESP32 has either 1 or 2 extra UARTS enabled, depending on chip and board.
   #elif defined(ESP32)
-    #if SOC_UART_NUM == 3
-      #define DENKO_UARTS 2
-    #elif SOC_UART_NUM == 2
-      #define DENKO_UARTS 1
-    #endif  
+    #define DENKO_UARTS (SOC_UART_NUM - 1)
 
   // ESP8266 has a single open transmit-only UART.
   #elif defined(ESP8266) && defined(SERIAL_PORT_HARDWARE_OPEN)
@@ -107,24 +90,20 @@
   #include <SoftwareSerial.h>
 #endif
 
-// If no high usage features (core sketch), 32 + 16.
-#if !defined(DENKO_SHIFT) && !defined (DENKO_I2C) && !defined(DENKO_SPI) && !defined(DENKO_UARTS) && !defined(DENKO_UART_BB) && !defined(DENKO_IR_OUT) && !defined(DENKO_LED_ARRAY)
+// 32 + 16 bytes aux message for ATmega168. 512 + 16 bytes for all others.
+#if defined(__AVR_ATmega168__)
   #define AUX_SIZE 48
-// If using IR_OUT or LED_ARRAY, and not on the ATmega168, 768 + 16.
-#elif (defined(DENKO_IR_OUT) || defined(DENKO_LED_ARRAY)) && !defined(__AVR_ATmega168__)
-  #define AUX_SIZE 784
-// Default aux message size to 256 + 16 bytes.
 #else
-  #define AUX_SIZE 272
+  #define AUX_SIZE 528
 #endif
 
 // Define 'DENKO_SERIAL_IF' as the serial interface to use.
 // Uses SerialUSB (left port), which is native USB, on Arduino Due & Zero, or Serial otherwise.
 // On many boards, eg. Arduino Leonardo, RP2040, ESP32-S3, Serial is native USB regardless.
 #if defined(__SAM3X8E__) || defined(__SAMD21G18A__)
-  #define DENKO_SERIAL_IF SerialUSB
+  #define DENKO_SERIAL_IF SERIAL_PORT_USBVIRTUAL
   #define DENKO_USB_CDC
-  // To use programming USB (right) on Due and Zero, comment 2 lines above, uncomment 1 line below.
+  // "Serial" is UART (right port) on Due and Zero, but may be native USB on boards with one port.
   // #define DENKO_SERIAL_IF Serial
 #else
   #define DENKO_SERIAL_IF Serial
@@ -135,30 +114,37 @@
 //
 // These are 256/64 regardless of whether native USB CDC or UART bridge.
 #if defined(ARDUINO_ARCH_RP2040) || defined(ESP8266) || defined(__SAM3X8E__)
-  #define DENKO_SERIAL_BUFFER_SIZE 256
+  #define DENKO_SERIAL_BUFFER_SIZE 248
   #define DENKO_RX_ACK_INTERVAL 64
+
 // ESP32 defaults to 256 buffer. Stay one under.
 #elif defined(ESP32)
-  #define DENKO_SERIAL_BUFFER_SIZE 255
-  #ifdef ARDUINO_USB_CDC_ON_BOOT
-    // S2 unreliable with acknowledgement before buffer is full.
-    #ifdef CONFIG_IDF_TARGET_ESP32S2
-      #define DENKO_RX_ACK_INTERVAL 255
-    // S3 and C3 are fine acknowledging at half buffer filled.
+  #define DENKO_SERIAL_BUFFER_SIZE 248
+  // H2 and C6 unreliable with CDC. Use UART bridge. Still unreliable ACK before buffer full, like S2.
+  #if defined(CONFIG_IDF_TARGET_ESP32H2) || defined(CONFIG_IDF_TARGET_ESP32C6)
+    #define DENKO_RX_ACK_INTERVAL 248
+  #else
+    #ifdef ARDUINO_USB_CDC_ON_BOOT
+      // S2 unreliable with acknowledgement before buffer is full.
+      #ifdef CONFIG_IDF_TARGET_ESP32S2
+        #define DENKO_RX_ACK_INTERVAL 248
+      // S3 and C3 are fine acknowledging at half buffer filled.
+      #else
+        #define DENKO_RX_ACK_INTERVAL 128
+      #endif
+    // Fall back to 64 if using a UART bridge.
     #else
-     #define DENKO_RX_ACK_INTERVAL 128
+      #define DENKO_RX_ACK_INTERVAL 64
     #endif
-  // Default to 64 if using a UART bridge.
-  #else
-    #define DENKO_RX_ACK_INTERVAL 64
   #endif
+
 // RA4M1 has a 512 Serial buffer.
 #elif defined(_RENESAS_RA_)
-  #define DENKO_SERIAL_BUFFER_SIZE 512
+  #define DENKO_SERIAL_BUFFER_SIZE 504
   #define DENKO_RX_ACK_INTERVAL 64
 // SAMD21 is 256/128 in native USB mode ONLY. Must use defaults on programming port to avoid data loss.
 #elif defined(__SAMD21G18A__) && defined(DENKO_USB_CDC)
-  #define DENKO_SERIAL_BUFFER_SIZE 256
+  #define DENKO_SERIAL_BUFFER_SIZE 248
   #define DENKO_RX_ACK_INTERVAL 128
 // 32u4 is odd. Size is 63 instead of 64. Interval must be 31. 32 doesn't work at all. Off by 1 errors?
 #elif defined(__AVR_ATmega32U4__)

data/src/lib/DenkoI2C.cpp

@@ -37,6 +37,14 @@ void Denko::i2cSetSpeed(uint8_t code) {
     default: Wire.setClock(100000);  break;
   }
   i2cSpeed = code;
+
+  // ESP32-H2 doesn't safely fallback if speed > 400kHz is chosen.
+  #ifdef CONFIG_IDF_TARGET_ESP32H2
+    if (i2cSpeed > 1) {
+      i2cSpeed = 1;
+      Wire.setClock(400000);
+    }
+  #endif
 }
 
 // CMD = 33
@@ -46,7 +54,7 @@ void Denko::i2cSearch() {
   uint8_t addr;
   if (!i2cStarted) i2cBegin();
   i2cSetSpeed(0);
-  stream->print(SDA);
+  stream->print("I2C0");
 
   // Only addresses from 0x08 to 0x77 are usable (8 to 127).
   for (addr = 0x08; addr < 0x78;  addr++) {
@@ -59,88 +67,89 @@ void Denko::i2cSearch() {
   stream->print('\n');
 }
 
-// CMD = 34
-// Write to an I2C device over a harwdare I2C interface.
-//
-// pin
-//  bits 0..6 = Device address
-//  bit  7    = Send stop condition. 0 = no, repeated start. 1 = yes.
 //
-// val
-//  bits 0..4 = Data length. NOTE: maximum of 32. Anything more is ignored.
-// 
-// auxMsg[0]  = I2C settings. Just speed selection for now.
-//
-// auxMsg[1]+ = data
+// cmd         = 34
+// pin         = <reseverd>
+// val         = <reserved>
+// auxMsg[0]   = I2C settings
+//  Bits[7..2] = <reserved>
+//  Bits[1..0] = Bitmask for I2C speed
+// auxMsg[1]   = Device address in bits [6..0] + repeated start in bit 7
+// auxMsg[2]   = Data length to write
+// auxMsg[3]+  = Data
 //
 void Denko::i2cWrite() {
   // Get parameters from message.
-  uint8_t address     =  (uint8_t)pin & 0b01111111;
-  uint8_t dataLength  =  (uint8_t)val;
+  uint8_t speedMask  = auxMsg[0] & 0b00000011;
+  uint8_t address    = auxMsg[1] & 0b01111111;
+  uint8_t sendStop   = auxMsg[1] >> 7;
+  uint8_t dataLength = auxMsg[2];
 
-  // Limit to 32 bytes.
+  // Limit to board's I2C buffer size.
   if (dataLength > DENKO_I2C_BUFFER_SIZE) dataLength = DENKO_I2C_BUFFER_SIZE;
 
+  // Start and set speed.
   if (!i2cStarted)            i2cBegin();
-  if (i2cSpeed != auxMsg[0])  i2cSetSpeed(auxMsg[0]);
+  if (i2cSpeed != speedMask)  i2cSetSpeed(speedMask);
 
   Wire.beginTransmission(address);
-  Wire.write(&auxMsg[1], dataLength);
+  Wire.write(&auxMsg[3], dataLength);
 
   // No repeated start on ESP32.
   #if defined(ESP32)
     Wire.endTransmission();
   #else
-    uint8_t sendStop = (uint8_t)pin >> 7;
+
     Wire.endTransmission(sendStop);
   #endif
 }
 
-// CMD = 35
-// Read from an I2C device over a harwdare I2C interface.
 //
-// pin
-//  bits 0..6 = Device address
-//  bit  7    = Send stop condition. 0 = no, repeated start. 1 = yes.
-//
-// val
-//  bits 0..4 = Data length. NOTE: maximum of 32. Anything more is ignored.
-//
-// auxMsg[0]  = I2C settings. Just speed selection for now.
+// Read from an I2C device over a harwdare I2C interface.
 //
-// auxMsg[1]  = If > 0, write a register address of that many bytes before reading.
-// auxMsg[2]+ = Register address bytes in order.
+// cmd         = 35
+// pin         = <reseverd>
+// val         = <reserved>
+// auxMsg[0]   = I2C settings
+//  Bits[7..2] = <reserved>
+//  Bits[1..0] = Bitmask for I2C speed
+// auxMsg[1]   = Device address in bits [6..0] + repeated start in bit 7
+// auxMsg[2]   = Data length to read
+// auxMsg[3]   = Register address length
+// auxMsg[4]+  = Register address bytes if length > 0
 //
 void Denko::i2cRead() {
   // Get parameters from message.
-  uint8_t address         = (uint8_t)pin & 0b01111111;
-  uint8_t sendStop        = (uint8_t)pin >> 7;
-  uint8_t dataLength      = (uint8_t)val;
+  uint8_t speedMask  = auxMsg[0] & 0b00000011;
+  uint8_t address    = auxMsg[1] & 0b01111111;
+  uint8_t sendStop   = auxMsg[1] >> 7;
+  uint8_t dataLength = auxMsg[2];
 
-  // Limit to 32 bytes.
+  // Limit to board's I2C buffer size.
   if (dataLength > DENKO_I2C_BUFFER_SIZE) dataLength = DENKO_I2C_BUFFER_SIZE;
 
+  // Start and set speed.
   if (!i2cStarted)            i2cBegin();
-  if (i2cSpeed != auxMsg[0])  i2cSetSpeed(auxMsg[0]);
-  
+  if (i2cSpeed != speedMask)  i2cSetSpeed(speedMask);
+
   // Optionally write up to a 4 byte register address before reading.
-  if ((auxMsg[1] > 0) && (auxMsg[1] < 5)) {
+  if ((auxMsg[3] > 0) && (auxMsg[3] < 5)) {
     Wire.beginTransmission(address);
-    Wire.write(&auxMsg[2], auxMsg[1]);
+    Wire.write(&auxMsg[4], auxMsg[3]);
     Wire.endTransmission(sendStop);
   }
-  
+
   // ESP32 crashes if requestFrom gets the 3rd arg.
-  #if defined(ESP32)  
+  #if defined(ESP32)
     Wire.requestFrom(address, dataLength);
   #else
     Wire.requestFrom(address, dataLength, sendStop);
   #endif
-  
-  // Send data as if coming from SDA pin. Prefix with device adddress.
+
+  // Send data as if coming from a pin called "I2C0". Prefix with device adddress.
   // Fail silently if no bytes read / invalid device address.
-  stream->print(SDA); stream->print(':');
-  stream->print(address); stream->print('-');  
+  stream->print("I2C0:");
+  stream->print(address); stream->print('-');
   while(Wire.available()){
     stream->print(Wire.read());
     stream->print(',');