denko 0.14.0 → 0.15.0

data/test/i2c/peripheral_test.rb

@@ -56,10 +56,10 @@ class I2CPeripheralTest < Minitest::Test
     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")
+    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

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

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
 

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
@@ -98,21 +105,21 @@ class OneWireBusTest < Minitest::Test
   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
@@ -124,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/ir_output_test.rb

@@ -9,6 +9,11 @@ class IROutPutTest < Minitest::Test
     @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.write Array.new(256) { 0 }

data/test/pulse_io/pwm_output_test.rb

@@ -64,9 +64,9 @@ class PWMOutTest < Minitest::Test
     part
     mock = Minitest::Mock.new
     if (RUBY_VERSION.split(".")[0].to_i < 3)
-      mock.expect :call, nil, [14, :output_pwm], {frequency: 1000, resolution: 8}
+      mock.expect :call, nil, [14, :output_pwm], {frequency: 1000, :period=>1000000, resolution: 8}
     else
-      mock.expect :call, nil, [14, :output_pwm, {frequency: 1000, resolution: 8}]
+      mock.expect :call, nil, [14, :output_pwm, {frequency: 1000, :period=>1000000, resolution: 8}]
     end
 
     board.stub(:set_pin_mode, mock) do
@@ -74,16 +74,16 @@ class PWMOutTest < Minitest::Test
     end
     mock.verify
     assert_equal :output_pwm, part.mode
-    assert_equal true,        part.pwm_enabled
+    assert_equal true,        part.pwm_enabled?
   end
 
   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, resolution: 12}
+      mock.expect :call, nil, [6, :output_pwm], {frequency: 1000, :period=>1000000, resolution: 12}
     else
-      mock.expect :call, nil, [6, :output_pwm, {frequency: 1000, resolution: 12}]
+      mock.expect :call, nil, [6, :output_pwm, {frequency: 1000, :period=>1000000, resolution: 12}]
     end
 
     board.stub(:set_pin_mode, mock) do
@@ -91,16 +91,16 @@ class PWMOutTest < Minitest::Test
     end
     mock.verify
     assert_equal :output_pwm, part2.mode
-    assert_equal true,        part2.pwm_enabled
+    assert_equal true,        part2.pwm_enabled?
   end
 
   def test_pwm_enable_uses_arg_settings
     part
     mock = Minitest::Mock.new
     if (RUBY_VERSION.split(".")[0].to_i < 3)
-      mock.expect :call, nil, [14, :output_pwm], {frequency: 500, resolution: 14}
+      mock.expect :call, nil, [14, :output_pwm], {frequency: 500, :period=>2000000, resolution: 14}
     else
-      mock.expect :call, nil, [14, :output_pwm, {frequency: 500, resolution: 14}]
+      mock.expect :call, nil, [14, :output_pwm, {frequency: 500, :period=>2000000, resolution: 14}]
     end
 
     board.stub(:set_pin_mode, mock) do
@@ -108,7 +108,7 @@ class PWMOutTest < Minitest::Test
     end
     mock.verify
     assert_equal :output_pwm, part.mode
-    assert_equal true,        part.pwm_enabled
+    assert_equal true,        part.pwm_enabled?
     assert_equal 14,          part.resolution
     assert_equal 500,         part.frequency
     assert_equal (2**14-1),   part.pwm_high
@@ -123,6 +123,6 @@ class PWMOutTest < Minitest::Test
     end
     mock.verify
     assert_equal :output, part.mode
-    assert_equal false, part.pwm_enabled
+    assert_equal false, part.pwm_enabled?
   end
 end

data/test/rtc/ds3231_test.rb

@@ -34,10 +34,10 @@ class DS3231Test < Minitest::Test
   end
 
   def test_read
-    board.inject_read_for_i2c(0, "104-0,0,0,6,1,1,48")
+    board.inject_component_update(bus, "104-0,0,0,6,1,1,48")
 
     mock = Minitest::Mock.new.expect :call, nil, [part.address, 0x00, 7, 100000, false]
-    bus.stub(:_read, mock) do
+    bus.stub(:read_nb, mock) do
       part.time
     end
     mock.verify
@@ -45,6 +45,7 @@ class DS3231Test < Minitest::Test
 
   def test_pre_callback_filter
     mock = Minitest::Mock.new.expect :call, nil, [Time.new(2000, 1, 1, 0, 0, 0.0)]
+    part.read_nb
     part.stub(:update_state, mock) do
       bus.send(:update, "104-0,0,0,6,1,1,48")
     end

data/test/sensor/dht_test.rb

@@ -2,19 +2,19 @@ require_relative '../test_helper'
 
 class DHTTest < Minitest::Test
   PIN = 1
-  
+
   # Actual raw data from a sensor
   GOOD_STRING  = "14,82,77,57,26,52,26,57,26,51,32,51,26,57,26,52,72,57,26,67,72,57,26,51,27,56,72,52,77,52,77,51,26,57,72,67,26,52,26,57,26,52,26,57,26,51,31,52,26,57,72,67,26,52,26,56,72,57,26,52,26,57,72,52,77,51,72,67,72,57,72,51,32,51,26,57,26,52,72,57,72,56,72,47"
   GOOD_ARRAY   = [14, 82, 77, 57, 26, 52, 26, 57, 26, 51, 32, 51, 26, 57, 26, 52, 72, 57, 26, 67, 72, 57, 26, 51, 27, 56, 72, 52, 77, 52, 77, 51, 26, 57, 72, 67, 26, 52, 26, 57, 26, 52, 26, 57, 26, 51, 31, 52, 26, 57, 72, 67, 26, 52, 26, 56, 72, 57, 26, 52, 26, 57, 72, 52, 77, 51, 72, 67, 72, 57, 72, 51, 32, 51, 26, 57, 26, 52, 72, 57, 72, 56, 72, 47]
   SHORT_ARRAY  = [1,2,3,4,5,6]
-  
+
   # Make test data with a bad CRC byte (all 1s = 255).
   def bad_crc
     bad_crc = GOOD_ARRAY.dup
     (67..82).each { |i| bad_crc[i] = 56 }
     bad_crc
   end
-  
+
   def board
     @board ||= BoardMock.new
   end
@@ -22,17 +22,17 @@ class DHTTest < Minitest::Test
   def part
     @part ||= Denko::Sensor::DHT.new(board: board, pin:PIN)
   end
-  
+
   # It should tell the board to do a #pulse_read
   def test__read
     part
-    mock = Minitest::Mock.new.expect(:call, nil, [PIN], reset: board.low, reset_time: 20000, pulse_limit: 84, timeout: 100)
+    mock = Minitest::Mock.new.expect(:call, nil, [PIN], reset: board.low, reset_time: 10_000, pulse_limit: 84, timeout: 100)
     board.stub(:pulse_read, mock) do
-      part._read
+      part.read_nb
     end
     mock.verify
   end
-  
+
   # Callback pre filter should convert string of bytes to array and call #decode with it.
   def test_pre_callback_filter
     part
@@ -41,23 +41,23 @@ class DHTTest < Minitest::Test
       part.update(GOOD_STRING)
     end
   end
-  
+
   def test_decode
     # Error message in output if data is missing.
     result = part.decode(SHORT_ARRAY)
     assert result.keys.include? :error
     assert result[:error].match(/missing/i)
-    
+
     # Error message in output if bad CRC.
     result = part.decode(bad_crc)
     assert result.keys.include? :error
     assert result[:error].match(/crc/i)
-    
+
     # It should calculate output correctly.
     result = part.decode(GOOD_ARRAY)
     assert_equal result, {temperature: 29.5, humidity: 66.9}
   end
-  
+
   def test_crc
     refute part.crc(bad_crc)
   end

data/test/spi/bitbang_test.rb

@@ -0,0 +1,27 @@
+require_relative '../test_helper'
+
+class TempSpiPeripheral
+  include Denko::SPI::Peripheral
+end
+
+class SPIBitBangTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @bus ||= Denko::SPI::BitBang.new(board: board, pins: {mosi: 4, miso: 5, clock: 6})
+  end
+
+  def test_no_miso
+    no_miso = Denko::SPI::BitBang.new(board: board, pins: {mosi: 4, clock: 6})
+    refute no_miso.params[:pins][:input]
+    refute no_miso.pins[:input]
+  end
+
+  def test_no_mosi
+    no_mosi = Denko::SPI::BitBang.new(board: board, pins: {miso: 5, clock: 6})
+    refute no_mosi.params[:pins][:output]
+    refute no_mosi.pins[:output]
+  end
+end

data/test/spi/bus_test.rb

@@ -1,11 +1,7 @@
 require_relative '../test_helper'
 
 class TempSpiPeripheral
-  def initialize(pin)
-    @pin = pin
-  end
-
-  attr_reader :pin
+  include Denko::SPI::Peripheral
 end
 
 class SPIBusTest < Minitest::Test
@@ -20,6 +16,22 @@ class SPIBusTest < Minitest::Test
   PIN = 9
   OPTIONS = { read: 2, frequency: 800000, mode: 2, bit_order: :lsbfirst }
 
+  def test_automatically_adds_and_removes_component
+    obj = TempSpiPeripheral.new(bus: part, pin: 1)
+    assert part.components.include?(obj)
+
+    part.remove_component(obj)
+    refute part.components.include?(obj)
+  end
+
+  def test_unique_select_pins
+    TempSpiPeripheral.new(bus: part, pin: 1)
+
+    assert_raises do
+      TempSpiPeripheral.new(bus: part, pin: 1)
+    end
+  end
+
   def test_transfer
     mock = Minitest::Mock.new.expect :call, nil, [5, PIN], **OPTIONS
     board.stub(:spi_transfer, mock) do
@@ -36,7 +48,7 @@ class SPIBusTest < Minitest::Test
     mock.verify
   end
 
-  def test_stop
+  def test_stop_forwarded
     mock = Minitest::Mock.new.expect :call, nil, [PIN]
     board.stub(:spi_stop, mock) do
       part.stop(PIN)
@@ -44,33 +56,11 @@ class SPIBusTest < Minitest::Test
     mock.verify
   end
 
-  def test_add_and_remove_component
-    obj = TempSpiPeripheral.new(1)
-    part.add_component(obj)
-    assert board.components.include?(obj)
-
-    part.remove_component(obj)
-    refute board.components.include?(obj)
-  end
-
-  def test_set_pin_mode
+  def test_set_pin_mode_forwarded
     mock = Minitest::Mock.new.expect :call, nil, [9, :output]
     board.stub(:set_pin_mode, mock) do
       part.set_pin_mode(9, :output)
     end
     mock.verify
   end
-
-  def test_unique_select_pins
-    part.add_component TempSpiPeripheral.new(1)
-
-    assert_raises do
-      part.add_component TempSpiPeripheral.new(1)
-    end
-  end
-
-  def test_no_select_pin
-    part.add_component TempSpiPeripheral.new(nil)
-    assert_empty part.components
-  end
 end

data/test/spi/input_register_test.rb

@@ -130,10 +130,10 @@ class InputRegisterTest < Minitest::Test
     refute part.any_listening
   end
 
-  def test_gets_reads_through_pin
+  def test_gets_reads_through_select
     mock = Minitest::Mock.new.expect :call, nil, ["127,255"]
     part.stub(:update, mock) do
-      board.update("#{part.pin}:127,255")
+      board.update("#{part.select.pin}:127,255")
     end
     mock.verify
   end

data/test/spi/{peripheral_multi_pin_test.rb → peripheral_test.rb}

@@ -1,18 +1,22 @@
 require_relative '../test_helper'
 
-class SPITesterMulti
-  include Denko::SPI::Peripheral::MultiPin
+class SPITester
+  include Denko::SPI::Peripheral
 
   def initialize_pins(options={})
     super(options)
-    proxy_pin :other_pin, Denko::DigitalIO::Output, board: bus.board
+    proxy_pin :other_pin, Denko::DigitalIO::Output
   end
 
   def some_callback(data)
   end
 end
 
-class SPIPeripheralMultiPinTest < Minitest::Test
+class SPITesterSingle
+  include Denko::SPI::Peripheral
+end
+
+class SPIPeripheralTest < Minitest::Test
   def board
     @board ||= BoardMock.new
   end
@@ -26,7 +30,7 @@ class SPIPeripheralMultiPinTest < Minitest::Test
   end
 
   def part
-    @part ||= SPITesterMulti.new(options)
+    @part ||= SPITester.new(options)
   end
 
   def test_string_data_converts_to_bytes_for_callbacks
@@ -50,4 +54,20 @@ class SPIPeripheralMultiPinTest < Minitest::Test
     end
     mock.verify
   end
+
+  def test_allows_pin_alone
+    part2 = SPITesterSingle.new(bus: bus, pin: 5)
+    assert bus.components.include?(part2)
+  end
+
+  def test_subcomponents_attach_to_board_not_bus
+    part
+    assert board, part.select.board
+    assert board, part.other_pin.board
+  end
+
+  def test_added_to_bus
+    part
+    assert bus.components.include?(part)
+  end
 end