denko 0.13.6 → 0.15.0

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

@@ -5,7 +5,7 @@ require_relative '../test_helper'
 
 class APISPITest < Minitest::Test
   include TestPacker
-  
+
   def connection
     @connection ||= ConnectionMock.new
   end
@@ -13,43 +13,59 @@ class APISPITest < Minitest::Test
   def board
     @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 = [[], 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[3] = 1
+    args = header_args.tap { |a| a[4] = 1 }
     assert_equal (pack :uint8, 0b10000001), board.spi_header(*args)[0]
 
-    args[3] = 2
+    args = header_args.tap { |a| a[4] = 2 }
     assert_equal (pack :uint8, 0b10000010), board.spi_header(*args)[0]
 
-    args[3] = 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 = [[], 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 = [[], 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[2] = 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
     assert_raises(ArgumentError) { board.spi_transfer(3, read: 0) }
     assert_raises(ArgumentError) { board.spi_listen(3, read: 0) }
@@ -58,34 +74,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/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

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

data/test/digital_io/rotary_encoder_test.rb

@@ -6,94 +6,114 @@ class RotaryEncoderTest < Minitest::Test
   end
 
   def part
-    @part ||= Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data:3, clock: 4}
+    @part ||= Denko::DigitalIO::RotaryEncoder.new board: board, pins: {b: 3, a: 4}
   end
 
-  def test_sets_steps_per_revolution
-    assert_equal 30,      part.steps_per_revolution
-    assert_equal 12.to_f, part.instance_variable_get(:@degrees_per_step)
+  def test_alternate_pin_names
+    short = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {dt: 3, clk: 4}
+    assert_equal 3, short.b.pin
+    assert_equal 4, short.a.pin
+
+    long = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data: 5, clock: 6}
+    assert_equal 5, long.b.pin
+    assert_equal 6, long.a.pin
+  end
+
+  def test_counts_per_revolution
+    assert_equal 60,      part.counts_per_revolution
+    assert_equal 6.to_f,  part.degrees_per_count
   end
-  
+
   def test_resets_on_initialize
-    assert_equal part.state, {steps: 0, angle: 0}
+    assert_equal({count: 0, angle: 0}, part.state)
+  end
+
+  def test_sets_debounce_time_for_both_pins
+    a_mock = Minitest::Mock.new.expect(:call, nil, [1])
+    b_mock = Minitest::Mock.new.expect(:call, nil, [1])
+
+    part.a.stub(:debounce_time=, a_mock) do
+      part.b.stub(:debounce_time=, b_mock) do
+        part.send(:run_after_initialize_cbs)
+      end
+    end
+    a_mock.verify
+    b_mock.verify
   end
-  
+
   def test_calls_listen_on_both_pins_with_given_divider
-    clock_mock = Minitest::Mock.new.expect(:call, nil, [1])
-    clock_mock.expect(:call, nil, [2])
-    data_mock = Minitest::Mock.new.expect(:call, nil, [1])
-    data_mock.expect(:call, nil, [2])
-    
-    part.clock.stub(:listen, clock_mock) do
-      part.data.stub(:listen, data_mock) do
-        part.send(:after_initialize)
-        part.send(:after_initialize, divider: 2)
+    a_mock = Minitest::Mock.new.expect(:call, nil, [1])
+    b_mock = Minitest::Mock.new.expect(:call, nil, [1])
+
+    part.a.stub(:listen, a_mock) do
+      part.b.stub(:listen, b_mock) do
+        part.send(:run_after_initialize_cbs)
       end
     end
+    a_mock.verify
+    b_mock.verify
   end
-  
+
   def test_observes_on_initialize
     mock = Minitest::Mock.new.expect(:call, nil)
     part.stub(:observe_pins, mock) do
-      part.send(:after_initialize)
+      part.send(:run_after_initialize_cbs)
     end
+    mock.verify
   end
-  
-  def test_observes_the_right_pin
-    refute_empty part.clock.callbacks
-    assert_empty part.data.callbacks
-        
-    part2 = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data:6, clock: 5}
-    
-    refute_empty part2.data.callbacks
-    assert_empty part2.clock.callbacks
-  end
-  
-  def test_goes_the_right_direction
-    part.data.send(:update, 1)
-    part.clock.send(:update, 1)
-    assert_equal({ steps: -1, angle: 348.0 }, part.state)
-    
-    part.reset
-    
-    part.data.send(:update, 1)
-    part.clock.send(:update, 0)
-    assert_equal({ steps: 1, angle: 12.0 }, part.state)
+
+  def test_observes_the_pins
+    part2 = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {b: 6, a: 5}
+    refute_empty part2.b.callbacks
+    refute_empty part2.a.callbacks
   end
 
   def test_reverse
     part.reverse
     assert part.reversed
 
-    part.data.send(:update, 1)
-    part.clock.send(:update, 1)
-    assert_equal({ steps: 1, angle: 12.0 }, part.state)
+    part.a.send(:update, 1)
+    part.b.send(:update, 1)
+    assert_equal({ count: 2, angle: 12.0 }, part.state)
   end
 
-  def test_swapped_pins
-    part2 = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data:4, clock: 3}
-
-    part2.clock.send(:update, 1)
-    part2.data.send(:update, 1)
-    assert_equal({ steps: 1, angle: 12.0 }, part2.state)
-  end
-  
-  def test_callback_prefilter
-    part.data.send(:update, 1)
-    part.clock.send(:update, 0)
+  def test_quadrature_decoding
+    part.b.send(:update, 0)
+    part.a.send(:update, 0)
     callback_value = nil
     part.add_callback do |value|
       callback_value = value.dup
     end
-    part.data.send(:update, 1)
-    part.clock.send(:update, 0)
-    
-    assert_equal({change: 1, steps: 2, angle: 24.0}, callback_value)
+
+    part.reset
+    part.a.send(:update, 1)
+    assert_equal({change: -1, count: -1, angle: 354.0}, callback_value)
+
+    part.b.send(:update, 1)
+    assert_equal({change: -1, count: -2, angle: 348.0}, callback_value)
+
+    part.a.send(:update, 0)
+    assert_equal({change: -1, count: -3, angle: 342.0}, callback_value)
+
+    part.b.send(:update, 0)
+    assert_equal({change: -1, count: -4, angle: 336.0}, callback_value)
+
+    part.b.send(:update, 1)
+    assert_equal({change: 1, count: -3, angle: 342.0}, callback_value)
+
+    part.a.send(:update, 1)
+    assert_equal({change: 1, count: -2, angle: 348.0}, callback_value)
+
+    part.b.send(:update, 0)
+    assert_equal({change: 1, count: -1, angle: 354.0}, callback_value)
+
+    part.a.send(:update, 0)
+    assert_equal({change: 1, count: 0, angle: 0.0}, callback_value)
   end
-  
+
   def test_update_state_removes_change
-    part.data.send(:update, 1)
-    part.clock.send(:update, 1)
+    part.b.send(:update, 1)
+    part.a.send(:update, 1)
     assert_nil part.state[:change]
   end
 end