denko 0.14.0 → 0.15.0

data/src/lib/DenkoSPIBB.cpp

@@ -22,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;
@@ -53,7 +53,7 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
     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) {
@@ -68,7 +68,7 @@ void Denko::spiBBtransfer( uint8_t clock, uint8_t input, uint8_t output, uint8_t
       stream->print((i+1 == rLength) ? '\n' : ',');
     }
   }
-  
+
   // Leave select high.
   if (bitRead(settings, 6) == 1) digitalWrite(select, HIGH);
 }
@@ -79,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;
 
@@ -129,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.
@@ -145,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/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,19 +15,19 @@ class AnalogIOPotentiometerTest < Minitest::Test
       part
     end
 
-    assert part.smoothing
     assert_equal 8,   part.divider
     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

data/test/behaviors/bus_peripheral_test.rb

@@ -18,19 +18,19 @@ class BusPeripheralTest < Minitest::Test
   def bus
     @bus ||= NoAddressController.new(board: board)
   end
-  
+
   def part
     @part ||= NoAddressPeripheral.new(bus: bus, address: 0x22)
   end
-  
+
   def test_initialize
     assert_equal part.board, bus
   end
 
-  def test_can_use_bus_atomically   
+  def test_can_use_bus_atomically
     mock = Minitest::Mock.new
     1.times {mock.expect(:call, nil)}
-    
+
     bus.mutex.stub(:synchronize, mock) do
       part.atomically { true; false; }
     end

data/test/behaviors/callbacks_test.rb

@@ -29,23 +29,33 @@ class CallbacksTest < Minitest::Test
 
   def callback_mutex_is_correct_class
     if (RUBY_ENGINE == "ruby")
-      assert_equal Denko::MutexStub, part.callback_mutex.class
+      assert_equal Denko::MutexStub, part.instance_variable_get(:@callback_mutex).class
     else
-      assert_equal Mutex, part.callback_mutex.class
+      assert_equal Mutex, part.instance_variable_get(:@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)
-      part.remove_callbacks(:key)
+    lock_mock = Minitest::Mock.new
+    2.times {lock_mock.expect(:call, nil)}
+
+    unlock_mock = Minitest::Mock.new
+    2.times {unlock_mock.expect(:call, nil)}
+
+    mutex = part.instance_variable_get(:@callback_mutex)
+    mutex.stub(:lock, lock_mock) do
+      mutex.stub(:unlock, unlock_mock) do
+        part.callbacks
+        assert_equal({}, part.callbacks)
+        part.add_callback(:key, &callback)
+        assert part.callbacks[:key]
+        part.remove_callbacks(:key)
+        assert_equal({}, part.callbacks)
+      end
     end
-    mock.verify
+    lock_mock.verify
+    unlock_mock.verify
   end
 
   def test_add_callback

data/test/behaviors/component_test.rb

@@ -32,9 +32,9 @@ class ComponentTest < Minitest::Test
 
   def test_state_mutex_is_correct_class
     if (RUBY_ENGINE == "ruby")
-      assert_equal Denko::MutexStub, part.state_mutex.class
+      assert_equal Denko::MutexStub, part.instance_variable_get(:@state_mutex).class
     else
-      assert_equal Mutex, part.state_mutex.class
+      assert_equal Mutex, part.instance_variable_get(:@state_mutex).class
     end
   end
 
@@ -43,15 +43,25 @@ class ComponentTest < Minitest::Test
     assert_equal part.state, 10
   end
 
+  # ONLY for pass by value states. If state is Hash or Array, ignore mutex.
   def test_state_through_mutex
-    mock = Minitest::Mock.new
-    2.times {mock.expect(:call, nil)}
+    lock_mock = Minitest::Mock.new
+    2.times { lock_mock.expect(:call, nil) }
 
-    part.state_mutex.stub(:synchronize, mock) do
-      part.state
-      part.send(:state=, nil)
+    unlock_mock = Minitest::Mock.new
+    2.times { unlock_mock.expect(:call, nil) }
+
+    mutex = part.instance_variable_get(:@state_mutex)
+    mutex.stub(:lock, lock_mock) do
+      mutex.stub(:unlock, unlock_mock) do
+        part.state
+        part.send(:state=, 20)
+      end
     end
-    mock.verify
+
+    lock_mock.verify
+    unlock_mock.verify
+    assert_equal 20, part.state
   end
 
   def test_micro_delay

data/test/board/board_test.rb

@@ -31,7 +31,7 @@ class BoardTest < Minitest::Test
   end
 
   def test_set_aux_limit
-    assert_equal 527, board.aux_limit
+    assert_equal 528, board.aux_limit
   end
 
   def test_set_eeprom_length
@@ -42,13 +42,13 @@ class BoardTest < Minitest::Test
     assert_equal 0, board.low
     assert_equal 1, board.high
   end
-  
+
   def test_analog_resolution
     assert_equal 255, board.analog_write_high
     assert_equal 8,   board.analog_write_resolution
     assert_equal 1023, board.analog_read_high
     assert_equal 10,   board.analog_read_resolution
-    
+
     mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command:96, value:12)])
     mock.expect(:call, nil, [Denko::Message.encode(command:97, value:12)])
@@ -57,17 +57,17 @@ class BoardTest < Minitest::Test
       board.analog_read_resolution = 12
     end
     mock.verify
-    
+
     assert_equal 0,    board.low
     assert_equal 12,   board.analog_write_resolution
     assert_equal 4095, board.analog_write_high
     assert_equal 12,   board.analog_read_resolution
     assert_equal 4095, board.analog_read_high
   end
-  
+
   def test_eeprom
     mock = Minitest::Mock.new.expect(:call, "test eeprom", [], board: board)
-    Denko::EEPROM::BuiltIn.stub(:new, mock) do
+    Denko::EEPROM::Board.stub(:new, mock) do
       board.eeprom
     end
     mock.verify
@@ -85,16 +85,16 @@ class BoardTest < Minitest::Test
   def test_update_passes_messages_to_correct_components
     mock1 = Minitest::Mock.new.expect(:update, nil, ["data"])
     3.times { mock1.expect(:pin, 1) }
-    
+
     # Make sure lines are split only on the first colon.
     # Tests for string based pine names too.
     mock2 = Minitest::Mock.new.expect(:update, nil, ["with:colon"])
     3.times { mock2.expect(:pin, 14) }
-    
+
     # Special EEPROM mock.
     mock3 = Minitest::Mock.new.expect(:update, nil, ["bytes"])
     3.times { mock3.expect(:pin, 254) }
-     
+
     board.add_component(mock1)
     board.add_component(mock2)
     board.add_component(mock3)

data/test/board/one_wire_test.rb

@@ -2,7 +2,7 @@ require_relative '../test_helper'
 
 class APIOneWireTest < Minitest::Test
   include TestPacker
-  
+
   def connection
     @connection ||= ConnectionMock.new
   end
@@ -10,36 +10,47 @@ class APIOneWireTest < Minitest::Test
   def board
     @board ||= Denko::Board.new(connection)
   end
-  
+
   def test_one_wire_reset
     board
-    message = Denko::Message.encode command: 41, pin: 1, value: 255
-    
+    message = Denko::Message.encode command: 41, pin: 1, value: 0
+
     mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
-      board.one_wire_reset(1, 255)
+      board.one_wire_reset(1, false)
     end
     mock.verify
   end
-  
+
+  def test_one_wire_reset_with_presence
+    board
+    message = Denko::Message.encode command: 41, pin: 1, value: 1
+
+    mock = Minitest::Mock.new.expect :call, nil, [message]
+    connection.stub(:write, mock) do
+      board.one_wire_reset(1, true)
+    end
+    mock.verify
+  end
+
   def test_one_wire_search
     board
     message = Denko::Message.encode command: 42, pin: 1, aux_message: pack(:uint64, 128, max:8)
-    
+
     mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.one_wire_search(1, 128)
     end
     mock.verify
   end
-  
+
   def test_one_wire_write
     board
-    
+
     # Calculate length and parasite power properly.
     message1 = Denko::Message.encode command: 43, pin: 1, value: 0b10000000 | 3, aux_message: pack(:uint8, [1,2,3])
     message2 = Denko::Message.encode command: 43, pin: 1, value: 4, aux_message: pack(:uint8, [1,2,3,4])
-    
+
     mock = Minitest::Mock.new
     mock.expect :call, nil, [message1]
     mock.expect :call, nil, [message2]
@@ -48,18 +59,18 @@ class APIOneWireTest < Minitest::Test
       board.one_wire_write(1, nil, [1,2,3,4])
     end
     mock.verify
-    
+
     # Don't allow more than 127 bytes of data.
-    assert_raises(ArgumentError) do 
+    assert_raises(ArgumentError) do
       too_big = Array.new(128).map { 42 }
       board.one_wire_write(1, true, too_big)
     end
   end
-  
+
   def test_one_wire_read
     board
     message = Denko::Message.encode command: 44, pin: 1, value: 9
-        
+
     mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.one_wire_read(1, 9)

data/test/board/spi_test.rb

@@ -14,40 +14,56 @@ class APISPITest < Minitest::Test
     @board ||= Denko::Board.new(connection)
   end
 
+  def header_args
+    length = board.aux_limit - 8
+
+    [nil, Array.new(length){0}, length, 1000000, 0, :msbfirst]
+  end
+
   def test_spi_modes
-    # Start with mode = 0.
-    args = [nil, [], 0, 1000000, 0, :msbfirst]
-    assert_equal (pack :uint8, 0b10000000), board.spi_header(*args)[0]
+    # Default to mode 0.
+    assert_equal (pack :uint8, 0b10000000), board.spi_header(*header_args)[0]
 
-    args[4] = 1
+    args = header_args.tap { |a| a[4] = 1 }
     assert_equal (pack :uint8, 0b10000001), board.spi_header(*args)[0]
 
-    args[4] = 2
+    args = header_args.tap { |a| a[4] = 2 }
     assert_equal (pack :uint8, 0b10000010), board.spi_header(*args)[0]
 
-    args[4] = 3
+    args = header_args.tap { |a| a[4] = 3 }
     assert_equal (pack :uint8, 0b10000011), board.spi_header(*args)[0]
 
-    # Invalid mode = 4.
-    assert_raises(ArgumentError) { board.spi_header(*args[3] = 4) }
+    args = header_args.tap { |a| a[4] = 4 }
+    assert_raises(ArgumentError) { board.spi_header(*args) }
   end
 
   def test_spi_lsbfirst
-    args = [nil, [], 0, 1000000, 0, :lsbfirst]
+    # Default to :msbfirst
+    assert_equal (pack :uint8, 0b10000000), board.spi_header(*header_args)[0]
+
+    args = header_args.tap { |a| a[5] = :lsbfirst }
     assert_equal (pack :uint8, 0b00000000), board.spi_header(*args)[0]
   end
 
   def test_spi_frequency
-    args = [nil, [], 0, 1000000, 0, :msbfirst]
-    assert_equal (pack :uint32, 1000000), board.spi_header(*args)[3..6]
+    # Default to 1 MHz.
+    assert_equal (pack :uint32, 1_000_000), board.spi_header(*header_args)[4..7]
 
-    args[3] = 8000000
-    assert_equal (pack :uint32, 8000000), board.spi_header(*args)[3..6]
+    args = header_args.tap { |a| a[3] = 8_000_000 }
+    assert_equal (pack :uint32, 8_000_000), board.spi_header(*args)[4..7]
   end
 
   def test_spi_too_many_bytes
-    assert_raises(ArgumentError) { board.spi_header(read: 256) }
-    assert_raises(ArgumentError) { board.spi_header(write: Array.new(256){0})}
+    # Default args have maximum read and write based on aux_limit.
+    board.spi_header(*header_args)
+
+    # Too many write
+    args = header_args.tap { |a| a[1] << 0 }
+    assert_raises(ArgumentError) { board.spi_header(*args) }
+
+    # Too many read
+    args = header_args.tap { |a| a[2] += 1 }
+    assert_raises(ArgumentError) { board.spi_header(*args) }
   end
 
   def test_spi_no_bytes

data/test/digital_io/input_test.rb

@@ -16,7 +16,7 @@ class DigitalIOInputTest < Minitest::Test
     end
     mock.verify
   end
-  
+
   def test_converts_to_integer
     part
     part.update("1")
@@ -26,7 +26,7 @@ class DigitalIOInputTest < Minitest::Test
   def test__read
     mock = Minitest::Mock.new.expect :call, nil, [14]
     board.stub(:digital_read, mock) do
-      part._read
+      part.read_nb
     end
     mock.verify
   end