denko 0.13.0

data/test/i2c/bus_test.rb

@@ -0,0 +1,66 @@
+require_relative '../test_helper'
+
+class I2CPeripheralBase
+  include Denko::I2C::Peripheral
+end
+
+class I2CBusTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    return @part if @part
+    @part = Denko::I2C::Bus.new(board: board, pin:5)
+    @part
+  end
+  
+  def peripheral
+    @peripheral ||= I2CPeripheralBase.new(bus: part, address: 0x30)
+  end
+
+  def test_initialize
+    assert_equal part.found_devices, []
+    refute_nil part.callbacks[:bus_controller]
+  end
+
+  def test_search
+    board.inject_read_for_pin(5, "48:50")
+
+    mock = MiniTest::Mock.new.expect :call, nil
+    board.stub(:i2c_search, mock) do
+      part.search
+    end
+    mock.verify
+
+    assert_equal part.found_devices, [0x30, 0x32]
+  end
+
+  def test_write
+    mock = MiniTest::Mock.new.expect :call, nil, [0x30, [0x01, 0x02], 100000, false]
+    board.stub(:i2c_write, mock) do
+      part.write 0x30, [0x01, 0x02]
+    end
+    mock.verify
+  end
+  
+  def test__read
+    board.inject_read_for_pin(5, "48-255,0,255,0,255,0")
+    
+    mock = MiniTest::Mock.new.expect :call, nil, [0x32, 0x03, 6, 100000, false]
+    board.stub(:i2c_read, mock) do
+      part.read 0x32, 0x03, 6
+    end
+    mock.verify
+  end
+  
+  def test_updates_peripherals
+    mock = MiniTest::Mock.new.expect :call, nil, [[255, 127]]
+    
+    peripheral.stub(:update, mock) do
+      part.send(:update, "48-255,127")
+      part.send(:update, "50-128,0")
+    end
+    mock.verify
+  end
+end

data/test/i2c/peripheral_test.rb

@@ -0,0 +1,50 @@
+require_relative '../test_helper'
+
+class I2CPeripheralBase
+  include Denko::I2C::Peripheral
+end
+
+class I2CPeripheralTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    return @bus if @bus
+    @bus = Denko::I2C::Bus.new(board: board, pin:5)
+    @bus
+  end
+  
+  def part
+    @part ||= I2CPeripheralBase.new(bus: bus, i2c_address: 0x30)
+  end
+    
+  def test_write_and_repeated_start
+    part.i2c_repeated_start = true
+    
+    mock = MiniTest::Mock.new.expect :call, nil, [0x30, [1,2], 100000, true]
+    bus.stub(:write, mock) do
+      part.i2c_write [1,2]
+    end
+  end
+
+  def test_frequency
+    part.i2c_frequency = 400000
+    
+    mock = MiniTest::Mock.new.expect :call, nil, [0x30, [1,2], 400000, false]
+    bus.stub(:write, mock) do
+      part.i2c_write [1,2]
+    end
+  end
+  
+  def test__read_and_repeated_start
+    part.i2c_repeated_start = true
+    
+    board.inject_read_for_component(part, 5, "48-127,127,127,127,127,127")
+    
+    mock = MiniTest::Mock.new.expect :call, nil, [0x30, 0x03, 6, 100000, true]
+    bus.stub(:read, mock) do
+      part.i2c_read(0x03, 6)
+    end
+  end
+end

data/test/led/base_test.rb

@@ -0,0 +1,24 @@
+require_relative '../test_helper'
+
+class BaseLEDTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::LED::Base.new(board: board, pin:1)
+  end
+
+  def test_led_new_creates_base_led
+    part = Denko::LED.new(board: board, pin:2)
+    assert_equal Denko::LED::Base, part.class
+  end
+
+  def test_blink_runs_in_thread
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:threaded_loop, mock) do
+      part.blink(0.5)
+    end
+    mock.verify
+  end
+end

data/test/led/rgb_test.rb

@@ -0,0 +1,64 @@
+require_relative '../test_helper'
+
+class RGBLEDTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def options
+    { board: board, pins: { red: 1, green: 2, blue: 3 } }
+  end
+
+  def part
+    @part ||= Denko::LED::RGB.new(options)
+  end
+
+  def test_proxies
+    assert_equal Denko::LED::Base, part.red.class
+    assert_equal Denko::LED::Base, part.green.class
+    assert_equal Denko::LED::Base, part.blue.class
+  end
+
+  def test_write
+    red_mock = MiniTest::Mock.new.expect :write, nil, [0]
+    green_mock = MiniTest::Mock.new.expect :write, nil, [128]
+    blue_mock = MiniTest::Mock.new.expect :write, nil, [0]
+
+    part.stub(:red, red_mock) do
+      part.stub(:green, green_mock) do
+        part.stub(:blue, blue_mock) do
+          part.write [0, 128, 0]
+        end
+      end
+    end
+    red_mock.verify
+    green_mock.verify
+    blue_mock.verify
+  end
+
+  def test_color_array
+    mock = MiniTest::Mock.new.expect :call, nil, [[128,0,0]]
+    part.stub(:write, mock) do
+      part.color = [128,0,0]
+    end
+    mock.verify
+  end
+
+  def test_color_names
+    colors = Denko::LED::RGB::COLORS
+
+    mock = MiniTest::Mock.new
+    colors.each_value do |color|
+      mock.expect :call, nil, [color]
+      mock.expect :call, nil, [color]
+    end
+
+    part.stub(:write, mock) do
+      colors.each_key do |key|
+        part.color = key
+        part.color = key.to_s
+      end
+    end
+    mock.verify
+  end
+end

data/test/led/seven_segment_test.rb

@@ -0,0 +1,86 @@
+require_relative '../test_helper'
+
+class SevenSegmentLEDTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def options
+    { board: board,
+      pins: {anode: 11, a: 12, b: 13, c: 3, d: 4, e: 5, f: 10, g: 9} }
+  end
+
+  def part
+    @part ||= Denko::LED::SevenSegment.new(options)
+  end
+
+  def test_proxies
+    segments = [:a, :b, :c, :d, :e, :f, :g]
+    segments.each do |segment|
+      assert_equal Denko::DigitalIO::Output, part.proxies[segment].class
+    end
+  end
+
+  def test_clears_during_initialize
+    # Avoid reusing pins which would raise a Board error.
+    def part.initialize_pins(options={}); end
+
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:clear, mock) do
+      part.send(:initialize, options)
+    end
+    mock.verify
+  end
+
+  def test_turns_on_during_initialize
+    # Avoid reusing pins which would raise a Board error.
+    def part.initialize_pins(options={}); end
+
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:on, mock) do
+      part.send(:initialize, options)
+    end
+    mock.verify
+  end
+
+  def test_on
+    mock = MiniTest::Mock.new.expect :high, nil
+    part.stub(:anode, mock) do
+      part.on
+    end
+    mock.verify
+  end
+
+  def test_off
+    mock = MiniTest::Mock.new.expect :low, nil
+    part.stub(:anode, mock) do
+      part.off
+    end
+    mock.verify
+  end
+
+  def test_scroll
+    mock = MiniTest::Mock.new.expect :call, nil, ['foo']
+    part.stub(:scroll, mock) do
+      part.display('foo')
+    end
+    mock.verify
+  end
+
+  def test_display_ensures_on
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:on, mock) do
+      part.display(1)
+    end
+    mock.verify
+  end
+
+  def test_display_clears_if_unknown_char
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:clear, mock) do
+      part.display('+')
+    end
+    mock.verify
+  end
+  # Test with cathode
+end

data/test/motor/servo_test.rb

@@ -0,0 +1,62 @@
+require_relative '../test_helper'
+
+class ServoMotorTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::Motor::Servo.new(board: board, pin:1, min: 0, max: 360)
+  end
+
+  def test_toggle_on_initialize
+    mock = MiniTest::Mock.new.expect(:call, nil, [1, :on], min: 544, max: 2400)
+    board.stub(:servo_toggle, mock) do
+      Denko::Motor::Servo.new(board: board, pin:1)
+    end
+    mock.verify
+  end
+
+  def test_attach
+    part
+    mock = MiniTest::Mock.new.expect(:call, nil, [1, :on], min: 0, max: 360)
+    board.stub(:servo_toggle, mock) { part.attach }
+    mock.verify
+  end
+
+  def test_detach
+    part
+    mock = MiniTest::Mock.new.expect(:call, nil, [1, :off])
+    board.stub(:servo_toggle, mock) { part.detach }
+    mock.verify
+  end
+
+  def test_position_modulo_180
+    part.position = 190
+    assert_equal 10, part.position
+    part.position = 180
+    assert_equal 180, part.position
+    part.position = 0
+    assert_equal 0, part.position
+    part.position = -1
+    assert_equal 179, part.position
+  end
+
+  def test_position_writes_mapped_microseconds_to_board
+    part
+    mock = MiniTest::Mock.new.expect(:call, nil, [1, 20])
+    board.stub(:servo_write, mock) do
+      part.position = 10
+    end
+    mock.verify
+  end
+
+  def test_speed_writes_mapped_microseconds_to_board
+    part
+    mock = MiniTest::Mock.new.expect(:call, nil, [1, 180])
+    board.stub(:servo_write, mock) do
+      part.speed = 0
+    end
+    mock.verify
+  end
+end

data/test/motor/stepper_test.rb

@@ -0,0 +1,51 @@
+require_relative '../test_helper'
+
+class StepperMotorTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::Motor::Stepper.new board: board,
+                                            pins: {step: 9, direction: 10}
+  end
+
+  def test_initialize
+    assert_equal Denko::DigitalIO::Output, part.step.class
+    assert_equal Denko::DigitalIO::Output, part.direction.class
+  end
+
+  def test_step_cw
+    dir_mock = MiniTest::Mock.new
+    dir_mock.expect :low?, false
+    dir_mock.expect :low, nil
+    step_mock = MiniTest::Mock.new
+    step_mock.expect :high, nil
+    step_mock.expect :low, nil
+
+    part.stub(:direction, dir_mock) do
+      part.stub(:step, step_mock) do
+        part.step_cw
+      end
+    end
+    dir_mock.verify
+    step_mock.verify
+  end
+
+  def test_step_cc
+    dir_mock = MiniTest::Mock.new
+    dir_mock.expect :high?, false
+    dir_mock.expect :high, nil
+    step_mock = MiniTest::Mock.new
+    step_mock.expect :high, nil
+    step_mock.expect :low, nil
+
+    part.stub(:direction, dir_mock) do
+      part.stub(:step, step_mock) do
+        part.step_cc
+      end
+    end
+    dir_mock.verify
+    step_mock.verify
+  end
+end

data/test/one_wire/bus_enumerator_test.rb

@@ -0,0 +1,134 @@
+require_relative '../test_helper'
+
+# State machine simulating a bus during address search. Initialize with
+# n devices with random addresses. Call #reset before each search.
+class BusSimulator
+  def initialize(device_count)
+    @devices = []
+    device_count.times do
+      rando = rand(2**56)
+      crc = Denko::OneWire::Helper.calculate_crc(rando)[0]
+      crc = crc << 56
+      rando = rando & crc
+      @devices << { rom: rando, in_search: true }
+    end
+    @devices = @devices.uniq
+    @index = -1
+  end
+
+  def addresses
+    @addresses ||= @devices.map { |d| d[:rom] }
+  end
+
+  def reset
+    @devices.each { |d| d[:in_search] = true }
+    @index = -1
+  end
+
+  def read_address_bit
+    bit = 1
+    @index = @index + 1
+    @devices.each do |d|
+      if d[:in_search]
+        bit = bit & d[:rom][@index]
+      end
+    end
+    bit
+  end
+
+  def read_complement_bit
+    bit = 1
+    @devices.each do |d|
+      if d[:in_search]
+        comp = d[:rom][@index] ^ 1
+        bit = bit & comp
+      end
+    end
+    bit
+  end
+
+  def write_bit(bit)
+    @devices.each do |d|
+      d[:in_search] = false unless d[:rom][@index] == bit
+    end
+  end
+end
+
+# Ruby version of the C++ functions running on the board.
+class BoardSimulator
+  def initialize(simulator)
+    @simulator = simulator
+  end
+
+  def reset
+    @simulator.reset
+  end
+
+  def search(branch_mask)
+    output_string = ""
+    (0..7).each do |i|
+      addr = 0
+      comp = 0
+      (0..7).each do |j|
+        # Read bit and complement from simulator.
+        addr_bit = @simulator.read_address_bit
+        comp_bit = @simulator.read_complement_bit
+
+        # Set them in variable.
+        addr = addr | (addr_bit * (2 ** j))
+        comp = comp | (comp_bit * (2 ** j))
+
+        # Override address bit to a 1 in variable if 1 in mask.
+        # Write whatever addr_bit ends up being back to the bus simulator.
+        if branch_mask[(i*8) + j] == 1
+          @simulator.write_bit(1)
+          addr = addr | (1 * (2 ** j))
+        else
+          @simulator.write_bit(addr_bit)
+        end
+      end
+
+      output_string << addr.to_s << "," << comp.to_s
+      output_string << "," if (i != 7 ) # No \n. Connection layer strips it IRL.
+    end
+    output_string
+  end
+end
+
+# Monkeypatch Bus and Helper to stub in simulations.
+module Denko
+  module OneWire
+    class BusStub < Bus
+      def read_power_supply
+        @parasite_power = false
+      end
+
+      def initialize(options={})
+        @board_sim = options[:board_sim]
+        super(options)
+      end
+
+      def _search(branch_mask)
+        @board_sim.reset
+        result = @board_sim.search(branch_mask)
+        # Manually call #update to simulate data recevieved from board.
+        self.update(result)
+      end
+    end
+  end
+end
+
+class OneWireEnumeratorTest < Minitest::Test
+  def test_find_all_addresses
+    # This gets slow with large number of devices.
+    bus_sim = BusSimulator.new(20)
+    board_sim = BoardSimulator.new(bus_sim)
+    bus = Denko::OneWire::BusStub.new board: BoardMock.new,
+                                     pin: 1,
+                                     board_sim: board_sim
+    bus.search
+
+    found_addresses = bus.found_devices.map { |d| d[:address] }
+    assert_equal found_addresses.sort, bus_sim.addresses.sort
+  end
+end

data/test/one_wire/bus_test.rb

@@ -0,0 +1,142 @@
+require_relative '../test_helper'
+
+class OneWireBusTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+  
+  def part
+    return @part if @part
+    # Respond with disabled parasite power.
+    board.inject_read_for_pin(1, "1")
+    @part ||= Denko::OneWire::Bus.new(board: board, pin: 1)
+  end
+
+  def test_initialize
+    board.inject_read_for_pin(2, "0")
+    bus2 = Denko::OneWire::Bus.new(board: board, pin: 2)
+    assert bus2.parasite_power
+  end
+
+  def test_read_power_supply_locks_mutex
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.mutex.stub(:synchronize, mock) do
+      part.read_power_supply
+    end
+    mock.verify
+  end
+
+  def test_read_power_supply
+    part
+
+    board.inject_read_for_component(part, 1, "1")
+    part.read_power_supply
+    refute part.parasite_power
+
+    board.inject_read_for_component(part, 1, "0")
+    part.read_power_supply
+    assert part.parasite_power
+  end
+
+  def test_read_power_supply_sends_board_commands
+    board_mock = MiniTest::Mock.new
+    board_mock.expect(:set_pin_mode, nil, [part.pin, :output])
+    board_mock.expect(:low, 0)
+    board_mock.expect(:digital_write,  nil, [part.pin, 0])
+    board_mock.expect(:one_wire_reset, nil, [part.pin, 0])
+    board_mock.expect(:one_wire_write, nil, [part.pin, false, [0xCC, 0xB4]])
+
+    # Stub the parasite power response from the board.
+    read_mock = MiniTest::Mock.new
+    read_mock.expect(:call, 0, [1])
+
+    part.stub(:board, board_mock) do
+      part.stub(:read, read_mock) do
+        part.read_power_supply
+      end
+    end
+
+    board_mock.verify
+    read_mock.verify
+    assert part.parasite_power
+  end
+
+  def test_device_present_in_mutex
+    # part.device_present calls #reset which expects a response. 
+    board.inject_read_for_component(part, 1, "1")
+
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.mutex.stub(:synchronize, mock) do
+      part.device_present
+    end
+    mock.verify
+  end
+
+  def test_set_device_present
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [1])
+    mock.expect(:call, nil, [1])
+    
+    part.stub(:reset, mock) do
+      # Give 0 for first reading, device present
+      board.inject_read_for_component(part, 1, "0")
+      assert part.device_present
+      
+      # Give 1 for second reading, no device
+      board.inject_read_for_component(part, 1,  "1")
+      refute part.device_present
+    end
+    mock.verify
+  end
+
+  def test_pre_callback_filter
+    assert_equal [255, 180, 120], part.pre_callback_filter("255,180,120")
+    assert_equal 127,             part.pre_callback_filter("127")
+  end
+
+  def test_reset
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [1, 1]
+    mock.expect :call, nil, [1, 0]
+
+    board.stub(:one_wire_reset, mock) do
+      part.reset(1)
+      part.reset
+    end
+    mock.verify
+  end
+  
+  def test__read
+    part
+    mock = MiniTest::Mock.new.expect :call, nil, [1, 4]
+    board.stub(:one_wire_read, mock) do
+      part._read(4)
+    end
+    mock.verify
+  end
+
+  def test_write
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [1, true,  [255, 177, 0x44]]
+    mock.expect :call, nil, [1, true,  [255, 177, 0x48]]
+    mock.expect :call, nil, [1, false, [255, 177, 0x55]]
+    mock.expect :call, nil, [1, false, [255, 177, 0x44]]
+    
+    board.stub(:one_wire_write, mock) do
+      # Parasite power on and parasite power functions.
+      part.instance_variable_set(:@parasite_power, true)
+      part.write [255, 177, 0x44]
+      part.write [255, 177, 0x48]
+      
+      # Parasite power on and not parasite power functions.
+      part.write [255, 177, 0x55]
+      
+      # Parasite power off and would-be parasite power function.
+      part.instance_variable_set(:@parasite_power, false)
+      part.write [255, 177, 0x44]
+    end
+    mock.verify
+  end
+end

data/test/one_wire/helper_test.rb

@@ -0,0 +1,18 @@
+require_relative '../test_helper'
+
+class OneWireHelper < Minitest::Test
+  
+  def test_with_valid_crc
+    assert Denko::OneWire::Helper.crc_check(18086456125349333800)
+    assert Denko::OneWire::Helper.crc_check([121, 117, 144, 185, 6, 165, 43, 26])
+  end
+  
+  def test_with_invalid_crc
+    refute Denko::OneWire::Helper.crc_check(18086456125349333801)
+  end
+  
+  def test_arbitrary_length_read
+    assert Denko::OneWire::Helper.crc_check([181, 1, 75, 70, 127, 255, 11, 16, 163])
+    refute Denko::OneWire::Helper.crc_check([181, 1, 75, 70, 127, 255, 11, 16, 164])
+  end
+end