denko 0.13.6 → 0.15.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
+
+  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]
+
+    board.inject_component_update(part, "48-127,127,127,127,127,127")
+
+    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/apa102_test.rb

@@ -0,0 +1,24 @@
+require_relative '../test_helper'
+
+class APA102Test < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    @bus ||= Denko::SPI::Bus.new(board: board)
+  end
+
+  def options
+    { bus: bus }
+  end
+
+  def part
+    @part ||= Denko::LED::APA102.new(options)
+  end
+
+  def test_added_to_bus_components
+    part
+    assert bus.components.include?(part)
+  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

@@ -20,14 +20,14 @@ class RGBLEDTest < Minitest::Test
   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]
+    red_mock = Minitest::Mock.new.expect :duty=, nil, [0]
+    green_mock = Minitest::Mock.new.expect :duty=, nil, [50]
+    blue_mock = Minitest::Mock.new.expect :duty=, 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]
+          part.write(0, 50, 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/{stepper_test.rb → a3967_test.rb}

@@ -1,12 +1,12 @@
 require_relative '../test_helper'
 
-class StepperMotorTest < Minitest::Test
+class A3967MotorTest < Minitest::Test
   def board
     @board ||= BoardMock.new
   end
 
   def part
-    @part ||= Denko::Motor::Stepper.new board: board,
+    @part ||= Denko::Motor::A3967.new board: board,
                                             pins: {step: 9, direction: 10}
   end
 
@@ -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/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/one_wire/bus_enumerator_test.rb

@@ -65,7 +65,7 @@ class BoardSimulator
   end
 
   def search(branch_mask)
-    output_string = ""
+    output_string = String.new
     (0..7).each do |i|
       addr = 0
       comp = 0

data/test/one_wire/bus_test.rb

@@ -4,7 +4,7 @@ class OneWireBusTest < Minitest::Test
   def board
     @board ||= BoardMock.new
   end
-  
+
   def part
     return @part if @part
     # Respond with disabled parasite power.
@@ -18,24 +18,25 @@ class OneWireBusTest < Minitest::Test
     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
+  def test_read_power_supply
+    board.inject_component_update(part, "0")
+
+    lock_mock = Minitest::Mock.new.expect(:call, nil)
+    unlock_mock = Minitest::Mock.new.expect(:call, nil)
+
+    part.mutex.stub(:lock, lock_mock) do
+      part.mutex.stub(:unlock, unlock_mock) do
+        part.read_power_supply
+      end
     end
-    mock.verify
-  end
 
-  def test_read_power_supply
-    part
+    lock_mock.verify
+    unlock_mock.verify
+    assert part.parasite_power
 
-    board.inject_read_for_component(part, 1, "1")
+    board.inject_component_update(part, "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
@@ -43,7 +44,7 @@ class OneWireBusTest < Minitest::Test
     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_reset, nil, [part.pin, false])
     board_mock.expect(:one_wire_write, nil, [part.pin, false, [0xCC, 0xB4]])
 
     # Stub the parasite power response from the board.
@@ -62,28 +63,34 @@ class OneWireBusTest < Minitest::Test
   end
 
   def test_device_present_in_mutex
-    # part.device_present calls #reset which expects a response. 
-    board.inject_read_for_component(part, 1, "1")
+    # part.device_present calls #reset which expects a response.
+    board.inject_component_update(part, "1")
+
+    lock_mock = Minitest::Mock.new.expect(:call, nil)
+    unlock_mock = Minitest::Mock.new.expect(:call, nil)
 
-    mock = Minitest::Mock.new.expect(:call, nil)
-    part.mutex.stub(:synchronize, mock) do
-      part.device_present
+    part.mutex.stub(:lock, lock_mock) do
+      part.mutex.stub(:unlock, unlock_mock) do
+        part.device_present
+      end
     end
-    mock.verify
+
+    lock_mock.verify
+    unlock_mock.verify
   end
 
   def test_set_device_present
     mock = Minitest::Mock.new
-    mock.expect(:call, nil, [1])
-    mock.expect(:call, nil, [1])
-    
+    mock.expect(:call, nil, [true])
+    mock.expect(:call, nil, [true])
+
     part.stub(:reset, mock) do
       # Give 0 for first reading, device present
-      board.inject_read_for_component(part, 1, "0")
+      board.inject_component_update(part, "0")
       assert part.device_present
-      
+
       # Give 1 for second reading, no device
-      board.inject_read_for_component(part, 1,  "1")
+      board.inject_component_update(part, "1")
       refute part.device_present
     end
     mock.verify
@@ -92,26 +99,27 @@ 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
     part
     mock = Minitest::Mock.new
-    mock.expect :call, nil, [1, 1]
-    mock.expect :call, nil, [1, 0]
+    mock.expect :call, nil, [1, true]
+    mock.expect :call, nil, [1, false]
 
     board.stub(:one_wire_reset, mock) do
-      part.reset(1)
+      part.reset(true)
       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)
+      part.read_nb(4)
     end
     mock.verify
   end
@@ -123,16 +131,16 @@ class OneWireBusTest < Minitest::Test
     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]

data/test/one_wire/peripheral_test.rb

@@ -90,10 +90,7 @@ class OneWirePeripheralTest < Minitest::Test
   end
 
   def test_read_scratch_is_atomic
-    # Pre-initialize the bus. 
-    bus
-    # Will read 9 bytes.
-    board.inject_read_for_component(bus, 1, "255,255,255,255,255,255,255,255")
+    board.inject_component_update(bus, "255,255,255,255,255,255,255,255")
 
     mock = Minitest::Mock.new.expect(:call, nil)
     part.stub(:atomically, mock) { part.read_scratch(9) }
@@ -101,10 +98,7 @@ class OneWirePeripheralTest < Minitest::Test
   end
 
   def test_read_scratch_matches_first
-    # Pre-initialize the bus. 
-    bus
-    # Will read 9 bytes.
-    board.inject_read_for_component(bus, 1, "255,255,255,255,255,255,255,255")
+    board.inject_component_update(bus, "255,255,255,255,255,255,255,255")
 
     mock = Minitest::Mock.new.expect(:call, nil)
     part.stub(:match, mock) { part.read_scratch(9) }
@@ -112,10 +106,7 @@ class OneWirePeripheralTest < Minitest::Test
   end
 
   def test_read_scratch_sends_the_command
-    # Pre-initialize the bus. 
-    bus
-    # Will read 9 bytes.
-    board.inject_read_for_component(bus, 1, "255,255,255,255,255,255,255,255")
+    board.inject_component_update(bus, "255,255,255,255,255,255,255,255")
 
     mock = Minitest::Mock.new
     mock.expect(:call, nil, [0xCC])
@@ -125,16 +116,13 @@ class OneWirePeripheralTest < Minitest::Test
   end
 
   def test_read_scratch_reads_bytes_from_bus
-    # Pre-initialize the bus. 
-    bus
-    # Will read 9 bytes.
-    board.inject_read_for_component(bus, 1, "255,255,255,255,255,255,255,255")
+    board.inject_component_update(bus, "255,255,255,255,255,255,255,255")
 
     mock = Minitest::Mock.new.expect(:call, nil, [9])
     bus.stub(:read, mock) { part.read_scratch(9) }
     mock.verify
   end
-  
+
   def test_write_scratch_is_atomic
     mock = Minitest::Mock.new.expect(:call, nil)
     part.stub(:atomically, mock) { part.write_scratch(1) }

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,42 @@
 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_does_not_set_pin_mode
+    refute part.params[:mode]
+    refute part.mode
+  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

data/test/pulse_io/pwm_output_test.rb

@@ -8,12 +8,34 @@ class PWMOutTest < Minitest::Test
   def part
     @part ||= Denko::PulseIO::PWMOutput.new(board: board, pin: 14)
   end
-  
+
+  def part2
+    @part2 ||= Denko::PulseIO::PWMOutput.new(board: board, pin: 6, frequency: 1000, resolution: 12)
+  end
+
+  def test_initialize_stores_settings
+    assert_equal 12,        part2.resolution
+    assert_equal 1000,      part2.frequency
+    assert_equal (2**12-1), part2.pwm_high
+  end
+
+  def test_duty
+    mock = Minitest::Mock.new
+    mock.expect :call, nil, [14, 0]
+    mock.expect :call, nil, [14, 128]
+    mock.expect :call, nil, [14, 255]
+    board.stub(:pwm_write, mock) do
+      part.duty = 0
+      part.duty = 50
+      part.duty = 100
+    end
+  end
+
   def test_pwm_write
     enable_mock = Minitest::Mock.new.expect :call, nil
     write_mock = Minitest::Mock.new
     write_mock.expect :call, nil, [14, 128]
-  
+
     board.stub(:pwm_write, write_mock) do
       part.stub(:pwm_enable, enable_mock) do
         assert_equal :output, part.mode
@@ -21,7 +43,7 @@ class PWMOutTest < Minitest::Test
         assert_equal 128, part.state
       end
     end
-    
+
     part.pwm_write(64)
     assert_equal 64, part.state
     assert_equal :output_pwm, part.mode
@@ -30,35 +52,68 @@ class PWMOutTest < Minitest::Test
     enable_mock.verify
   end
 
-  def test_write_uses_digital_write_at_limits
+  def test_write_uses_board_pwm_write_always
+    mock = Minitest::Mock.new.expect :call, nil, [14, 128]
+    board.stub(:pwm_write, mock) do
+      part.write(128)
+    end
+    mock.verify
+  end
+
+  def test_pwm_enable
+    part
     mock = Minitest::Mock.new
-    mock.expect :call, nil, [board.high]
-    mock.expect :call, nil, [board.low]
-    part.stub(:digital_write, mock) do
-      part.write(board.pwm_high)
-      part.write(board.low)
+    if (RUBY_VERSION.split(".")[0].to_i < 3)
+      mock.expect :call, nil, [14, :output_pwm], {frequency: 1000, :period=>1000000, resolution: 8}
+    else
+      mock.expect :call, nil, [14, :output_pwm, {frequency: 1000, :period=>1000000, resolution: 8}]
+    end
+
+    board.stub(:set_pin_mode, mock) do
+      part.pwm_enable
     end
     mock.verify
+    assert_equal :output_pwm, part.mode
+    assert_equal true,        part.pwm_enabled?
   end
 
-  def test_write_uses_analog_write_between_limits
-    mock = Minitest::Mock.new.expect :call, nil, [128]
-    part.stub(:pwm_write, mock) do
-      part.write(128)
+  def test_pwm_enable_uses_stored_settings
+    part2
+    mock = Minitest::Mock.new
+    if (RUBY_VERSION.split(".")[0].to_i < 3)
+      mock.expect :call, nil, [6, :output_pwm], {frequency: 1000, :period=>1000000, resolution: 12}
+    else
+      mock.expect :call, nil, [6, :output_pwm, {frequency: 1000, :period=>1000000, resolution: 12}]
+    end
+
+    board.stub(:set_pin_mode, mock) do
+      part2.pwm_enable
     end
     mock.verify
+    assert_equal :output_pwm, part2.mode
+    assert_equal true,        part2.pwm_enabled?
   end
-  
-  def test_pwm_enable
+
+  def test_pwm_enable_uses_arg_settings
     part
-    mock = Minitest::Mock.new.expect :call, nil, [14, :output_pwm]
+    mock = Minitest::Mock.new
+    if (RUBY_VERSION.split(".")[0].to_i < 3)
+      mock.expect :call, nil, [14, :output_pwm], {frequency: 500, :period=>2000000, resolution: 14}
+    else
+      mock.expect :call, nil, [14, :output_pwm, {frequency: 500, :period=>2000000, resolution: 14}]
+    end
+
     board.stub(:set_pin_mode, mock) do
-      part.pwm_enable
+      part.pwm_enable(frequency: 500, resolution: 14)
     end
     mock.verify
     assert_equal :output_pwm, part.mode
+    assert_equal true,        part.pwm_enabled?
+    assert_equal 14,          part.resolution
+    assert_equal 500,         part.frequency
+    assert_equal (2**14-1),   part.pwm_high
   end
-    
+
   def test_pwm_disable
     part.pwm_enable
     mock = Minitest::Mock.new
@@ -68,5 +123,6 @@ class PWMOutTest < Minitest::Test
     end
     mock.verify
     assert_equal :output, part.mode
+    assert_equal false, part.pwm_enabled?
   end
 end