denko 0.13.5 → 0.14.0

data/src/lib/DenkoI2CBB.cpp

@@ -0,0 +1,238 @@
+//
+// Adds I2C bitbang functionality to the Denko class if DENKO_I2C_BB defined in DenkoDefines.h.
+//
+#include "Denko.h"
+
+#ifdef DENKO_I2C_BB
+
+void Denko::i2c_bb_delay_quarter_period() {
+  #ifndef __AVR__
+    microDelay(i2c_bb_quarter_period);
+  #endif
+}
+
+// Delays for timing. Not sure how necessary this is.
+void Denko::i2c_bb_delay_half_period() {
+  #ifndef __AVR__
+    microDelay(i2c_bb_quarter_period*2);
+  #endif
+}
+
+// Can't use output mode for SDA. Toggle between input for HIGH, output for LOW.
+void Denko::i2c_bb_sda_high() { pinMode(i2c_bb_sda_pin, INPUT);  }
+void Denko::i2c_bb_sda_low()  { pinMode(i2c_bb_sda_pin, OUTPUT); }
+
+// Matching SCL functions for readability.
+void Denko::i2c_bb_scl_high() { digitalWrite(i2c_bb_scl_pin, HIGH); }
+void Denko::i2c_bb_scl_low()  { digitalWrite(i2c_bb_scl_pin, LOW);  }
+
+// Start condition is SDA then SCL going low, from both high.
+void Denko::i2c_bb_start() {
+  i2c_bb_delay_quarter_period();
+  i2c_bb_sda_low();
+  i2c_bb_delay_quarter_period();
+  i2c_bb_scl_low();
+}
+
+// Stop condition is SDA going high, while SCL is also high.
+void Denko::i2c_bb_stop() {
+  i2c_bb_delay_quarter_period();
+  i2c_bb_sda_low();
+  i2c_bb_delay_quarter_period();
+  i2c_bb_scl_high();
+  i2c_bb_delay_quarter_period();
+  i2c_bb_sda_high();
+}
+
+uint8_t Denko::i2c_bb_read_bit() {
+  uint8_t bit;
+
+  // Ensure SDA high before we pull SCL high.
+  // i2c_bb_delay_quarter_period();
+  i2c_bb_sda_high();
+  i2c_bb_delay_quarter_period();
+
+  // Pull SCL high.
+  i2c_bb_scl_high();
+
+  // Wait 1/4 period and sample SDA.
+  i2c_bb_delay_quarter_period();
+  bit = digitalRead(i2c_bb_sda_pin);
+
+  // Leave SCL low.
+  // i2c_bb_delay_quarter_period();
+  i2c_bb_scl_low();
+
+  return bit;
+}
+
+void Denko::i2c_bb_write_bit(uint8_t bit) {
+  // i2c_bb_delay_quarter_period();
+  // Set SDA while SCL is low.
+  if (bit == 0) {
+    i2c_bb_sda_low();
+  } else {
+    i2c_bb_sda_high();
+  }
+  // i2c_bb_delay_quarter_period();
+  
+  // Pull SCL high, wait (should be half cycle), then leave it low.
+  i2c_bb_scl_high();
+  i2c_bb_delay_quarter_period();
+  // i2c_bb_delay_half_period();
+  i2c_bb_scl_low();
+}
+
+uint8_t Denko::i2c_bb_read_byte(bool ack) {
+  uint8_t b;
+
+  // Receive MSB first.
+  for (int i=7; i>=0; i--) bitWrite(b, i, i2c_bb_read_bit());
+
+  // Send ACK or NACK and return byte.
+  if (ack) {
+    i2c_bb_write_bit(0);
+  } else {
+    i2c_bb_write_bit(1);
+  }
+  return b;
+}
+
+int Denko::i2c_bb_write_byte(uint8_t data) {
+  // Send MSB first.
+  for (int i=7; i>=0; i--) i2c_bb_write_bit(bitRead(data, i));
+
+  // Return -1 for NACK, 0 for ACK.
+  return (i2c_bb_read_bit() == 0) ? 0 : -1;
+}
+
+void Denko::i2c_bb_init(uint8_t scl, uint8_t sda) {
+  // Set pins in state variables, to avoid passing them around.
+  i2c_bb_scl_pin = scl;
+  i2c_bb_sda_pin = sda;
+
+  // Ensure SCL is output, and reset both pins to high.
+  pinMode(i2c_bb_scl_pin, OUTPUT);
+  i2c_bb_stop();
+}
+
+//
+// Search for I2C devices on a bit banged I2C interface.
+//
+// cmd = 31
+// pin = SCL pin
+// val = SDA pin
+//
+// Ask each address for a single byte to see if it exists on the bus.
+//
+void Denko::i2c_bb_search() {
+  int ack;
+  uint8_t addr;
+
+  // Switch our "bus" to the given pins.
+  i2c_bb_init((uint8_t)pin, (uint8_t)val);
+
+  // Start sending results.
+  stream->print(i2c_bb_sda_pin);
+
+  // If SDA is low here, nothing connected to bus. Return no results.
+  if (digitalRead(i2c_bb_sda_pin) == 0) {
+    stream->print('\n');
+    return;
+  }
+
+  // Only addresses from 0x08 to 0x77 are usable (8 to 127).
+  for (addr = 0x08; addr < 0x78;  addr++) {
+    i2c_bb_start();
+    ack = i2c_bb_write_byte((addr << 1) & 0b11111110);
+    if (ack == 0) {
+      stream->print(':');
+      stream->print(addr);
+    } 
+    i2c_bb_stop(); 
+  }
+  stream->print('\n');
+}
+
+//
+// Write to an I2C device over a bit banged I2C interface.
+//
+// cmd         = 31
+// pin         = SCL pin
+// val         = SDA pin
+// auxMsg[0]   = I2C settings
+//  Bits[7..0] = <reserved>
+// auxMsg[1]   = Device address in bits [6..0] + repeated start in bit 7
+// auxMsg[2]   = Data length to write
+// auxMsg[3]+  = Data
+//
+void Denko::i2c_bb_write() {
+  // Get parameters from message.
+  uint8_t address      = auxMsg[1] & 0b01111111;
+  uint8_t writeAddress = (address << 1) & 0b11111110;
+  uint8_t sendStop     = auxMsg[1] >> 7;
+  uint8_t dataLength   = auxMsg[2];
+
+  // Switch our "bus" to the given pins.
+  i2c_bb_init((uint8_t)pin, (uint8_t)val);
+
+  i2c_bb_start();
+  i2c_bb_write_byte(writeAddress);
+  for (int i=0; i<dataLength; i++) i2c_bb_write_byte(auxMsg[3+i]);
+  i2c_bb_stop();
+}
+
+//
+// Read from an I2C device over a bit banged I2C interface.
+//
+// cmd         = 32
+// pin         = SCL pin
+// val         = SDA pin
+// auxMsg[0]   = I2C settings
+//  Bits[7..0] = <reserved>
+// 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::i2c_bb_read() {
+  // Get parameters from message.
+  uint8_t address      = auxMsg[1] & 0b01111111;
+  uint8_t writeAddress = (address << 1) & 0b11111110;
+  uint8_t readAddress  = (address << 1) | 0b00000001;
+  uint8_t sendStop     = auxMsg[1] >> 7;
+  uint8_t dataLength   = auxMsg[2];
+
+  // Switch our "bus" to the given pins.
+  i2c_bb_init((uint8_t)pin, (uint8_t)val);
+
+  // Optionally write up to a 4 byte register address before reading.
+  if ((auxMsg[3] > 0) && (auxMsg[3] < 5)) {
+    i2c_bb_start();
+    i2c_bb_write_byte(writeAddress);
+    for(int i=0; i<auxMsg[3]; i++) i2c_bb_write_byte(auxMsg[4+i]);
+    i2c_bb_stop(); 
+  }
+
+  // If no ACK from device, return without sending any data.
+  i2c_bb_start();
+  int ack = i2c_bb_write_byte(readAddress);
+  if (ack < 0) return;
+
+  // Start streaming data as if coming from the SDA pin.
+  stream->print(i2c_bb_sda_pin); stream->print(':');
+  stream->print(address); stream->print('-');
+
+  // Read and ACK for all but the last byte.
+  for(int i=0; i<dataLength-1; i++){
+    stream->print(i2c_bb_read_byte(true));
+    stream->print(',');
+  }
+  stream->print(i2c_bb_read_byte(false));
+
+  // Finish stream and send stop condition.
+  stream->print(',');
+  stream->print('\n');
+  i2c_bb_stop();  
+}
+#endif

data/src/lib/DenkoIROut.cpp

@@ -2,7 +2,7 @@
 // This file adds to the Denko class only if DENKO_IR_OUT is defined in Denko.h.
 //
 #include "Denko.h"
-#if defined(DENKO_IR_OUT) && !defined(ESP8266) && !defined(ESP32)
+#if defined(DENKO_IR_OUT)
 
 // Save memory by disabling receiver.
 #undef RAW_BUFFER_LENGTH
@@ -20,14 +20,19 @@
 // CMD = 16
 // Send an infrared signal.
 void Denko::irSend(){
-  // Byte 1+ of auxMsg is already little-endian uint16 pulses.
-  uint16_t *pulseArray = reinterpret_cast<uint16_t *>(auxMsg + 1);
-  
-  // Dynamically set the sending pin. Needs to be PWM capable.
+  // Change send pin per call. Must be PWM capable.
   IrSender.setSendPin(pin);
 
-  // auxMsg[0] contains number of uint16_t
+  // Byte 2+ of auxMsg is already little-endian uint16 pulses.
+  //
+  // WARNING: This offset must always be an even number, for aligned
+  // memory access on the ESP8266, or it breaks.
+  uint16_t *pulseArray = reinterpret_cast<uint16_t *>(auxMsg + 2);
+
+  // auxMsg[0..1] contains number of pulses, also uint16.
+  uint16_t length = *reinterpret_cast<uint16_t *>(auxMsg);  
+
   // Val contains frequency
-  IrSender.sendRaw(pulseArray, auxMsg[0], val);
+  IrSender.sendRaw(pulseArray, length, val);
 }
 #endif

data/src/lib/DenkoLEDArray.cpp

@@ -10,6 +10,13 @@
 //
 #ifdef DENKO_LED_WS2812
   #include <Adafruit_NeoPixel.h>
+  #ifdef ESP32
+    #include <esp.c>
+  #endif
+
+  #ifdef ARDUINO_ARCH_RP2040
+    Adafruit_NeoPixel ledArray;
+  #endif
 #endif
 
 //
@@ -18,24 +25,40 @@
 //
 // pin          = Microcontroller pin connected to Data In pin of the LED array.
 // val          = Number of raw pixel data bytes to expect. Max 9999.
-// auxMsg[0..3] = Reserved for future settings.
-// auxMsg[4+]   = Raw pixel data, already in correct byte order (GRB, RGB, etc.).
+// auxMsg[0..3] = ALWAYS ZERO or ESP32 can crash if pixel bytes have certain low values. Very confusing.
+// auxMsg[4..7] = Reserved for future settings.
+// auxMsg[8+]   = Raw pixel data, already in correct byte order (GRB, RGB, etc.).
+//
+#define WS2812_DATA_OFFSET 8
 //
 void Denko::showLEDArray() {
-  // Setup a new LED array object.
-  Adafruit_NeoPixel ledArray(val, pin, NEO_GRB + NEO_KHZ800);
-  ledArray.begin();
+  // Avoid memcpy on ESP32 by calling espShow() directly.
+  #ifdef ESP32
+    espShow(pin, &auxMsg[WS2812_DATA_OFFSET], val, true);
 
-  // Copy LED data into the pixel buffer.
-  memcpy(ledArray.getPixels(), &auxMsg[4], val);
+  // Pre-init instance (one PIO) on Pi Pico.
+  #elif defined(ARDUINO_ARCH_RP2040)
+    ledArray.setPin(pin);
+    ledArray.updateLength(val);
+    memcpy(ledArray.getPixels(), &auxMsg[WS2812_DATA_OFFSET], val);
+    ledArray.show();
 
-  // ATmega4809 still needs this delay to avoid corrupt data. Not sure why.
-  #if defined(__AVR_ATmega4809__)
-    microDelay(64);
-  #endif
+  // Reinit and memcpy for everything else.
+  #else
+    // Setup a new LED array object.
+    Adafruit_NeoPixel ledArray(val, pin, NEO_GRB + NEO_KHZ800);
+    ledArray.begin();
+
+    // Copy LED data into the pixel buffer.
+    memcpy(ledArray.getPixels(), &auxMsg[WS2812_DATA_OFFSET], val);
 
-  // Write the pixel buffer to the array.
-  ledArray.show();
+    // Let the line stay low for about 6 bytes worth of data.
+    // Prevents first pixel green being stuck on.
+    microDelay(60);
+
+    // Write the pixel buffer to the array.
+    ledArray.show();
+  #endif
 
   // Tell the computer to resume sending data.
   sendReady();

data/src/lib/DenkoSPI.cpp

@@ -84,7 +84,8 @@ void Denko::spiEnd() {
 // val         = empty
 // auxMsg[0]   = SPI settings
 //   Bit 0..1  = SPI mode
-//   Bit 2..6  = ** unused **
+//   Bit 2..5  = ** unused **
+//   Bit 6     = Whether to toggle select pin (1), or not (0)
 //   Bit 7     = Read and write bit order: MSBFIRST(1) or LSBFIRST(0)
 // auxMsg[1]   = read length  (number of bytes)
 // auxMsg[2]   = write length (number of bytes)
@@ -100,8 +101,8 @@ void Denko::spiTransfer(uint32_t clockRate, uint8_t select, uint8_t settings, ui
     stream->print(':');
   }
 
-  // Pull select pin low, treating 255 as no select pin.
-  if (select != 255) {
+  // Pull select low.
+  if (bitRead(settings, 6) == 1) {
     pinMode(select, OUTPUT);
     digitalWrite(select, LOW);
   }
@@ -122,8 +123,8 @@ void Denko::spiTransfer(uint32_t clockRate, uint8_t select, uint8_t settings, ui
     }
   }
 
-  // Leave select high, treating 255 as no select pin.
-  if (select != 255) digitalWrite(select, HIGH);
+  // Leave select high.
+  if (bitRead(settings, 6) == 1) digitalWrite(select, HIGH);
 
   spiEnd();
 }

data/src/lib/DenkoSPIBB.cpp

@@ -11,7 +11,8 @@
 // val         = empty
 // auxMsg[0]   = SPI settings
 //   Bit 0..1  = SPI mode
-//   Bit 2..6  = ** unused **
+//   Bit 2..5  = ** unused **
+//   Bit 6     = Whether to toggle select pin (1), or not (0)
 //   Bit 7     = Read and write bit order: MSBFIRST(1) or LSBFIRST(0)
 // auxMsg[1]   = read length  (number of bytes)
 // auxMsg[2]   = write length (number of bytes)
@@ -38,7 +39,7 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
   // Set idle state of clock pin based on SPI mode.
   pinMode(clock, OUTPUT);
   if ((mode == 0)||(mode == 1)) digitalWrite(clock, LOW);
-  if ((mode == 2)||(mode == 3)) digitalWrite(clock, LOW);
+  if ((mode == 2)||(mode == 3)) digitalWrite(clock, HIGH);
 
   // Stream read bytes as if coming from select pin.
   if (rLength > 0) {
@@ -46,8 +47,8 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
     stream->print(':');
   }
 
-  // Pull select pin low, treating 255 as no select pin.
-  if (select != 255) {
+  // Pull select low, if needed.
+  if (bitRead(settings, 6) == 1) {
     pinMode(select, OUTPUT);
     digitalWrite(select, LOW);
   }
@@ -68,8 +69,8 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
     }
   }
   
-  // Leave select high, treating 255 as no select pin.
-  if (select != 255) digitalWrite(select, HIGH);
+  // Leave select high.
+  if (bitRead(settings, 6) == 1) digitalWrite(select, HIGH);
 }
 
 //

data/target.yml

@@ -1,3 +1,38 @@
-name: mega
+name: atmega
 fqbn: arduino:avr:uno
-port: /dev/cu.usbmodem14B01
+port: /dev/cu.usbmodem14501
+
+# name: atmega
+# fqbn: arduino:avr:mega
+# port: /dev/cu.usbmodem14501
+
+# name: atmega
+# fqbn: arduino:avr:leonardo
+# port: /dev/cu.usbmodem14501
+
+# Uses native USB port
+# name: atsam3x
+# fqbn: arduino:sam:arduino_due_x
+# port: /dev/cu.usbmodem14501
+
+# Uses native USB port
+# name: atsamd21
+# fqbn: arduino:samd:arduino_zero_native
+# port: /dev/cu.usbmodem14501
+
+# name: esp8266
+# fqbn: esp8266:esp8266:nodemcuv2
+# port: /dev/cu.SLAB_USBtoUART
+
+# name: esp32
+# fqbn: esp32:esp32:esp32doit-devkit-v1
+# port: /dev/cu.SLAB_USBtoUART
+
+# Use for S3 on secondary UART port (not native USB). Native USB needs to be enabled in IDE.
+# name: esp32
+# fqbn: esp32:esp32:lolin_s3
+# port: /dev/cu.usbmodem14501
+
+# name: rp2040
+# fqbn: rp2040:rp2040:rpipicow
+# port: /dev/cu.usbmodem14501

data/test/analog_io/potentiometer_test.rb

@@ -17,45 +17,45 @@ class AnalogIOPotentiometerTest < Minitest::Test
 
     assert part.smoothing
     assert_equal 8,   part.divider
-    assert_equal [],  part.instance_variable_get(:@smoothing_set)
+    assert_equal [],  part.smoothing_set
   end
-  
+
   def test_smoothing_on
     7.times do
       part.update(10)
     end
     part.update(50)
-    
+
     # 120/8 = 15
     assert_equal part.state, 15
   end
-  
+
   def test_smoothing_off
     part.smoothing = false
     7.times do
       part.update(10)
     end
     part.update(50)
-    
+
     # Give latest value.
     assert_equal part.state, 50
   end
-  
+
   def test_on_change
     mock = Minitest::Mock.new.expect(:call, nil)
-    
+
     # Turn off smoothing and set an initial value
     part.smoothing = false
     part.update(100)
-    
+
     # Add the callback
     part.on_change { mock.call }
-    
+
     # Send a few updates
     part.update(100)
     part.update(100)
     part.update(101)
-        
+
     # Should have only been called once.
     mock.verify
   end

data/test/behaviors/board_proxy_test.rb

@@ -18,7 +18,7 @@ class BoardProxyTest < Minitest::Test
     assert_equal part.high, 1
     assert_equal part.low, 0
     assert_equal part.convert_pin("7"), 7
-    part.set_pin_mode(1, :output, :pullup)
+    part.set_pin_mode(1, :output)
     part.start_read
   end
 end

data/test/behaviors/callbacks_test.rb

@@ -27,11 +27,19 @@ class CallbacksTest < Minitest::Test
     @part ||= CallbackComponent.new(board: board, pin: 1)
   end
 
+  def callback_mutex_is_correct_class
+    if (RUBY_ENGINE == "ruby")
+      assert_equal Denko::MutexStub, part.callback_mutex.class
+    else
+      assert_equal Mutex, part.callback_mutex.class
+    end
+  end
+
   def test_callback_mutex
     callback = Proc.new{}
     mock = Minitest::Mock.new
     3.times {mock.expect(:call, nil)}
-    
+
     part.callback_mutex.stub(:synchronize, mock) do
       part.callbacks
       part.add_callback(:key, &callback)
@@ -105,7 +113,7 @@ class CallbacksTest < Minitest::Test
     value = 0
     part.add_callback { value = 1 }
     part.update(nil)
-    assert_equal 0, value 
+    assert_equal 0, value
   end
 
   def test_no_callbacks_with_filter_returning_nil
@@ -113,6 +121,6 @@ class CallbacksTest < Minitest::Test
     value = 0
     part2.add_callback { value = 1 }
     part2.update("anything")
-    assert_equal 0, value 
+    assert_equal 0, value
   end
 end

data/test/behaviors/component_test.rb

@@ -8,7 +8,7 @@ class ComponentTest < Minitest::Test
   def board
     @board ||= BoardMock.new
   end
-  
+
   def part
     @part ||= BaseComponent.new(board: board)
   end
@@ -20,35 +20,43 @@ class ComponentTest < Minitest::Test
   def test_registers_with_board
     assert_equal board.components, [part]
   end
-  
+
   def test_unregisters_with_board
     part.send(:unregister)
     assert_equal board.components, []
   end
-  
+
   def test_start_with_nil_state
     assert_nil BaseComponent.new(board: board).state
   end
-  
+
+  def test_state_mutex_is_correct_class
+    if (RUBY_ENGINE == "ruby")
+      assert_equal Denko::MutexStub, part.state_mutex.class
+    else
+      assert_equal Mutex, part.state_mutex.class
+    end
+  end
+
   def test_sets_and_gets_state
     part.send(:state=, 10)
     assert_equal part.state, 10
   end
-  
+
   def test_state_through_mutex
     mock = Minitest::Mock.new
     2.times {mock.expect(:call, nil)}
-    
-    part.instance_variable_get(:@state_mutex).stub(:synchronize, mock) do
+
+    part.state_mutex.stub(:synchronize, mock) do
       part.state
       part.send(:state=, nil)
     end
     mock.verify
   end
-  
+
   def test_micro_delay
     mock = Minitest::Mock.new.expect :call, nil, [1000]
-    
+
     board.stub(:micro_delay, mock) do
       part.micro_delay(1000)
     end

data/test/behaviors/input_pin_test.rb

@@ -14,21 +14,26 @@ class InputPinTest < Minitest::Test
   end
 
   def test_mode_and_pullup
+    modes = [:input, :input_pulldown, :input_pullup]
+
     mock = Minitest::Mock.new
-    mock.expect :call, nil, [1, :input]
-    mock.expect :call, nil, [2, :input_pulldown]
-    mock.expect :call, nil, [3, :input_pullup]
-    mock.expect :call, nil, [4, :input_output]
+    modes.each_with_index do |mode, pin|
+      mock.expect :call, nil, [pin+1, mode]
+    end
     
     board.stub(:set_pin_mode, mock) do
-      part
-      InputComponent.new(board: board, pin: 2, pulldown: true)
-      InputComponent.new(board: board, pin: 3, pullup: true)
-      InputComponent.new(board: board, pin: 4, mode: :input_output)
+      modes.each_with_index do |mode, pin|
+        local_part = InputComponent.new(board: board, pin: pin+1, mode: mode)
+        assert_equal mode, local_part.mode
+      end
     end
     mock.verify
     
-    assert_equal :input, part.mode
+    assert_raises { InputComponent.new(board: board, pin: modes.count+1, mode: :wrong_mode) }
+  end
+
+  def test_debounce_time=
+    part.debounce_time = 1
   end
 
   def test_stop_listener