denko 0.13.6 → 0.15.0

data/test/rtc/ds3231_test.rb

@@ -6,47 +6,46 @@ class DS3231Test < 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)
   end
-  
+
   def part
-    @part ||= Denko::RTC::DS3231.new(bus: bus, address: 0x68)
+    @part ||= Denko::RTC::DS3231.new(bus: bus)
   end
-  
+
   def test_time_to_bcd
     time = Time.new(2000, 1, 1, 0, 0, 0.0)
     bytes = part.time_to_bcd(time)
     assert_equal bytes, [0, 0, 0, 6, 1, 1, 48]
   end
-  
+
   def test_bcd_to_time
     bytes = [0, 0, 0, 6, 1, 1, 48]
     time = part.bcd_to_time(bytes)
     assert_equal time, Time.new(2000, 1, 1, 0, 0, 0.0)
   end
-  
+
   def test_time=
-    mock = Minitest::Mock.new.expect :call, nil, [[0, [0, 0, 0, 6, 1, 1, 48]]]
+    mock = Minitest::Mock.new.expect :call, nil, [[0, 0, 0, 0, 6, 1, 1, 48]]
     part.stub(:i2c_write, mock) do
       part.time = Time.new(2000, 1, 1, 0, 0, 0.0)
     end
     mock.verify
   end
-  
+
   def test_read
-    board.inject_read_for_component(part, 5, "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
   end
-  
+
   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, {celsius: 29.5, fahrenheit: 85.1, humidity: 66.9}
+    assert_equal result, {temperature: 29.5, humidity: 66.9}
   end
-  
+
   def test_crc
     refute part.crc(bad_crc)
   end

data/test/sensor/ds18b20_test.rb

@@ -17,14 +17,10 @@ class DS18B20Test < Minitest::Test
   end
 
   def test_decode_temperatures
-    assert_equal({ celsius: 125, fahrenheit: 257 },
-                 part.decode_temperature([0b1101_0000,0b0000_0111]))
-    assert_equal({ celsius: 0, fahrenheit: 32 },
-                 part.decode_temperature([0b0000_0000,0b0000_0000]))
-    assert_equal({ celsius: -10.125, fahrenheit: 13.775 },
-                 part.decode_temperature([0b0101_1110,0b1111_1111]))
-    assert_equal({ celsius: -55, fahrenheit: -67 },
-                 part.decode_temperature([0b1001_0000,0b1111_1100]))
+    assert_equal 125,     part.decode_temperature([0b1101_0000,0b0000_0111])
+    assert_equal   0,     part.decode_temperature([0b0000_0000,0b0000_0000])
+    assert_equal -10.125, part.decode_temperature([0b0101_1110,0b1111_1111])
+    assert_equal -55,     part.decode_temperature([0b1001_0000,0b1111_1100])
   end
 
   def test_decode_resolution

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
@@ -14,29 +10,45 @@ class SPIBusTest < Minitest::Test
   end
 
   def part
-    @bus ||= Denko::SPI::Bus.new(board: board)
+    @bus ||= Denko::SPI::Bus.new(board: board, index: 5)
   end
 
   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, [PIN], **OPTIONS
+    mock = Minitest::Mock.new.expect :call, nil, [5, PIN], **OPTIONS
     board.stub(:spi_transfer, mock) do
       part.transfer(PIN, **OPTIONS)
     end
     mock.verify
   end
-  
+
   def test_listen
-    mock = Minitest::Mock.new.expect :call, nil, [PIN], **OPTIONS
+    mock = Minitest::Mock.new.expect :call, nil, [5, PIN], **OPTIONS
     board.stub(:spi_listen, mock) do
       part.listen(PIN, **OPTIONS)
     end
     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(255)
-    assert_empty part.components
-  end
 end

data/test/spi/input_register_test.rb

@@ -16,14 +16,14 @@ class InputRegisterTest < Minitest::Test
   def part
     @part ||= Denko::SPI::InputRegister.new(options)
   end
-  
+
   def button
     @button ||= Denko::DigitalIO::Button.new(board: part, pin: 0)
   end
 
   def test_state_setup
-    assert_equal part.instance_variable_get(:@reading_pins), Array.new(16) { false }
-    assert_equal part.instance_variable_get(:@listening_pins), Array.new(16) { false }
+    assert_equal Array.new(16) { false }, part.reading_pins
+    assert_equal Array.new(16) { false }, part.listening_pins
     refute_nil   part.callbacks[:board_proxy]
   end
 
@@ -34,7 +34,7 @@ class InputRegisterTest < Minitest::Test
     end
     mock.verify
   end
-  
+
   def test_listen
     mock = Minitest::Mock.new.expect :call, nil, [9], read: 2, frequency: 800000, mode: 2, bit_order: :lsbfirst
     bus.stub(:listen, mock) do
@@ -42,7 +42,7 @@ class InputRegisterTest < Minitest::Test
     end
     mock.verify
   end
-  
+
   def test_stop
     mock = Minitest::Mock.new.expect :call, nil, [9]
     bus.stub(:stop, mock) do
@@ -50,7 +50,7 @@ class InputRegisterTest < Minitest::Test
     end
     mock.verify
   end
-  
+
   def test_updates_child_components
     button
     part.update("1")
@@ -58,7 +58,7 @@ class InputRegisterTest < Minitest::Test
     part.update("0")
     assert button.low?
   end
-  
+
   def test_bit_array_conversion_and_state_update
     part.update("127")
     assert_equal [1,1,1,1,1,1,1,0], part.state
@@ -67,7 +67,7 @@ class InputRegisterTest < Minitest::Test
     new_part.update("127,128")
     assert_equal [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1], new_part.state
   end
-  
+
   def test_callbacks_get_bit_array
     mock = Minitest::Mock.new.expect :call, nil, [[1,1,1,1,1,1,1,0]]
     part.add_callback do |data|
@@ -76,11 +76,11 @@ class InputRegisterTest < Minitest::Test
     part.update("127")
     mock.verify
   end
-  
+
   def test_read_proxy
     # Stop automatic listening first.
     button.stop
-    
+
     # Give #read some value so it stops blocking.
     Thread.new do
       sleep(0.01) while !part.callbacks[:force_update]
@@ -101,12 +101,12 @@ class InputRegisterTest < Minitest::Test
     part.stub(:listen, mock) do
       # Tells the register to start listening when it initializees.
       button
-      
+
       # Should not make a second listen call to the board.
       Denko::DigitalIO::Button.new(board: part, pin: 1)
     end
     mock.verify
-    
+
     expected_array = Array.new(options[:bytes] * 8) { false }
     expected_array[0] = true
     expected_array[1] = true
@@ -114,26 +114,26 @@ class InputRegisterTest < Minitest::Test
     # Should be listening to the lowest 2 bits now.
     assert_equal expected_array, part.instance_variable_get(:@listening_pins)
   end
-  
+
   def test_stop_listener_proxy
     button
-    
+
     # Calling stop on a child part, when only it is listening, should call stop on the register too.
     mock = Minitest::Mock.new.expect :call, nil
     part.stub(:stop, mock) do
       button.stop
     end
     mock.verify
-    
+
     # Check listener tracking is correct.
     assert_equal Array.new(options[:bytes] * 8) { false }, part.instance_variable_get(:@listening_pins)
     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/output_register_test.rb

@@ -16,7 +16,7 @@ class OutputRegisterTest < Minitest::Test
   def part
     @part ||= Denko::SPI::OutputRegister.new(options)
   end
-  
+
   def led
     @led ||= Denko::LED.new(board: part, pin: 0)
   end
@@ -26,53 +26,42 @@ class OutputRegisterTest < Minitest::Test
     mock = Minitest::Mock.new.expect :call, nil, [9], write: [255,127], frequency: 800000, mode: 2, bit_order: :lsbfirst
     bus.stub(:transfer, mock) do
       arr = Array.new(16) { 1 }; arr[7] = 0
-      part.instance_variable_set(:@state, arr) 
+      part.instance_variable_set(:@state, arr)
       part.write
     end
     mock.verify
   end
-  
-  def test_state_setup
-    assert_equal part.instance_variable_get(:@write_delay), 0.001
-    assert_equal part.instance_variable_get(:@buffer_writes), true
-  end
-  
-  def test_write_buffering_control
-    new_part = Denko::SPI::OutputRegister.new(options.merge(buffer_writes: false, write_delay: 0.5))
-    assert_equal new_part.instance_variable_get(:@write_delay), 0.5
-    assert_equal new_part.instance_variable_get(:@buffer_writes), false
-  end
-  
+
   def test_updates_and_writes_state_for_children
     led
-    
+
     mock = Minitest::Mock.new.expect :call, nil, [9], write: [0, 1], frequency: 800000, mode: 2, bit_order: :lsbfirst
     bus.stub(:transfer, mock) do
       led.on
       sleep 0.050
     end
     mock.verify
-    
+
     expected_state = Array.new(options[:bytes] * 8) { |i| 0 }
     expected_state[0] = 1
 
     assert_equal expected_state, part.state
   end
-  
+
   def test_implements_digital_read_for_children
     led
-    
+
     mock = Minitest::Mock.new.expect :call, nil, [0]
     part.stub(:digital_read, mock) do
       led.board.digital_read(led.pin)
     end
     mock.verify
   end
-  
+
   def test_bit_and_byte_orders_correct
     part.instance_variable_set(:@bytes, 2)
     bit_array = "0101010100001111".split("")
-    
+
     mock = Minitest::Mock.new.expect :call, nil, [9], write: [0b11110000, 0b10101010], frequency: 800000, mode: 2, bit_order: :lsbfirst
     bus.stub(:transfer, mock) do
       part.instance_variable_set(:@state, bit_array)
@@ -80,14 +69,7 @@ class OutputRegisterTest < Minitest::Test
       sleep 0.002
     end
     mock.verify
-    
+
     assert_equal part.state, bit_array
   end
-  
-  def test_disable_buffering
-    part.instance_variable_set(:@buffer_writes, false)
-    part.instance_variable_set(:@write_delay, 1)
-    led.on
-    assert_nil part.thread
-  end
 end

data/test/spi/peripheral_test.rb

@@ -0,0 +1,73 @@
+require_relative '../test_helper'
+
+class SPITester
+  include Denko::SPI::Peripheral
+
+  def initialize_pins(options={})
+    super(options)
+    proxy_pin :other_pin, Denko::DigitalIO::Output
+  end
+
+  def some_callback(data)
+  end
+end
+
+class SPITesterSingle
+  include Denko::SPI::Peripheral
+end
+
+class SPIPeripheralTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    @bus ||= Denko::SPI::Bus.new(board: board)
+  end
+
+  def options
+    { bus: bus, pins: {select: 9, other_pin: 10}, spi_frequency: 800000, spi_mode: 2, spi_bit_order: :lsbfirst}
+  end
+
+  def part
+    @part ||= SPITester.new(options)
+  end
+
+  def test_string_data_converts_to_bytes_for_callbacks
+    part.on_data do |bytes|
+      part.some_callback(bytes)
+    end
+    mock = Minitest::Mock.new.expect :call, nil, [[127,255]]
+    part.stub(:some_callback, mock) do
+      board.update("#{part.select.pin}:127,255")
+    end
+    mock.verify
+  end
+
+  def test_array_data_reaches_callbacks
+    part.on_data do |bytes|
+      part.some_callback(bytes)
+    end
+    mock = Minitest::Mock.new.expect :call, nil, [[127,255]]
+    part.stub(:some_callback, mock) do
+      part.select.update([127,255])
+    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