denko 0.13.6 → 0.14.0

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/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]

data/test/board/message_test.rb

@@ -30,25 +30,31 @@ class MessageTest < Minitest::Test
   end
 
   def test_build_messages_correctly
-    assert_equal "1.1.1\n",    Denko::Message.encode(command: 1, pin: 1, value: 1)
-    assert_equal "1.1\n",      Denko::Message.encode(command: 1, pin: 1)
-    assert_equal "1..1\n",     Denko::Message.encode(command: 1, value: 1)
-    assert_equal "1\n",        Denko::Message.encode(command: 1)
-    assert_equal "1...test\n", Denko::Message.encode(command: 1, aux_message: "test")
+    assert_equal "0.1.1\n",    Denko::Message.encode(command: 0, pin: 1, value: 1)
+    assert_equal "0.1\n",      Denko::Message.encode(command: 0, pin: 1)
+    assert_equal "0..1\n",     Denko::Message.encode(command: 0, value: 1)
+    assert_equal "0\n",        Denko::Message.encode(command: 0)
+    assert_equal "0...test\n", Denko::Message.encode(command: 0, aux_message: "test")
+  end
+
+  def test_single_byte_digital_write
+    assert_equal 0b11000100.chr, Denko::Message.encode(command: 1, pin: 4,  value: 1)
+    assert_equal 0b10000100.chr, Denko::Message.encode(command: 1, pin: 4,  value: 0)
+    assert_equal "1.64.1\n",     Denko::Message.encode(command: 1, pin: 64, value: 1)
   end
 
   def test_escape_newline_in_aux
-    assert_equal  "1...line1\\\nline2\\\n\n",
-                  Denko::Message.encode(command: 1, aux_message: "line1\nline2\n")
+    assert_equal  "0...line1\\\nline2\\\n\n",
+                  Denko::Message.encode(command: 0, aux_message: "line1\nline2\n")
   end
 
   def test_escape_backslash_in_aux
-    assert_equal  "1...line1\\\\line2\\\\\n",
-                  Denko::Message.encode(command: 1, aux_message: "line1\\line2\\")
+    assert_equal  "0...line1\\\\line2\\\\\n",
+                  Denko::Message.encode(command: 0, aux_message: "line1\\line2\\")
   end
 
   def test_escape_newline_and_backslashes_together
-    assert_equal  "1...line1\\\\\\\nline2\\\\\\\n\n",
-                  Denko::Message.encode(command: 1, aux_message: "line1\\\nline2\\\n")
+    assert_equal  "0...line1\\\\\\\nline2\\\\\\\n\n",
+                  Denko::Message.encode(command: 0, aux_message: "line1\\\nline2\\\n")
   end
 end

data/test/board/spi_test.rb

@@ -5,7 +5,7 @@ require_relative '../test_helper'
 
 class APISPITest < Minitest::Test
   include TestPacker
-  
+
   def connection
     @connection ||= ConnectionMock.new
   end
@@ -13,43 +13,43 @@ class APISPITest < Minitest::Test
   def board
     @board ||= Denko::Board.new(connection)
   end
-  
+
   def test_spi_modes
     # Start with mode = 0.
-    args = [[], 0, 1000000, 0, :msbfirst]
+    args = [nil, [], 0, 1000000, 0, :msbfirst]
     assert_equal (pack :uint8, 0b10000000), board.spi_header(*args)[0]
 
-    args[3] = 1
+    args[4] = 1
     assert_equal (pack :uint8, 0b10000001), board.spi_header(*args)[0]
 
-    args[3] = 2
+    args[4] = 2
     assert_equal (pack :uint8, 0b10000010), board.spi_header(*args)[0]
 
-    args[3] = 3
+    args[4] = 3
     assert_equal (pack :uint8, 0b10000011), board.spi_header(*args)[0]
 
     # Invalid mode = 4.
     assert_raises(ArgumentError) { board.spi_header(*args[3] = 4) }
   end
-  
+
   def test_spi_lsbfirst
-    args = [[], 0, 1000000, 0, :lsbfirst]
+    args = [nil, [], 0, 1000000, 0, :lsbfirst]
     assert_equal (pack :uint8, 0b00000000), board.spi_header(*args)[0]
   end
 
   def test_spi_frequency
-    args = [[], 0, 1000000, 0, :msbfirst]
+    args = [nil, [], 0, 1000000, 0, :msbfirst]
     assert_equal (pack :uint32, 1000000), board.spi_header(*args)[3..6]
 
-    args[2] = 8000000
+    args[3] = 8000000
     assert_equal (pack :uint32, 8000000), board.spi_header(*args)[3..6]
   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})}
   end
-  
+
   def test_spi_no_bytes
     assert_raises(ArgumentError) { board.spi_transfer(3, read: 0) }
     assert_raises(ArgumentError) { board.spi_listen(3, read: 0) }
@@ -58,34 +58,34 @@ class APISPITest < Minitest::Test
   def test_spi_bad_frequency
     assert_raises(ArgumentError) { board.spi_transfer(3, read: 0, frequency: "string") }
   end
-  
+
   def test_spi_transfer
     board
     bytes = [1,2,3,4]
-    header = board.spi_header(bytes, 4, 8000000, 2, :lsbfirst)
+    header = board.spi_header(3, bytes, 4, 8000000, 2, :lsbfirst)
     aux = header + pack(:uint8, bytes)
     mock = Minitest::Mock.new.expect  :call, nil,
                                       [Denko::Message.encode(command: 26, pin: 3, aux_message: aux)]
-    
+
     board.stub(:write, mock) do
       args = { write: [1,2,3,4], read: 4, bit_order: :lsbfirst, frequency: 8000000, mode: 2 }
-      board.spi_transfer(3, **args)
+      board.spi_transfer(0, 3, **args)
     end
     mock.verify
   end
-  
+
   def test_spi_listen
     board
-    header = board.spi_header([], 8, 1000000, 0, :lsbfirst)
+    header = board.spi_header(3, [], 8, 1000000, 0, :lsbfirst)
     mock = Minitest::Mock.new.expect  :call, nil,
                                       [Denko::Message.encode(command: 27, pin: 3, aux_message: header)]
-    
+
     board.stub(:write, mock) do
-      board.spi_listen(3, read: 8, bit_order: :lsbfirst)
+      board.spi_listen(0, 3, read: 8, bit_order: :lsbfirst)
     end
     mock.verify
   end
-  
+
   def test_spi_stop
     board
     mock = Minitest::Mock.new.expect :call, nil, [Denko::Message.encode(command: 28, pin: 3)]

data/test/digital_io/button_test.rb

@@ -0,0 +1,15 @@
+require_relative '../test_helper'
+
+class DigitalIOButtonTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::DigitalIO::Button.new(board: board, pin: 14)
+  end
+
+  def test_divider_set_correctly
+    assert_equal 1, part.divider
+  end
+end

data/test/digital_io/relay_test.rb

@@ -0,0 +1,18 @@
+require_relative '../test_helper'
+
+class DigitalIORelaynTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def relay
+    @relay ||= Denko::DigitalIO::Relay.new(board: board, pin: 14)
+  end
+
+  def test_open_and_close
+    relay.close
+    assert_equal 1, relay.state
+    relay.open
+    assert_equal 0, relay.state
+  end
+end