denko 0.13.6 → 0.15.0

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

@@ -27,17 +27,35 @@ 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.instance_variable_get(:@callback_mutex).class
+    else
+      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
@@ -105,7 +123,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 +131,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,53 @@ 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.instance_variable_get(:@state_mutex).class
+    else
+      assert_equal Mutex, part.instance_variable_get(:@state_mutex).class
+    end
+  end
+
   def test_sets_and_gets_state
     part.send(:state=, 10)
     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)}
-    
-    part.instance_variable_get(:@state_mutex).stub(:synchronize, mock) do
-      part.state
-      part.send(:state=, nil)
+    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(:@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
     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

data/test/behaviors/multi_pin_test.rb

@@ -5,8 +5,9 @@ class MultiPinComponent
   
   def initialize_pins(options={})
     require_pin :one
-    proxy_pin   :two,   Denko::DigitalIO::Output
-    proxy_pin   :maybe, Denko::DigitalIO::Input, optional: true
+    proxy_pin   :two,         Denko::DigitalIO::Output
+    proxy_pin   :maybe,       Denko::DigitalIO::Input,  optional: true
+    proxy_pin   :other_board, Denko::DigitalIO::Output, board: options[:board2], optional: true
   end
 end
 
@@ -15,9 +16,14 @@ class MultiPinTest < Minitest::Test
     @board ||= BoardMock.new
   end
 
+  def board2
+    @board2 ||= BoardMock.new
+  end
+
   def part
     @part ||= MultiPinComponent.new board: board,
-                                    pins: { one: 9, two: 10, maybe: 11 }
+                                    board2: board2,
+                                    pins: { one: 9, two: 10, maybe: 11, other_board: 13 }
   end
 
   def test_validate_pins
@@ -38,6 +44,10 @@ class MultiPinTest < Minitest::Test
     assert_equal Denko::DigitalIO::Output, part.proxies[:two].class
     assert_equal Denko::DigitalIO::Input, part.proxies[:maybe].class
   end
+
+  def test_build_proxy_on_other_board
+    assert_equal board2, part.proxies[:other_board].board
+  end
   
   def attr_reader_exists_for_optional_pins
     part = MultiPinComponent.new board: board, pins: { one: 9, two:10 }
@@ -56,7 +66,7 @@ class MultiPinTest < Minitest::Test
 
   def test_proxy_states
     part.two.high
-    assert_equal({two: board.high, maybe: nil}, part.proxy_states)
+    assert_equal({two: board.high, maybe: nil, other_board: nil}, part.proxy_states)
 
     part2 = MultiPinComponent.new board: board, pins: { one: 'A1', two:12 }
     part2.two.low

data/test/behaviors/output_pin_test.rb

@@ -9,19 +9,22 @@ class OutputPinTest < Minitest::Test
     @board ||= BoardMock.new
   end
 
-  def part
-    @part ||= OutputComponent.new(board: board, pin: 1)
-  end
-
   def test_set_mode
+    modes = [:output, :output_pwm, :output_dac, :output_open_drain, :output_open_source]
+
     mock = Minitest::Mock.new
-    mock.expect :call, nil, [1, :output]
-    
+    modes.each_with_index do |mode, pin|
+      mock.expect :call, nil, [pin+1, mode]
+    end
+
     board.stub(:set_pin_mode, mock) do
-      part
+      modes.each_with_index do |mode, pin|
+        part = OutputComponent.new(board: board, pin: pin+1, mode: mode)
+        assert_equal mode, part.mode
+      end
     end
     mock.verify
     
-    assert_equal :output, part.mode
+    assert_raises { OutputComponent.new(board: board, pin: modes.count+1, mode: :wrong_mode) }
   end
 end

data/test/behaviors/poller_test.rb

@@ -18,6 +18,7 @@ class PollerTest < Minitest::Test
   def inject(data, wait_for_callbacks = true)
     Thread.new do
       if wait_for_callbacks
+        while (!part.callbacks) do; sleep 0.01; end
         while (!part.callbacks[:read]) do; sleep 0.01; end
       end
       loop do

data/test/behaviors/reader_test.rb

@@ -18,6 +18,7 @@ class ReaderTest < Minitest::Test
   def inject(data, wait_for_callbacks = true)
     Thread.new do
       if wait_for_callbacks
+        while (!part.callbacks) do; sleep 0.01; end
         while (!part.callbacks[:read]) do; sleep 0.01; end
       end
       loop do
@@ -39,7 +40,7 @@ class ReaderTest < Minitest::Test
   def test_read_once
     mock = Minitest::Mock.new.expect :call, nil
     inject(1)
-    
+
     part.stub(:_read, mock) do
       part.read
     end
@@ -50,7 +51,7 @@ class ReaderTest < Minitest::Test
     inject(42)
     assert_equal part.read, 42
   end
-  
+
   def test_read_using_with_lambda
     inject(1)
     reader = Minitest::Mock.new.expect :call, nil

data/test/behaviors/subcomponents_test.rb

@@ -15,7 +15,7 @@ class MultiPinComponentMock
   def pin
     {a: 1, b: 2}
   end
-end 
+end
 
 class SubcomponentsTest < Minitest::Test
   def connection
@@ -60,7 +60,7 @@ class SubcomponentsTest < Minitest::Test
     board.remove_component(multi_pin)
     assert_empty board.components
   end
-  
+
   def test_calls_stop_on_remove
     pinless = PinlessComponentMock.new
     board.add_component(pinless)
@@ -72,4 +72,24 @@ class SubcomponentsTest < Minitest::Test
 
     mock.verify
   end
+
+  def test_disallows_duplicate_hw_i2c_buses
+    i2c0 = Denko::I2C::Bus.new(board: board, pin: 0)
+    assert_raises { Denko::I2C::Bus.new(board: board) }
+  end
+
+  def test_hw_i2c_buses_add_and_remove_properly
+    i2c0 = Denko::I2C::Bus.new(board: board, i2c_index: 0)
+    i2c1 = Denko::I2C::Bus.new(board: board, i2c_index: 1)
+    assert_equal [i2c0, i2c1], board.components
+
+    # Have the right hash keys.
+    assert_equal i2c0, board.hw_i2c_comps[0]
+    assert_equal i2c1, board.hw_i2c_comps[1]
+
+    # Get removed correctly.
+    board.remove_component(i2c0)
+    hash = { 1 => i2c1 }
+    assert_equal hash, board.hw_i2c_comps
+  end
 end

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

@@ -14,27 +14,31 @@ class BoardCoreTest < Minitest::Test
   def test_set_pin_mode
     mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b000)])
-    mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b010)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b010, aux_message: pack(:uint32, [0, 0]))])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b010, aux_message: pack(:uint32, [1000, 12]))])
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b100)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b001)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b011)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b101)])
-    mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b111)])  
 
     board.stub(:write, mock) do
       board.set_pin_mode 1, :output
       board.set_pin_mode 1, :output_pwm
+      board.set_pin_mode 1, :output_pwm, frequency: 1000, resolution: 12
       board.set_pin_mode 1, :output_dac
       board.set_pin_mode 1, :input
       board.set_pin_mode 1, :input_pulldown
       board.set_pin_mode 1, :input_pullup
-      board.set_pin_mode 1, :input_output
     end
     mock.verify
 
     assert_raises { board.set_pin_mode 1, "wrong" }
   end
 
+  def test_set_pin_debounce
+    board.set_pin_debounce(1, 1)
+  end
+
   def test_digital_write
     mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 1, pin: 1, value: board.low)])
@@ -74,7 +78,7 @@ class BoardCoreTest < Minitest::Test
 
     assert_raises { board.pwm_write 1, "wrong" }
   end
-  
+
   def test_dac_write
     mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 4, pin: 1, value: board.low)])
@@ -153,11 +157,11 @@ class BoardCoreTest < Minitest::Test
   def test_analog_resolution
     mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 96, value: 10)])
-    mock.expect(:call, nil, [Denko::Message.encode(command: 97, value: 10)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 97, value: 8)])
 
     board.stub(:write, mock) do
       board.analog_write_resolution = 10
-      board.analog_read_resolution = 10
+      board.analog_read_resolution = 8
     end
     mock.verify
 
@@ -167,16 +171,16 @@ class BoardCoreTest < Minitest::Test
     assert_raises { board.analog_read_resolution= "wrong"  }
   end
 
-  def micro_delay   
+  def micro_delay
     aux = pack(:uint16, [1000])
     message = Denko::Message.encode command: 99, aux_message: aux
     mock = Minitest::Mock.new.expect :call, nil, [message]
-    
+
     board.stub(:write, mock) do
       board.micro_delay(1000)
     end
-    
-    assert_raises(ArgumentError) { board.micro_delay(65536)   }  
-    assert_raises(ArgumentError) { board.micro_delay("wrong") }  
+
+    assert_raises(ArgumentError) { board.micro_delay(65536)   }
+    assert_raises(ArgumentError) { board.micro_delay("wrong") }
   end
 end

data/test/board/i2c_test.rb

@@ -2,7 +2,7 @@ require_relative '../test_helper'
 
 class APII2CTest < Minitest::Test
   include TestPacker
-  
+
   def connection
     @connection ||= ConnectionMock.new
   end
@@ -10,91 +10,97 @@ class APII2CTest < Minitest::Test
   def board
     @board ||= Denko::Board.new(connection)
   end
-  
+
   def test_search
     board
     message = Denko::Message.encode command: 33
-    
+
     mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
-      board.i2c_search
+      board.i2c_search(0)
     end
     mock.verify
   end
 
   def test_write
     board
-    aux = pack(:uint8, 0x00) + pack(:uint8, [1,2,3,4])
     address = 0x30
-      
+    data    = [1,2,3,4]
+
     # Normal
-    message1 = Denko::Message.encode command: 34, pin: address | (1 << 7), value: 4, aux_message: aux
+    aux_stop = pack(:uint8, 0x00) +  pack(:uint8, address | (1 << 7)) + pack(:uint8, data.length) + pack(:uint8, data)
+    message1 = Denko::Message.encode command: 34, aux_message: aux_stop
     # Repeated start
-    message2 = Denko::Message.encode command: 34, pin: address | (0 << 7), value: 4, aux_message: aux
+    aux_repeat = pack(:uint8, 0x00) +  pack(:uint8, address | (0 << 7)) + pack(:uint8, data.length) + pack(:uint8, data)
+    message2   = Denko::Message.encode command: 34, aux_message: aux_repeat
 
     mock = Minitest::Mock.new
     mock.expect :call, nil, [message1]
     mock.expect :call, nil, [message2]
-    
+
     connection.stub(:write, mock) do
-      board.i2c_write(0x30, [1,2,3,4])
-      board.i2c_write(0x30, [1,2,3,4], 100000, true)
+      board.i2c_write(0, 0x30, [1,2,3,4])
+      board.i2c_write(0, 0x30, [1,2,3,4], 100000, true)
     end
     mock.verify
   end
 
   def test_write_limits
-    assert_raises { board.i2c_write(0x30, Array.new(33) {0x00}) }
-    assert_raises { board.i2c_write(0x30, Array.new(0)  {0x00}) }
+    assert_raises { board.i2c_write(0, 0x30, Array.new(33) {0x00}) }
+    assert_raises { board.i2c_write(0, 0x30, Array.new(0)  {0x00}) }
   end
 
   def test_read
     board
-    aux = pack(:uint8, 0x00) + pack(:uint8, [1, 0x03])
+    address = 0x30
+
     # Normal
-    message1 = Denko::Message.encode command: 35, pin: 0x30 | (1 << 7), value: 4, aux_message: aux
+    aux_stop = pack(:uint8, 0x00) + pack(:uint8, address | (1 << 7)) + pack(:uint8, 4) + pack(:uint8, [1, 0x03])
+    message1 = Denko::Message.encode command: 35, aux_message: aux_stop
     # Repeated start
-    message2 = Denko::Message.encode command: 35, pin: 0x30 | (0 << 7), value: 4, aux_message: aux
+    aux_repeat = pack(:uint8, 0x00) + pack(:uint8, address | (0 << 7)) + pack(:uint8, 4) + pack(:uint8, [1, 0x03])
+    message2   = Denko::Message.encode command: 35, aux_message: aux_repeat
 
     mock = Minitest::Mock.new
     mock.expect :call, nil, [message1]
     mock.expect :call, nil, [message2]
-    
+
     connection.stub(:write, mock) do
-      board.i2c_read(0x30, 0x03, 4)
-      board.i2c_read(0x30, 0x03, 4, 100000, true)
+      board.i2c_read(0, 0x30, 0x03, 4)
+      board.i2c_read(0, 0x30, 0x03, 4, 100000, true)
     end
     mock.verify
   end
-  
+
   def test_read_without_register
     board
-    aux = pack(:uint8, 0x00) + pack(:uint8, [0])
-    message = Denko::Message.encode command: 35, pin: 0x30 | (1 << 7), value: 4, aux_message: aux
+    aux = pack(:uint8, 0x00) + pack(:uint8, 0x30 | (1 << 7)) + pack(:uint8, 4) + pack(:uint8, [0])
+    message = Denko::Message.encode command: 35, aux_message: aux
 
     mock = Minitest::Mock.new
     mock.expect :call, nil, [message]
-    
+
     connection.stub(:write, mock) do
-      board.i2c_read(0x30, nil, 4)
+      board.i2c_read(0, 0x30, nil, 4)
     end
     mock.verify
   end
 
   def test_read_limits
-    assert_raises { board.i2c_read(0x30, nil, 33) }
-    assert_raises { board.i2c_read(0x30, nil, 0)  }
+    assert_raises { board.i2c_read(0, 0x30, nil, 33) }
+    assert_raises { board.i2c_read(0, 0x30, nil, 0)  }
   end
 
   def test_frequencies
     board
     data = [1,2,3,4]
     address = 0x30
-      
+
     messages = []
     # 100 kHz, 400 kHz, 1 Mhz, 3.4 MHz
+    aux_after_config = pack(:uint8, 0x30 | (1 << 7)) + pack(:uint8, data.length) + pack(:uint8, data)
     [0x00, 0x01, 0x02, 0x03].each do |code|
-      messages << Denko::Message.encode(command: 34, pin: 0x30 | (1 << 7), value: 4, aux_message: pack(:uint8, code) + pack(:uint8, data))
+      messages << Denko::Message.encode(command: 34, aux_message: pack(:uint8, code) + aux_after_config)
     end
 
     mock = Minitest::Mock.new
@@ -102,13 +108,13 @@ class APII2CTest < Minitest::Test
       mock.expect :call, nil, [message]
     end
     connection.stub(:write, mock) do
-      board.i2c_write(address, data, 100000)
-      board.i2c_write(address, data, 400000)
-      board.i2c_write(address, data, 1000000)
-      board.i2c_write(address, data, 3400000)
+      board.i2c_write(0, address, data, 100000)
+      board.i2c_write(0, address, data, 400000)
+      board.i2c_write(0, address, data, 1000000)
+      board.i2c_write(0, address, data, 3400000)
     end
     mock.verify
 
-    assert_raises(ArgumentError) { board.i2c_write(0x30, [1,2,3,4], 5000000, false) }
+    assert_raises(ArgumentError) { board.i2c_write(0, 0x30, [1,2,3,4], 5000000, false) }
   end
 end

data/test/board/infrared_test.rb

@@ -13,7 +13,7 @@ class APIInfraredTest < Minitest::Test
   
   def test_infrared_emit
     board
-    aux = pack(:uint8, 4) + pack(:uint16, [255,0,255,0])
+    aux = pack(:uint16, 4) + pack(:uint16, [255,0,255,0])
     message = Denko::Message.encode command: 16, pin: 8, value: 38, aux_message: aux
     
     mock = Minitest::Mock.new.expect :call, nil, [message]