denko 0.13.0

data/test/board/core_test.rb

@@ -0,0 +1,182 @@
+require_relative '../test_helper'
+
+class BoardCoreTest < Minitest::Test
+  include TestPacker
+
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  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: 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_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_digital_write
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [Denko::Message.encode(command: 1, pin: 1, value: board.low)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 1, pin: 1, value: board.high)])
+
+    board.stub(:write, mock) do
+      board.digital_write 1, board.low
+      board.digital_write 1, board.high
+    end
+    mock.verify
+
+    assert_raises { board.digital_write 1, "wrong" }
+  end
+
+  def test_digital_read
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [Denko::Message.encode(command: 2, pin: 1)])
+
+    board.stub(:write, mock) do
+      board.digital_read 1
+    end
+    mock.verify
+  end
+
+  def test_pwm_write
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [Denko::Message.encode(command: 3, pin: 1, value: board.low)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 3, pin: 1, value: board.pwm_high)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 3, pin: 1, value: 128)])
+
+    board.stub(:write, mock) do
+      board.pwm_write 1, board.low
+      board.pwm_write 1, board.pwm_high
+      board.pwm_write 1, 128
+    end
+    mock.verify
+
+    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)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 4, pin: 1, value: board.dac_high)])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 4, pin: 1, value: 128)])
+
+    board.stub(:write, mock) do
+      board.dac_write 1, board.low
+      board.dac_write 1, board.dac_high
+      board.dac_write 1, 128
+    end
+    mock.verify
+
+    assert_raises { board.dac_write 1, "wrong" }
+  end
+
+  def test_analog_read
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [Denko::Message.encode(command: 5, pin: 1)])
+
+    board.stub(:write, mock) do
+      board.analog_read 1
+    end
+    mock.verify
+  end
+
+  def test_set_listener
+    mock = MiniTest::Mock.new
+
+    # \x00\x02 corresponds to the default digital divider of 4 (2^2).
+    # \x00\x04 corresponds to the default analog divider of 16 (2^4).
+    mock.expect(:call, nil, [Denko::Message.encode(command: 6, pin: 1, value: 0, aux_message: "\x00\x02")])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 6, pin: 1, value: 0, aux_message: "\x01\x04")])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 6, pin: 1, value: 1, aux_message: "\x01\x04")])
+    mock.expect(:call, nil, [Denko::Message.encode(command: 6, pin: 1, value: 1, aux_message: "\x01\x00")])
+
+    board.stub(:write, mock) do
+      board.set_listener(1, :off)
+      board.set_listener(1, :off, mode: :analog)
+      board.set_listener(1, :on, mode: :analog)
+      board.set_listener(1, :on, mode: :analog, divider: 1)
+    end
+    mock.verify
+
+    assert_raises { board.set_listener 1, :on, mode: "wrong" }
+    assert_raises { board.set_listener 1, :on, divider: 256 }
+  end
+
+  def test_digital_listen
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [1, :on], mode: :digital, divider: 4)
+
+    board.stub(:set_listener, mock) do
+      board.digital_listen(1)
+    end
+  end
+
+  def test_analog_listen
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [1, :on], mode: :analog, divider: 16)
+
+    board.stub(:set_listener, mock) do
+      board.analog_listen(1)
+    end
+  end
+
+  def test_stop_listener
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [1, :off])
+
+    board.stub(:set_listener, mock) do
+      board.stop_listener(1)
+    end
+  end
+
+  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)])
+
+    board.stub(:write, mock) do
+      board.analog_write_resolution = 10
+      board.analog_read_resolution = 10
+    end
+    mock.verify
+
+    assert_raises { board.analog_write_resolution= 17      }
+    assert_raises { board.analog_read_resolution= 17       }
+    assert_raises { board.analog_write_resolution= "wrong" }
+    assert_raises { board.analog_read_resolution= "wrong"  }
+  end
+
+  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") }  
+  end
+end

data/test/board/eeprom_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+
+class BoardEEPROMTest < Minitest::Test
+  include TestPacker
+
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  def test_eeprom_read
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [(Denko::Message.encode command: 7, value: 16, aux_message: pack(:uint16, 15))]
+
+    board.stub(:write, mock) do
+      board.eeprom_read(15, 16)
+    end
+    mock.verify
+  end
+
+  def test_eeprom_write
+    data = (1..16).to_a
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [(Denko::Message.encode command: 8, value: data.length, aux_message: pack(:uint16, 15) + pack(:uint8, data))]
+
+    board.stub(:write, mock) do
+      board.eeprom_write(15, data)
+    end
+    mock.verify
+  end
+end

data/test/board/helper_test.rb

@@ -0,0 +1,38 @@
+# encoding: ascii-8bit
+# For convenience when validating longer data types.
+
+require_relative '../test_helper'
+
+class APIHelperTest < Minitest::Test
+  include TestPacker
+
+  def test_single_integers
+    assert_equal pack(:uint8, 25), "\x19"
+  end
+  
+  def test_other_formats
+    assert_equal pack(:uint16, 5*10**4),  "P\xC3"
+    assert_equal pack(:uint32, 4*10**9),  "\x00(k\xEE"
+    assert_equal pack(:uint64, 9*10**18), "\x00\x00\x84\xE2Pl\xE6|"
+  end
+  
+  def test_array
+    assert_equal pack(:uint8, [25,26]), "\x19\x1A"
+  end
+  
+  def test_padding
+    assert_equal pack(:uint8, 25, pad: 2), "\x19\x00"
+  end
+  
+  def test_min
+    assert_raises(ArgumentError) { pack(:uint8, 25, min: 2) }
+  end
+  
+  def test_max
+    assert_raises(ArgumentError) { pack(:uint8, [25,26,27], max: 2) }
+  end
+  
+  def test_invalid_formats
+    assert_raises(ArgumentError) { pack(:uint128, 25) }
+  end
+end

data/test/board/i2c_test.rb

@@ -0,0 +1,114 @@
+require_relative '../test_helper'
+
+class APII2CTest < Minitest::Test
+  include TestPacker
+  
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  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
+    end
+    mock.verify
+  end
+
+  def test_write
+    board
+    aux = pack(:uint8, 0x00) + pack(:uint8, [1,2,3,4])
+    address = 0x30
+      
+    # Normal
+    message1 = Denko::Message.encode command: 34, pin: address | (1 << 7), value: 4, aux_message: aux
+    # Repeated start
+    message2 = Denko::Message.encode command: 34, pin: address | (0 << 7), value: 4, aux_message: aux
+
+    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)
+    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}) }
+  end
+
+  def test_read
+    board
+    aux = pack(:uint8, 0x00) + pack(:uint8, [1, 0x03])
+    # Normal
+    message1 = Denko::Message.encode command: 35, pin: 0x30 | (1 << 7), value: 4, aux_message: aux
+    # Repeated start
+    message2 = Denko::Message.encode command: 35, pin: 0x30 | (0 << 7), value: 4, aux_message: aux
+
+    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)
+    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
+
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [message]
+    
+    connection.stub(:write, mock) do
+      board.i2c_read(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)  }
+  end
+
+  def test_frequencies
+    board
+    data = [1,2,3,4]
+    address = 0x30
+      
+    messages = []
+    # 100 kHz, 400 kHz, 1 Mhz, 3.4 MHz
+    [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))
+    end
+
+    mock = MiniTest::Mock.new
+    messages.each do |message|
+      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)
+    end
+    mock.verify
+
+    assert_raises(ArgumentError) { board.i2c_write(0x30, [1,2,3,4], 5000000, false) }
+  end
+end

data/test/board/infrared_test.rb

@@ -0,0 +1,37 @@
+require_relative '../test_helper'
+
+class APIInfraredTest < Minitest::Test
+  include TestPacker
+  
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+  
+  def test_infrared_emit
+    board
+    aux = pack(:uint8, 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]
+    connection.stub(:write, mock) do
+      board.infrared_emit 8, 38, [255,0,255,0]
+    end
+    mock.verify
+  end
+  
+  def test_minimum_pulses
+    assert_raises(ArgumentError) do
+      board.infrared_emit 8, 38, []
+    end
+  end
+  
+  def test_maximum_pulses
+    assert_raises(ArgumentError) do 
+      board.infrared_emit 8, 38, Array.new(513) { 128 }
+    end
+  end
+end

data/test/board/message_test.rb

@@ -0,0 +1,54 @@
+require_relative '../test_helper'
+
+class MessageTest < Minitest::Test
+  def test_require_a_command
+    assert_raises(ArgumentError) { Denko::Message.encode }
+    assert_instance_of String, Denko::Message.encode(command: 90)
+  end
+
+  def test_require_command_in_correct_range
+    assert_raises(ArgumentError) { Denko::Message.encode command: -1 }
+    assert_raises(ArgumentError) { Denko::Message.encode command: 256 }
+    assert_raises(ArgumentError) { Denko::Message.encode command: 42.2 }
+  end
+
+  def test_require_pin_in_correct_range
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, pin: -1 }
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, pin: 256 }
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, pin: 42.2 }
+  end
+
+  def test_require_value_in_correct_range
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, value: -1 }
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, value: 10000 }
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, value: 42.2 }
+  end
+
+  def test_validates_aux_message_length
+    too_big_message = Array.new(529) { "a" }.join 
+    assert_raises(ArgumentError) { Denko::Message.encode command: 0, value: 0, aux_message: too_big_message }
+  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")
+  end
+
+  def test_escape_newline_in_aux
+    assert_equal  "1...line1\\\nline2\\\n\n",
+                  Denko::Message.encode(command: 1, 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\\")
+  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")
+  end
+end

data/test/board/one_wire_test.rb

@@ -0,0 +1,69 @@
+require_relative '../test_helper'
+
+class APIOneWireTest < Minitest::Test
+  include TestPacker
+  
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+  
+  def test_one_wire_reset
+    board
+    message = Denko::Message.encode command: 41, pin: 1, value: 255
+    
+    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    connection.stub(:write, mock) do
+      board.one_wire_reset(1, 255)
+    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]
+    connection.stub(:write, mock) do
+      board.one_wire_write(1, true, [1,2,3])
+      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 
+      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)
+    end
+    mock.verify
+  end
+end

data/test/board/pulse_test.rb

@@ -0,0 +1,51 @@
+require_relative '../test_helper'
+
+class BoardPulseTest < Minitest::Test
+  include TestPacker
+
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  def test_pulse_read
+    # Default settings
+    mock = MiniTest::Mock.new
+    aux = pack(:uint16, [0, 200]) << pack(:uint8, 100)
+    message = Denko::Message.encode command: 9, pin: 4, value: 0b00, aux_message: aux
+    
+    mock.expect :call, nil, [message]
+    board.stub(:write, mock) do
+      board.pulse_read(4)
+    end
+    mock.verify
+    
+    # Good options
+    mock = MiniTest::Mock.new
+    aux = pack(:uint16, [1000, 200]) << pack(:uint8, 160)
+    message1 = Denko::Message.encode command: 9, pin: 4, value: 0b01, aux_message: aux
+    message2 = Denko::Message.encode command: 9, pin: 4, value: 0b11, aux_message: aux
+    
+    mock.expect :call, nil, [message1]
+    mock.expect :call, nil, [message2]
+    board.stub(:write, mock) do
+      board.pulse_read(4, reset: board.low, reset_time: 1000, timeout: 200, pulse_limit: 160)
+      board.pulse_read(4, reset: board.high, reset_time: 1000, timeout: 200, pulse_limit: 160)
+    end
+    mock.verify
+    
+    # Bad options
+    assert_raises(ArgumentError) { board.pulse_read(4, reset_time: 65536)  }
+    assert_raises(ArgumentError) { board.pulse_read(4, reset_time: -1)     }
+    assert_raises(ArgumentError) { board.pulse_read(4, reset_time: "bad")  }
+    assert_raises(ArgumentError) { board.pulse_read(4, timeout: 65536)     }
+    assert_raises(ArgumentError) { board.pulse_read(4, timeout: -1)        }
+    assert_raises(ArgumentError) { board.pulse_read(4, timeout: "bad")     }
+    assert_raises(ArgumentError) { board.pulse_read(4, pulse_limit: 256)   }
+    assert_raises(ArgumentError) { board.pulse_read(4, pulse_limit: -1)    }    
+    assert_raises(ArgumentError) { board.pulse_read(4, pulse_limit: "bad") }
+  end
+end

data/test/board/servo_test.rb

@@ -0,0 +1,47 @@
+require_relative '../test_helper'
+
+class APIServoTest < Minitest::Test
+  include TestPacker
+  
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  def test_on_off
+    mock = MiniTest::Mock.new
+    aux = pack :uint16, [544, 2400]
+    mock.expect :call, nil, [Denko::Message.encode(command: 10, pin: 9, value: 1, aux_message: aux)]
+    mock.expect :call, nil, [Denko::Message.encode(command: 10, pin: 9, value: 0, aux_message: aux)]
+
+    board.stub(:write, mock) do
+      board.servo_toggle(9, :on)
+      board.servo_toggle(9)
+    end
+    mock.verify
+  end
+
+  def test_min_max
+    mock = MiniTest::Mock.new
+    aux = pack :uint16, [360, 2100]
+    mock.expect :call, nil, [Denko::Message.encode(command: 10, pin: 9, value: 1, aux_message: aux)]
+
+    board.stub(:write, mock) do
+      board.servo_toggle(9, :on, min: 360, max: 2100)
+    end
+    mock.verify
+  end
+  
+  def test_write
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [Denko::Message.encode(command: 11, pin: 9, aux_message: pack(:uint16, 180))]
+
+    board.stub(:write, mock) do
+      board.servo_write(9, 180)
+    end
+    mock.verify
+  end
+end