denko 0.13.6 → 0.14.0

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

data/test/eeprom/built_in_test.rb

@@ -2,14 +2,14 @@ require_relative '../test_helper'
 
 class BoardMock < Denko::Board
   attr_reader :eeprom_stub
-  
+
   def eeprom_read(start_address, length)
     # Initialize a fake EEPROM
     @eeprom_stub ||= Array.new(eeprom_length){255}
-    
+
     # Pack it up like a string coming from the board.
     string = @eeprom_stub[start_address, length].map{ |x| x.to_s }.join(",")
-    
+
     # Update ourselves with it.
     self.update("254:#{start_address}-#{string}\n")
   end
@@ -27,7 +27,7 @@ class BuiltInEEPROMTest < Minitest::Test
   def part
     @part ||= board.eeprom
   end
-  
+
   def test_pin_ee
     assert_equal part.pin, 254
   end
@@ -35,14 +35,14 @@ class BuiltInEEPROMTest < Minitest::Test
   def test_loads_on_initialize_and_updates_correctly
     assert_equal part.state, Array.new(board.eeprom_length){255}
   end
-  
+
   def test_delegates_to_state_array
     mock = Minitest::Mock.new
     mock.expect(:[], 255, [0])
     mock.expect(:[]=, 128, [1, 128])
     mock.expect(:each, nil)
     mock.expect(:each_with_index, nil)
-    
+
     part.stub(:state, mock) do
       part[0]
       part[1] = 128
@@ -50,12 +50,12 @@ class BuiltInEEPROMTest < Minitest::Test
       part.each_with_index { |el| el }
     end
   end
-  
+
   def test_saves_to_the_board
     part[0] = 128
     part[part.length] = 127
     part.save
-    assert_equal board.eeprom_stub[0], 128
-    assert_equal board.eeprom_stub[board.eeprom_length], 127
+    assert_equal 128, board.eeprom_stub[0]
+    assert_equal 127, board.eeprom_stub[board.eeprom_length]
   end
 end

data/test/i2c/bus_test.rb

@@ -10,24 +10,30 @@ class I2CBusTest < Minitest::Test
   end
 
   def part
-    return @part if @part
-    @part = Denko::I2C::Bus.new(board: board, pin:5)
-    @part
+    @part ||= Denko::I2C::Bus.new(board: board)
   end
-  
+
   def peripheral
     @peripheral ||= I2CPeripheralBase.new(bus: part, address: 0x30)
   end
 
   def test_initialize
     assert_equal part.found_devices, []
+    assert_equal 0, part.i2c_index
     refute_nil part.callbacks[:bus_controller]
+
+    part2 = Denko::I2C::Bus.new(board: board, index: 10)
+    assert_equal 10, part2.i2c_index
+
+    part3 = Denko::I2C::Bus.new(board: board, i2c_index: 11)
+    assert_equal 11, part3.i2c_index
   end
 
   def test_search
-    board.inject_read_for_pin(5, "48:50")
+    # Reject 0s created by leading and trailing colons.
+    board.inject_read_for_i2c(0, ":48:50:")
 
-    mock = Minitest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil, [0]
     board.stub(:i2c_search, mock) do
       part.search
     end
@@ -37,26 +43,36 @@ class I2CBusTest < Minitest::Test
   end
 
   def test_write
-    mock = Minitest::Mock.new.expect :call, nil, [0x30, [0x01, 0x02], 100000, false]
+    mock = Minitest::Mock.new.expect :call, nil, [0, 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]
+
+  def test__read_string
+    board.inject_read_for_i2c(0, "48-255,0,255,0,255,0")
+
+    mock = Minitest::Mock.new.expect :call, nil, [0, 0x32, 0x03, 6, 100000, false]
+    board.stub(:i2c_read, mock) do
+      part.read 0x32, 0x03, 6
+    end
+    mock.verify
+  end
+
+  def test__read_array
+    board.inject_read_for_i2c(0, [48,255,0,255,0,255,0])
+
+    mock = Minitest::Mock.new.expect :call, nil, [0, 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")

data/test/i2c/peripheral_test.rb

@@ -2,6 +2,9 @@ require_relative '../test_helper'
 
 class I2CPeripheralBase
   include Denko::I2C::Peripheral
+  I2C_ADDRESS        = 0x30
+  I2C_FREQUENCY      = 400_000
+  I2C_REPEATED_START = true
 end
 
 class I2CPeripheralTest < Minitest::Test
@@ -10,41 +13,57 @@ class I2CPeripheralTest < Minitest::Test
   end
 
   def bus
-    return @bus if @bus
-    @bus = Denko::I2C::Bus.new(board: board, pin:5)
-    @bus
+    @bus ||= Denko::I2C::Bus.new(board: board, pin:5)
   end
-  
+
   def part
-    @part ||= I2CPeripheralBase.new(bus: bus, i2c_address: 0x30)
+    @part ||= I2CPeripheralBase.new(bus: bus)
+  end
+
+  def test_address
+    assert_equal 0x30, part.address
+    part2 = I2CPeripheralBase.new(bus: bus, address: 0x31)
+    assert_equal 0x31, part2.address
   end
-    
+
   def test_write_and_repeated_start
-    part.i2c_repeated_start = true
-    
-    mock = Minitest::Mock.new.expect :call, nil, [0x30, [1,2], 100000, true]
+    assert_equal true, part.i2c_repeated_start
+    mock = Minitest::Mock.new.expect :call, nil, [0x30, [1,2], 400_000, true]
+    bus.stub(:write, mock) do
+      part.i2c_write [1,2]
+    end
+
+    part.i2c_repeated_start = false
+    assert_equal false, part.i2c_repeated_start
+    mock = Minitest::Mock.new.expect :call, nil, [0x30, [1,2], 400_000, false]
     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]
+    assert_equal 400_000, part.i2c_frequency
+    mock = Minitest::Mock.new.expect :call, nil, [0x30, [1,2], 400_000, true]
+    bus.stub(:write, mock) do
+      part.i2c_write [1,2]
+    end
+
+    part.i2c_frequency = 100_000
+    assert_equal 100_000, part.i2c_frequency
+    mock = Minitest::Mock.new.expect :call, nil, [0x30, [1,2], 100_000, true]
     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]
+
+    mock = Minitest::Mock.new.expect :call, nil, [0x30, 0x03, 6, 400_000, true]
     bus.stub(:read, mock) do
-      part.i2c_read(0x03, 6)
+      part.i2c_read(6, register: 0x03)
     end
   end
 end

data/test/led/base_test.rb

@@ -14,11 +14,12 @@ class BaseLEDTest < Minitest::Test
     assert_equal Denko::LED::Base, part.class
   end
 
-  def test_blink_runs_in_thread
+  def test_blink_runs_in_thread_and_sets_ivar
     mock = Minitest::Mock.new.expect :call, nil
     part.stub(:threaded_loop, mock) do
       part.blink(0.5)
     end
     mock.verify
+    assert_equal 0.5, part.blink_interval
   end
 end

data/test/led/rgb_test.rb

@@ -27,7 +27,7 @@ class RGBLEDTest < Minitest::Test
     part.stub(:red, red_mock) do
       part.stub(:green, green_mock) do
         part.stub(:blue, blue_mock) do
-          part.write [0, 128, 0]
+          part.write(0, 128, 0)
         end
       end
     end
@@ -36,10 +36,10 @@ class RGBLEDTest < Minitest::Test
     blue_mock.verify
   end
 
-  def test_color_array
-    mock = Minitest::Mock.new.expect :call, nil, [[128,0,0]]
+  def test_raw_rgb_values
+    mock = Minitest::Mock.new.expect :call, nil, [128,0,0]
     part.stub(:write, mock) do
-      part.color = [128,0,0]
+      part.write(128,0,0)
     end
     mock.verify
   end
@@ -49,8 +49,8 @@ class RGBLEDTest < Minitest::Test
 
     mock = Minitest::Mock.new
     colors.each_value do |color|
-      mock.expect :call, nil, [color]
-      mock.expect :call, nil, [color]
+      mock.expect :call, nil, [*color]
+      mock.expect :call, nil, [*color]
     end
 
     part.stub(:write, mock) do

data/test/led/seven_segment_test.rb

@@ -87,13 +87,13 @@ class SevenSegmentLEDTest < Minitest::Test
     part.segments.each do 
       mocks << Minitest::Mock.new.expect(:call, nil, [1])
     end
-    part.segments[0].stub(:write, mocks[0]) do
-      part.segments[1].stub(:write, mocks[1]) do
-        part.segments[2].stub(:write, mocks[2]) do
-          part.segments[3].stub(:write, mocks[3]) do
-            part.segments[4].stub(:write, mocks[4]) do
-              part.segments[5].stub(:write, mocks[5]) do
-                part.segments[6].stub(:write, mocks[6]) do
+    part.segments[0].stub(:digital_write, mocks[0]) do
+      part.segments[1].stub(:digital_write, mocks[1]) do
+        part.segments[2].stub(:digital_write, mocks[2]) do
+          part.segments[3].stub(:digital_write, mocks[3]) do
+            part.segments[4].stub(:digital_write, mocks[4]) do
+              part.segments[5].stub(:digital_write, mocks[5]) do
+                part.segments[6].stub(:digital_write, mocks[6]) do
                   part.display('+')
                 end
               end

data/test/motor/servo_test.rb

@@ -10,7 +10,7 @@ class ServoMotorTest < Minitest::Test
   end
 
   def test_toggle_on_initialize
-    mock = Minitest::Mock.new.expect(:call, nil, [1, :on], min: 544, max: 2400)
+    mock = Minitest::Mock.new.expect(:call, nil, [1, :on], min: 500, max: 2500)
     board.stub(:servo_toggle, mock) do
       Denko::Motor::Servo.new(board: board, pin:1)
     end

data/test/motor/stepper_test.rb

@@ -32,7 +32,7 @@ class StepperMotorTest < Minitest::Test
     step_mock.verify
   end
 
-  def test_step_cc
+  def test_step_ccw
     dir_mock = Minitest::Mock.new
     dir_mock.expect :high?, false
     dir_mock.expect :high, nil
@@ -42,7 +42,7 @@ class StepperMotorTest < Minitest::Test
 
     part.stub(:direction, dir_mock) do
       part.stub(:step, step_mock) do
-        part.step_cc
+        part.step_ccw
       end
     end
     dir_mock.verify

data/test/one_wire/bus_test.rb

@@ -92,6 +92,7 @@ class OneWireBusTest < Minitest::Test
   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")
+    assert_equal [123, 111, 187], part.pre_callback_filter([123,111,187])
   end
 
   def test_reset

data/test/pulse_io/buzzer_test.rb

@@ -10,9 +10,12 @@ class BuzzerTest < Minitest::Test
   end
 
   def test_low_on_initialize
-    assert_equal part.state, board.low
+    mock = Minitest::Mock.new.expect :call, [part.pin]
+    board.stub(:no_tone, mock) do
+      part
+    end
   end
-  
+
   def test_tone
     mock = Minitest::Mock.new
     mock.expect :call, nil, [part.pin, 60, nil]
@@ -23,7 +26,7 @@ class BuzzerTest < Minitest::Test
     end
     mock.verify
   end
-  
+
   def test_no_tone
     part
     mock = Minitest::Mock.new
@@ -33,7 +36,7 @@ class BuzzerTest < Minitest::Test
     end
     mock.verify
   end
-  
+
   def stop
     mock = Minitest::Mock.new
     mock.expect :call, nil

data/test/pulse_io/{ir_transmitter_test.rb → ir_output_test.rb}

@@ -1,37 +1,37 @@
 require_relative '../test_helper'
 
-class IRTransmitterTest < Minitest::Test
+class IROutPutTest < Minitest::Test
   def board
     @board ||= BoardMock.new
   end
 
   def part
-    @part ||= Denko::PulseIO::IRTransmitter.new(board: board, pin:1)
+    @part ||= Denko::PulseIO::IROutput.new(board: board, pin:1)
   end
-  
+
   def test_pulse_count_validation
     assert_raises(ArgumentError) do
-      part.emit Array.new(257) { 0 }
+      part.write Array.new(256) { 0 }
     end
   end
-  
+
   def test_numeric_validation
     assert_raises(ArgumentError) do
-      part.emit ["a", "b", "c"]
+      part.write ["a", "b", "c"]
     end
   end
-  
+
   def test_pulse_length_validation
     assert_raises(ArgumentError) do
-      part.emit [65536]
+      part.write [65536]
     end
   end
-  
+
   def test_emits
     part
     mock = Minitest::Mock.new.expect(:call, nil, [1, 38, [127,0]])
     board.stub(:infrared_emit, mock) do
-      part.emit([127,0])
+      part.write([127,0])
     end
     mock.verify
   end