denko 0.13.6 → 0.15.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,10 @@
 //
 #ifdef DENKO_LED_WS2812
   #include <Adafruit_NeoPixel.h>
+
+  #ifdef ARDUINO_ARCH_RP2040
+    Adafruit_NeoPixel ledArray;
+  #endif
 #endif
 
 //
@@ -18,24 +22,36 @@
 //
 // 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();
+  // Pre-init instance (one PIO) on Pi Pico.
+  #ifdef ARDUINO_ARCH_RP2040
+    ledArray.setPin(pin);
+    ledArray.updateLength(val);
+    memcpy(ledArray.getPixels(), &auxMsg[WS2812_DATA_OFFSET], val);
+    ledArray.show();
 
-  // Copy LED data into the pixel buffer.
-  memcpy(ledArray.getPixels(), &auxMsg[4], val);
+  // Reinit and memcpy for everything else.
+  #else
+    // Setup a new LED array object.
+    Adafruit_NeoPixel ledArray(val, pin, NEO_GRB + NEO_KHZ800);
+    ledArray.begin();
 
-  // ATmega4809 still needs this delay to avoid corrupt data. Not sure why.
-  #if defined(__AVR_ATmega4809__)
-    microDelay(64);
-  #endif
+    // Copy LED data into the pixel buffer.
+    memcpy(ledArray.getPixels(), &auxMsg[WS2812_DATA_OFFSET], val);
+
+    // 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();
+    // Write the pixel buffer to the array.
+    ledArray.show();
+  #endif
 
   // Tell the computer to resume sending data.
   sendReady();

data/src/lib/DenkoSPI.cpp

@@ -45,7 +45,7 @@ void Denko::spiBegin(byte settings, uint32_t clockRate) {
 
   // SPI mode is the lowest 2 bits of settings.
   byte mode = settings & 0B00000011;
-  
+
   // Bit 7 of settings controls bit order. 0 = LSBFIRST, 1 = MSBFIRST.
   if (bitRead(settings, 7) == 0) {
     // True integer value for these macros vary by platform, so just do this.
@@ -84,46 +84,51 @@ 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)
 // auxMsg[3-6] = clock frequency (uint32_t as 4 bytes)
 // auxMsg[7+]  = data (bytes) (write only)
 //
-void Denko::spiTransfer(uint32_t clockRate, uint8_t select, uint8_t settings, uint8_t rLength, uint8_t wLength, byte *data) {
+void Denko::spiTransfer(uint32_t clockRate, uint8_t select, uint8_t settings, uint16_t rLength, uint16_t wLength, byte *data) {
   spiBegin(settings, clockRate);
 
-  // Stream read bytes as if coming from select pin.
+  // Pull select low.
+  if (bitRead(settings, 6) == 1) {
+    pinMode(select, OUTPUT);
+    digitalWrite(select, LOW);
+  }
+
+  // Go one byte at a time if reading bytes out.
   if (rLength > 0) {
+    // Stream read bytes as if coming from select pin.
     stream->print(select);
     stream->print(':');
-  }
 
-  // Pull select pin low, treating 255 as no select pin.
-  if (select != 255) {
-    pinMode(select, OUTPUT);
-    digitalWrite(select, LOW);
-  }
-  
-  for (byte i = 0;  (i < rLength || i < wLength);  i++) {
-    byte b;
+    for (uint16_t i=0; (i < rLength || i < wLength); i++) {
+      byte b;
 
-    if (i < wLength) {
-      b = SPI.transfer(data[i]);
-    } else {
-      b = SPI.transfer(0x00);
-    }
+      if (i < wLength) {
+        b = SPI.transfer(data[i]);
+      } else {
+        b = SPI.transfer(0x00);
+      }
 
-    if (i < rLength) {
-      // Print read byte, then a comma or \n if it's the last read byte.
-      stream->print(b);
-      stream->print((i+1 == rLength) ? '\n' : ',');
+      if (i < rLength) {
+        // Print read byte, then a comma or \n if it's the last read byte.
+        stream->print(b);
+        stream->print((i+1 == rLength) ? '\n' : ',');
+      }
     }
+  // Write the entire buffer at once if not reading.
+  } else {
+    SPI.transfer(data, wLength);
   }
 
-  // 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();
 }
@@ -136,16 +141,14 @@ void Denko::spiAddListener() {
             clockRate |= (uint32_t)auxMsg[4] << 8;
             clockRate |= (uint32_t)auxMsg[5] << 16;
             clockRate |= (uint32_t)auxMsg[6] << 24;
-  
+
   for (int i = 0;  i < SPI_LISTENER_COUNT;  i++) {
     if (spiListeners[i].enabled == 0) {
-      spiListeners[i] = {
-        clockRate,
-        pin,        // Select pin
-        auxMsg[0],  // Settings
-        auxMsg[1],  // Read length
-        1           // Enabled = 1 sets hardware SPI listener
-      };
+      spiListeners[i].freq      = clockRate;
+      spiListeners[i].select    = pin;                                              // Select pin
+      spiListeners[i].settings  = auxMsg[0];                                        // Settings mask
+      spiListeners[i].length    = (((uint16_t)auxMsg[3] & 0xF0) << 4) | auxMsg[1];  // Read length
+      spiListeners[i].enabled   = 1;                                                // 1 sets this listener as Hardware SPI
       return;
     } else {
     // Should send some kind of error if all are in use.
@@ -155,7 +158,7 @@ void Denko::spiAddListener() {
 
 // Called by spiUpdateListeners to read an individual hardware SPI listener.
 void Denko::spiReadListener(uint8_t i) {
-  spiTransfer(spiListeners[i].clock,
+  spiTransfer(spiListeners[i].freq,
               spiListeners[i].select,
               spiListeners[i].settings,
               spiListeners[i].length,

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)
@@ -21,8 +22,8 @@
 // auxMsg[6]   = ** unused **
 // auxMsg[7+]  = data (bytes) (write only) - Start from 7 for parity with hardware SPI.
 //
-void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t select, uint8_t settings,
-                          uint8_t rLength, uint8_t wLength, byte *data) {
+void Denko::spiBBtransfer (uint8_t clock, uint8_t input, uint8_t output, uint8_t select, uint8_t settings,
+                           uint16_t rLength, uint16_t wLength, byte *data) {
 
   // Mode is the lowest 2 bits of settings.
   uint8_t mode = settings & 0b00000011;
@@ -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,13 +47,13 @@ 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);
   }
 
-  for (byte i = 0;  (i < rLength || i < wLength);  i++) {
+  for (uint16_t i=0; (i < rLength || i < wLength); i++) {
     byte b;
 
     if (i < wLength) {
@@ -67,9 +68,9 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
       stream->print((i+1 == rLength) ? '\n' : ',');
     }
   }
-  
-  // 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);
 }
 
 //
@@ -78,7 +79,7 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
 byte Denko::spiBBtransferByte(uint8_t clock, uint8_t input, uint8_t output, uint8_t select, uint8_t mode, uint8_t bitOrder, byte data) {
   // Byte to return
   byte b = 0x00;
-  
+
   // Track which of the 8 bits we're on.
   uint8_t bitPos;
 
@@ -128,13 +129,11 @@ void Denko::spiBBaddListener() {
   for (int i = 0;  i < SPI_LISTENER_COUNT;  i++) {
     // Overwrite the first disabled listener in the struct array.
     if (spiListeners[i].enabled == 0) {
-      spiListeners[i] = {
-        ((uint32_t)(auxMsg[4] << 8) | auxMsg[3]),   // Clock: [0..7], input: [8..15]
-        pin,                                        // Select pin
-        auxMsg[0],                                  // Settings mask
-        auxMsg[1],                                  // Read length
-        2                                           // Enabled = 2 sets bit bang SPI listener
-      };
+      spiListeners[i].freq      = ((uint32_t)(auxMsg[4] << 8) | auxMsg[3]);         // SCK: [0..7], MOSI: [8..15] in freq's uint32.
+      spiListeners[i].select    = pin;                                              // Select pin
+      spiListeners[i].settings  = auxMsg[0];                                        // Settings mask
+      spiListeners[i].length    = (((uint16_t)auxMsg[3] & 0xF0) << 4) | auxMsg[1];  // Read length
+      spiListeners[i].enabled   = 2;                                                // 2 sets this listener as Bit-Bang
       return;
     } else {
     // Should send some kind of error if all are in use.
@@ -144,8 +143,8 @@ void Denko::spiBBaddListener() {
 
 // Called by spiUpdateListeners to read an individual bit bang SPI listener.
 void Denko::spiBBreadListener(uint8_t i) {
-  spiBBtransfer((spiListeners[i].clock & 0xFF),         // Clock pin is bits [0..7] of the uint32
-                ((spiListeners[i].clock >> 8) & 0xFF),  // Input pin is bits [8..15] of the uint32
+  spiBBtransfer ((spiListeners[i].freq & 0xFF),         // SCK pin is bits [0..7] of freq's uint32
+                ((spiListeners[i].freq >> 8) & 0xFF),   // MOSI pin is bits [8..15] of freq's uint32
                 255,                                    // Disabled output pin
                 spiListeners[i].select,                 // Select pin
                 spiListeners[i].settings,

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/input_test.rb

@@ -12,7 +12,7 @@ class AnalogIOInputTest < Minitest::Test
   def test__read
     mock = Minitest::Mock.new.expect :call, nil, [14, nil, nil, nil]
     board.stub(:analog_read, mock) do
-      part._read
+      part.read_nb
     end
     mock.verify
   end

data/test/analog_io/potentiometer_test.rb

@@ -15,47 +15,47 @@ class AnalogIOPotentiometerTest < Minitest::Test
       part
     end
 
-    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
+    part.smoothing = true
     7.times do
       part.update(10)
     end
     part.update(50)
-    
+
     # 120/8 = 15
-    assert_equal part.state, 15
+    assert_equal 15, part.state
   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