denko 0.13.3 → 0.13.5

data/lib/denko/sensor/qmp6988.rb

@@ -0,0 +1,308 @@
+module Denko
+  module Sensor
+    class QMP6988
+      include I2C::Peripheral
+      include Behaviors::Poller
+
+      UPDATE_TIME           = 0.020
+      RESET_REGISTER        = 0xE0
+      RESET_COMMAND         = 0xE6
+      CTRL_MEAS_REGISTER    = 0xF4
+      STANDBY_TIME_REGISTER = 0xF5
+      IIR_REGISTER          = 0xF1
+      CONFIG_LENGTH         = 5
+      DATA_REGISTER         = 0xF7
+      DATA_LENGTH           = 6
+      CALIBRATION_REGISTER  = 0xA0
+      CALIBRATION_LENGTH    = 25
+      CHIP_ID_REGISTER      = 0xD1
+      CHIP_ID_LENGTH        = 1
+      FORCED_MODE           = 0b01
+      NORMAL_MODE           = 0b11
+
+      # Standby Times for Normal (Continuous) Mode in milliseconds
+      STANDBY_TIMES = {
+        1    => 0b000,
+        5    => 0b001,
+        50   => 0b010,
+        250  => 0b011,
+        500  => 0b100,
+        1000 => 0b101,
+        2000 => 0b110,
+        4000 => 0b111,
+      }
+
+      #
+      # Oversample Setting Values
+      # Note: Each sensor has a separate oversample setting.
+      #
+      # General formula:
+      #   2 ** (n-1), where n is the decimal value of the bits, up to 16x max oversampling.
+      #
+      OVERSAMPLE_FACTORS = {
+        # 0  =>  0b000, # Sensor skipped. Value will be 0x800000.
+        1  =>  0b001,
+        2  =>  0b010,
+        4  =>  0b011,
+        8  =>  0b100,
+        16 =>  0b101,
+        32 =>  0b110,
+        64 =>  0b111,
+      }
+      #
+      # Single sample times (in milliseconds) for each sensor, derived from datasheet examples.
+      TEMPERATURE_SAMPLE_TIME = 0.9
+      PRESSURE_SAMPLE_TIME = 0.85
+
+      # IIR Filter Coefficients
+      IIR_COEFFICIENTS = {
+        0  =>  0b000,
+        2  =>  0b001,
+        4  =>  0b010,
+        8  =>  0b011,
+        16 =>  0b100,
+        32 =>  0b101, # 0b110 and 0b111 are also valid for 16.
+      }
+
+      def before_initialize(options={})
+        @i2c_address = 0x70
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Avoid repeated memory allocation for callback data and state.
+        @reading     = { temperature: nil, pressure: nil }
+        self.state   = { temperature: nil, pressure: nil }
+
+        reset
+        
+        # Get 5 config registers. Copy 0xF4 to modify it for control.
+        get_config_registers
+        @ctrl_meas_register = @registers[:f4].dup
+
+        # Default settings
+        self.iir_coefficient = 0
+        self.temperature_samples = 1
+        self.pressure_samples = 1
+        self.forced_mode
+
+        # self.forced mode triggered an initial measurement so IIR works properly if enabled.
+        # Wait for those values to enter the data registers, but don't read them back.
+        sleep @measurement_time
+
+        get_calibration_data
+      end
+
+      #
+      # Configuration Methods
+      #
+      def reset
+        i2c_write [RESET_REGISTER, RESET_COMMAND]
+        sleep UPDATE_TIME
+      end
+
+      def iir_coefficient=(coeff)
+        raise ArgumentError, "invalid IIR coefficient: #{coeff}" unless IIR_COEFFICIENTS.keys.include? coeff
+        i2c_write [IIR_REGISTER, IIR_COEFFICIENTS[coeff]]
+        @iir_coefficient = coeff
+      end
+      attr_reader :iir_coefficient
+
+      def standby_time=(ms)
+        raise ArgumentError, "invalid standby time: #{ms}" unless self.class::STANDBY_TIMES.keys.include? ms
+        byte = STANDBY_TIMES[ms] << 5
+        @standby_time = ms
+        i2c_write [STANDBY_TIME_REGISTER, byte]
+        sleep UPDATE_TIME
+      end
+      attr_reader :standby_time
+
+      def temperature_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        @ctrl_meas_register = (@ctrl_meas_register & 0b00011111) | (OVERSAMPLE_FACTORS[factor] << 5)
+        @temperature_samples = factor
+        calculate_measurement_time
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        sleep UPDATE_TIME
+      end
+      attr_reader :temperature_samples
+      
+      def pressure_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        @ctrl_meas_register = (@ctrl_meas_register & 0b11100011) | (OVERSAMPLE_FACTORS[factor] << 2)
+        @pressure_samples = factor
+        calculate_measurement_time
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        sleep UPDATE_TIME
+      end
+      attr_reader :pressure_samples
+
+      def calculate_measurement_time
+        @measurement_time = (@temperature_samples.to_i * TEMPERATURE_SAMPLE_TIME) +
+                           (@pressure_samples.to_i * PRESSURE_SAMPLE_TIME)
+        # Add 5ms for safety and convert to seconds.
+        @measurement_time = (@measurement_time + 5) * 0.001
+      end
+
+      def forced_mode
+        @ctrl_meas_register = (@ctrl_meas_register & 0b11111100) | FORCED_MODE
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        @forced_mode = true
+        sleep UPDATE_TIME
+      end
+
+      def continuous_mode
+        @ctrl_meas_register = (@ctrl_meas_register & 0b11111100) | NORMAL_MODE
+        i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+        @forced_mode = false
+        sleep UPDATE_TIME
+      end
+
+      def chip_id
+        return @chip_id if @chip_id
+        i2c_read(CHIP_ID_REGISTER, 1)
+        sleep 0.001 while !@chip_id
+        @chip_id
+      end
+
+      #
+      # Reading & Processing
+      #
+      def _read
+        if @forced_mode
+          # Write CTRL_MEAS register to trigger reading, then wait for measurement.
+          i2c_write [CTRL_MEAS_REGISTER, @ctrl_meas_register]
+          sleep @measurement_time
+        end
+        
+        # Read the data bytes.
+        i2c_read(DATA_REGISTER, DATA_LENGTH)
+      end
+
+      def pre_callback_filter(bytes)
+        if bytes.length == DATA_LENGTH
+          return process_reading(bytes)
+        elsif bytes.length == CONFIG_LENGTH
+          process_config(bytes)
+        elsif bytes.length == CALIBRATION_LENGTH
+          process_calibration(bytes)
+        elsif bytes.length == CHIP_ID_LENGTH
+          @chip_id = bytes[0]
+        end
+        return nil
+      end
+
+      def process_reading(bytes)
+        # Temperature and pressure are 24-bits long each, and need 2^23 subtracted.
+        dt = ((bytes[3] << 16) + (bytes[4] << 8) + bytes[5]) - (0b1 << 23)
+        dp = ((bytes[0] << 16) + (bytes[1] << 8) + bytes[2]) - (0b1 << 23)
+
+        # Compensated temperature calculated in 1/256 of a degree Celsius.
+        tr =  @calibration[:a0] +
+              @calibration[:a1] * dt +
+              @calibration[:a2] * (dt ** 2)
+        @reading[:temperature] = tr / 256.0
+
+        # Compensated pressure calculated in Pascals.
+        @reading[:pressure] = @calibration[:b00] +
+                              @calibration[:bt1] * tr +
+                              @calibration[:bp1] * dp +
+                              @calibration[:b11] * (tr * dp)  +
+                              @calibration[:bt2] * (tr ** 2) +
+                              @calibration[:bp2] * (dp ** 2) +
+                              @calibration[:b12] * (dp * (tr ** 2)) +
+                              @calibration[:b21] * ((dp ** 2) * tr) +
+                              @calibration[:bp3] * (dp ** 3)
+
+        # Return reading for callbacks.
+        @reading
+      end
+
+      def update_state(reading)
+        @state_mutex.synchronize do
+          @state[:temperature] = reading[:temperature]
+          @state[:pressure]    = reading[:pressure]
+        end
+      end
+
+      def get_config_registers
+        @registers = {}
+        i2c_read(IIR_REGISTER, CONFIG_LENGTH)
+        sleep 0.001 while @registers.empty?
+        @registers
+      end
+
+      def process_config(bytes)
+        @registers = { f1: bytes[0], f2: bytes[1], f3: bytes[2], f4: bytes[3], f5: bytes[4] }
+      end
+      attr_reader :registers
+
+      #
+      # Calibration
+      #
+      attr_reader :calibration_data_loaded
+
+      CONVERSION_FACTORS = {
+        a1:  { A: -6.3e-03,   S: 4.3e-04 },
+        a2:  { A: -1.9e-11,   S: 1.2e-10 },
+        bt1: { A:  1.0e-01,   S: 9.1e-02 },
+        bt2: { A:  1.2e-08,   S: 1.2e-06 },
+        bp1: { A:  3.3e-02,   S: 1.9e-02 },
+        b11: { A:  2.1e-07,   S: 1.4e-07 },
+        bp2: { A: -6.3e-10,   S: 3.5e-10 },
+        b12: { A:  2.9e-13,   S: 7.6e-13 },
+        b21: { A:  2.1e-15,   S: 1.2e-14 },
+        bp3: { A:  1.3e-16,   S: 7.9e-17 },
+        a0:  16.0,
+        b00: 16.0,
+      }
+
+      def get_calibration_data
+        i2c_read(CALIBRATION_REGISTER, CALIBRATION_LENGTH)
+      end
+
+      def process_calibration(bytes)
+        if bytes
+          # These 2 values are 20-bit instead of 16-bit, so can't combine them with #pack.
+          a0_unsigned  = (bytes[18] << 12) + (bytes[19] << 4) + (bytes[24] & 0b00001111)
+          b00_unsigned = (bytes[0] << 12) + (bytes[1] << 4) + ((bytes[24] & 0b11110000) >> 4)
+
+          # Cast the raw bytes as big-endian signed.
+          @calibration_raw = {
+            # Shift these to 32-bit before converting to signed, then reverse the shift after.
+            a0: [(a0_unsigned << 12)].pack('L>').unpack('l>')[0] >> 12,
+            b00: [(b00_unsigned << 12)].pack('L>').unpack('l>')[0] >> 12,
+
+            a1: bytes[20..21].pack('C*').unpack('s>')[0],
+            a2: bytes[22..23].pack('C*').unpack('s>')[0],
+
+            b11: bytes[8..9].pack('C*').unpack('s>')[0],
+            b12: bytes[12..13].pack('C*').unpack('s>')[0],
+            b21: bytes[14..15].pack('C*').unpack('s>')[0],
+
+            bp1: bytes[6..7].pack('C*').unpack('s>')[0],
+            bp2: bytes[10..11].pack('C*').unpack('s>')[0],
+            bp3: bytes[16..17].pack('C*').unpack('s>')[0],
+
+            bt1: bytes[2..3].pack('C*').unpack('s>')[0],
+            bt2: bytes[4..5].pack('C*').unpack('s>')[0],
+          }
+
+          # Use conversion formulae to calculate compensation coefficients, all as floats.
+          @calibration = {}
+          @calibration_raw.keys.each do |key|
+            if CONVERSION_FACTORS[key].class == Float
+              @calibration[key] = @calibration_raw[key] / CONVERSION_FACTORS[key]
+            else
+              @calibration[key] = CONVERSION_FACTORS[key][:A] + (CONVERSION_FACTORS[key][:S] * @calibration_raw[key] / 32767.0)
+            end
+          end
+
+          @calibration_data_loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/denko/sensor/rcwl9620.rb

@@ -0,0 +1,34 @@
+module Denko
+  module Sensor
+    class RCWL9620
+      include I2C::Peripheral
+      include Behaviors::Poller
+
+      def before_initialize(options={})
+        @i2c_address = 0x57
+        super(options)
+      end
+
+      def _read
+        i2c_write(0x01)
+        sleep(0.120)
+        i2c_read(nil, 3)
+      end
+
+      def pre_callback_filter(bytes)
+        # Data is in micrometers, 3 bytes, big-endian.
+        um = (bytes[0] << 16) + (bytes[1] << 8) + bytes[2]
+        mm = um / 1000.0
+
+        # Limit output between 20 and 4500mm.
+        if mm > 4500.0
+          return 4500.0
+        elsif mm < 20.0
+          return 20.0
+        else
+          return mm
+        end
+      end
+    end
+  end
+end

data/lib/denko/sensor/sht3x.rb

@@ -0,0 +1,128 @@
+module Denko
+  module Sensor
+    class SHT3X
+      include I2C::Peripheral
+      include Behaviors::Poller
+
+      RESET                 = 0x30A2
+      RESET_TIME            = 0.002
+      HEATER_OFF            = 0x3066
+      HEATER_ON             = 0x306D
+      FETCH_DATA            = 0xE000
+      REPEATABILITY         = {
+        high:   { lsb: 0x00, measurement_time: 0.016 },
+        medium: { lsb: 0x0B, measurement_time: 0.007 },
+        low:    { lsb: 0x16, measurement_time: 0.005 },
+      }
+      
+      # Unused
+      READ_STATUS_REGISTER  = 0xF32D
+      CLEAR_STATUS_REGISTER = 0x3041
+      BREAK                 = 0x3093
+      ART                   = 0x2B32
+
+      def before_initialize(options={})
+        @i2c_address = 0x44
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Avoid repeated memory allocation for callback data and state.
+        @reading     = { temperature: nil, humidity: nil }
+        self.state   = { temperature: nil, humidity: nil }
+
+        reset
+        self.repeatability = :high
+      end
+
+      def repeatability=(key)
+        raise ArgumentError, "invalid repeatability setting: #{key}" unless REPEATABILITY.keys.include? key
+        @measurement_lsb = REPEATABILITY[key][:lsb]
+        @measurement_time = REPEATABILITY[key][:measurement_time]
+      end
+
+      def _read
+        i2c_write [0x24, @measurement_lsb]
+        sleep(@measurement_time)
+        i2c_read(FETCH_DATA, 6)
+      end
+
+      def pre_callback_filter(bytes)
+        # Temperature is bytes 0 to 2: MSB, LSB, CRC
+        if calculate_crc(bytes[0..2]) == bytes[2]
+          t_raw = (bytes[0] << 8) | bytes[1]
+          @reading[:temperature] = (175 * t_raw / 65535.0) - 45
+        else
+          @reading[:temperature] = nil
+        end
+
+        # Humidity is bytes 3 to 5: MSB, LSB, CRC
+        if calculate_crc(bytes[3..5]) == bytes[5]
+          h_raw = (bytes[3] << 8) | bytes[4]
+          @reading[:humidity] = 100 * h_raw / 65535.0
+        else
+          @reading[:humidity] = nil
+        end
+
+        @reading
+      end
+
+      def update_state(reading)
+        @state_mutex.synchronize do
+          @state[:temperature] = reading[:temperature]
+          @state[:humidity]    = reading[:humidity]
+        end
+      end
+
+      def reset
+        i2c_write [RESET]
+        sleep RESET_TIME
+        @heater_on = false
+      end
+
+      def heater_on?
+        @heater_on
+      end
+
+      def heater_off?
+        !@heater_on
+      end
+      
+      def heater_on
+        i2c_write [HEATER_ON]
+        @heater_on = true
+      end
+
+      def heater_off
+        i2c_write [HEATER_OFF]
+        @heater_on = false
+      end
+
+      # CRC is same as AHT20 sensor. Copied from that file.
+      CRC_INITIAL_VALUE = 0xFF
+      CRC_POLYNOMIAL    = 0x31
+      MSBIT_MASK        = 0x80
+
+      def calculate_crc(bytes)
+        crc = CRC_INITIAL_VALUE
+
+        # Ignore last byte. That's the CRC value to compare with.
+        bytes.take(bytes.length - 1).each do |byte|
+          crc = crc ^ byte
+          8.times do
+            if (crc & MSBIT_MASK) > 0
+              crc = (crc << 1) ^ CRC_POLYNOMIAL
+            else
+              crc = crc << 1
+            end
+          end
+        end
+        
+        # Limit CRC size to 8 bits.
+        crc = crc & 0xFF
+      end
+    end
+  end
+end

data/lib/denko/sensor.rb

@@ -4,10 +4,17 @@ module Denko
     autoload :Humidity,    "#{__dir__}/sensor/virtual"
     autoload :DHT,         "#{__dir__}/sensor/dht"
     autoload :DS18B20,     "#{__dir__}/sensor/ds18b20"
+    autoload :BMP180,      "#{__dir__}/sensor/bmp180"
     autoload :BME280,      "#{__dir__}/sensor/bme280"
+    autoload :BMP280,      "#{__dir__}/sensor/bme280"
     autoload :HTU21D,      "#{__dir__}/sensor/htu21d"
     autoload :HTU31D,      "#{__dir__}/sensor/htu31d"
     autoload :AHT10,       "#{__dir__}/sensor/aht"
     autoload :AHT20,       "#{__dir__}/sensor/aht"
+    autoload :SHT3X,       "#{__dir__}/sensor/sht3x"
+    autoload :QMP6988,     "#{__dir__}/sensor/qmp6988"
+    autoload :RCWL9620,    "#{__dir__}/sensor/rcwl9620"
+    autoload :HCSR04,      "#{__dir__}/sensor/hcsr04"
+    autoload :GenericPIR,  "#{__dir__}/sensor/generic_pir"
   end
 end

data/lib/denko/version.rb

@@ -1,3 +1,3 @@
 module Denko
-  VERSION = "0.13.3"
+  VERSION = "0.13.5"
 end

data/src/denko_wifi.ino

@@ -30,8 +30,8 @@
 #elif defined(ESP32)
   #include <WiFi.h>
   #include <ESPmDNS.h>
-  // #include <WiFiUdp.h>
-  // #include <ArduinoOTA.h>
+  #include <WiFiUdp.h>
+  #include <ArduinoOTA.h>
   #define WIFI_STATUS_LED 2
 #else
   #define WIFI_STATUS_LED 13
@@ -48,13 +48,13 @@
 #endif
 
 // Configure your WiFi options here. IP address is not configurable. Uses DHCP.
-int port = 3466;
-char* ssid = "yourNetwork";
-char* pass = "yourPassword";
+#define DENKO_TCP_PORT 3466
+#define WIFI_SSID "yourNetwork"
+#define WIFI_PASSWORD "yourPassword"
 boolean connected = false;
 
 Denko denko;
-WiFiServer server(port);
+WiFiServer server(DENKO_TCP_PORT);
 WiFiClient client;
 
 // Use the built in LED to indicate WiFi status.
@@ -82,7 +82,7 @@ void printWifiStatus() {
     DENKO_SERIAL_IF.println(WiFi.localIP());
   #endif
   DENKO_SERIAL_IF.print("Denko TCP Port: ");
-  DENKO_SERIAL_IF.println(port);
+  DENKO_SERIAL_IF.println(DENKO_TCP_PORT);
   indicateWiFi(true);
 }
 
@@ -94,7 +94,7 @@ void connect(){
 
   // Try to connect.
   DENKO_SERIAL_IF.print("Connecting to WiFi ");
-  WiFi.begin(ssid, pass);
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
 
   // Delay until connected.
   while (WiFi.status() != WL_CONNECTED) {
@@ -117,14 +117,39 @@ void setup() {
   DENKO_SERIAL_IF.begin(115200);
   while(!DENKO_SERIAL_IF);
 
-  // Enable over the air updates on the ESP8266.
-  #if defined(ESP8266)
+  // Attempt initial WiFi connection.
+  connect();
+
+  // Enable over the air updates on the ESP8266 and ESP32.
+  // Taken from standard ESP8266/ESP32 OTA examples.
+  #if defined(ESP8266) || (ESP32)
+    ArduinoOTA.onStart([]() {
+      String type;
+      if (ArduinoOTA.getCommand() == U_FLASH) {
+        type = "sketch";
+      } else { // U_FS (ESP8266) or U_SPIFFS (ESP32)
+        type = "filesystem";
+      }
+      // NOTE: if updating FS or SPIFFS, this would be the place to unmount using FS.end() or SPIFFS.end()
+      Serial.println("Arduino OTA: Start updating " + type);
+    });
+    ArduinoOTA.onEnd([]() {
+      Serial.println("\nArduino OTA: End\n");
+    });
+    ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
+      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+    });
+    ArduinoOTA.onError([](ota_error_t error) {
+      Serial.printf("Error[%u]: ", error);
+      if (error == OTA_AUTH_ERROR) Serial.println("Arduino OTA: Auth Failed");
+      else if (error == OTA_BEGIN_ERROR) Serial.println("Arduino OTA: Begin Failed");
+      else if (error == OTA_CONNECT_ERROR) Serial.println("Arduino OTA: Connect Failed");
+      else if (error == OTA_RECEIVE_ERROR) Serial.println("Arduino OTA: Receive Failed");
+      else if (error == OTA_END_ERROR) Serial.println("Arduino OTA: End Failed");
+    });
     ArduinoOTA.begin();
   #endif
 
-  // Attempt initial WiFi connection.
-  connect();
-  
   // Start the denko TCP server.
   server.begin();
 
@@ -141,7 +166,7 @@ void loop() {
   maintainWiFi();
 
   // Handle OTA updates.
-  #if defined(ESP8266)
+  #if defined(ESP8266) || (ESP32)
     ArduinoOTA.handle();
   #endif
 

data/src/lib/Denko.cpp

@@ -3,6 +3,9 @@
 */
 #include "Denko.h"
 #include "BoardMap.h"
+#ifdef DENKO_EEPROM
+  #include "EEPROM.h"
+#endif
 
 Denko::Denko(){
   messageFragments[0] = cmdStr;
@@ -119,7 +122,8 @@ void Denko::process() {
     #endif
 
     // Implemented in DenkoPulseInput.cpp
-    case 9: pulseRead             (); break;
+    case 9:  pulseRead             (); break;
+    case 20: hcsr04Read            (); break;
 
     // Implemented in DenkoServo.cpp
     #ifdef DENKO_SERVO
@@ -275,7 +279,7 @@ void Denko::handshake() {
   stream->print(',');
   #if defined(EEPROM_EMULATED)
   	stream->print(EMULATED_EEPROM_LENGTH);
-  #elif defined(EEPROM_PRESENT)
+  #elif defined(DENKO_EEPROM)
 	  stream->print(EEPROM.length());
   #endif
 

data/src/lib/Denko.h

@@ -95,11 +95,13 @@ class Denko {
     void eepromRead         (); //cmd = 7
     void eepromWrite        (); //cmd = 8
 
-    // Included Libraries
+    // Pulse inputs (DHT and HC-SR04)
     void pulseRead          (); //cmd = 9
+    void hcsr04Read         (); //cmd = 20
+
+    // Servos
     void servoToggle        (); //cmd = 10
     void servoWrite         (); //cmd = 11
-    void handleSerial       (); //cmd = 12
 
     // Single Bit Bang UART
     #ifdef DENKO_UART_BB

data/src/lib/DenkoDefines.h

@@ -134,9 +134,24 @@
 // Best performance acknowledging at 64 bytes, or 32 if buffer is only 64.
 //
 // These are 256/64 regardless of whether native USB CDC or UART bridge.
-#if defined(ARDUINO_ARCH_RP2040) ||  defined(ESP32) || defined(ESP8266) || defined(__SAM3X8E__)
+#if defined(ARDUINO_ARCH_RP2040) || defined(ESP8266) || defined(__SAM3X8E__)
   #define DENKO_SERIAL_BUFFER_SIZE 256
   #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.
+    #else
+     #define DENKO_RX_ACK_INTERVAL 128
+    #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

data/src/lib/DenkoLEDArray.cpp

@@ -31,7 +31,7 @@ void Denko::showLEDArray() {
 
   // ATmega4809 still needs this delay to avoid corrupt data. Not sure why.
   #if defined(__AVR_ATmega4809__)
-    delayMicroseconds(64);
+    microDelay(64);
   #endif
 
   // Write the pixel buffer to the array.