denko 0.13.6 → 0.14.0

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, resolution: 8}
+    else
+      mock.expect :call, nil, [14, :output_pwm, {frequency: 1000, 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, resolution: 12}
+    else
+      mock.expect :call, nil, [6, :output_pwm, {frequency: 1000, 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, resolution: 14}
+    else
+      mock.expect :call, nil, [14, :output_pwm, {frequency: 500, 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

data/test/rtc/ds3231_test.rb

@@ -6,45 +6,43 @@ 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_read_for_i2c(0, "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
       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.stub(:update_state, mock) do

data/test/sensor/dht_test.rb

@@ -55,7 +55,7 @@ class DHTTest < Minitest::Test
     
     # 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

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/bus_test.rb

@@ -4,7 +4,7 @@ class TempSpiPeripheral
   def initialize(pin)
     @pin = pin
   end
-  
+
   attr_reader :pin
 end
 
@@ -14,28 +14,28 @@ 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_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
     mock = Minitest::Mock.new.expect :call, nil, [PIN]
     board.stub(:spi_stop, mock) do
@@ -70,7 +70,7 @@ class SPIBusTest < Minitest::Test
   end
 
   def test_no_select_pin
-    part.add_component TempSpiPeripheral.new(255)
+    part.add_component TempSpiPeripheral.new(nil)
     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,17 +114,17 @@ 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

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_multi_pin_test.rb

@@ -0,0 +1,53 @@
+require_relative '../test_helper'
+
+class SPITesterMulti
+  include Denko::SPI::Peripheral::MultiPin
+
+  def initialize_pins(options={})
+    super(options)
+    proxy_pin :other_pin, Denko::DigitalIO::Output, board: bus.board
+  end
+
+  def some_callback(data)
+  end
+end
+
+class SPIPeripheralMultiPinTest < 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 ||= SPITesterMulti.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
+end

data/test/spi/peripheral_single_pin_test.rb

@@ -0,0 +1,48 @@
+require_relative '../test_helper'
+
+class SPITester
+  include Denko::SPI::Peripheral::SinglePin
+
+  def some_callback(data)
+  end
+end
+
+class SPIPeripheralSinglePinTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    @bus ||= Denko::SPI::Bus.new(board: board)
+  end
+
+  def options
+    { bus: bus, pin: 9, 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.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.update([127,255])
+    end
+    mock.verify
+  end
+end

data/test/test_helper.rb

@@ -18,7 +18,6 @@ Denko::AnalogIO::ADS1118
 Denko::AnalogIO::Input
 Denko::AnalogIO::Output
 Denko::AnalogIO::Potentiometer
-Denko::AnalogIO::Sensor
 
 # Behaviors
 # Not needed, since every behavior will be included by at least one class.
@@ -68,15 +67,13 @@ Denko::OneWire::Helper
 
 # Pulse IO
 Denko::PulseIO::Buzzer
-Denko::PulseIO::IRTransmitter
+Denko::PulseIO::IROutput
 Denko::PulseIO::PWMOutput
 
 # RTC
 Denko::RTC::DS3231
 
 # Sensor
-Denko::Sensor::Temperature
-Denko::Sensor::Humidity
 Denko::Sensor::BME280
 Denko::Sensor::BMP280
 Denko::Sensor::DHT
@@ -155,13 +152,6 @@ class BoardMock < Denko::Board
 
   WAITING_ON_READ_KEYS = [:read, :bus_controller, :board_proxy, :force_udpate]
 
-  def component_exists_for_pin(pin)
-    self.components.each do |component|
-      return component if component.pin == pin
-    end
-    false
-  end
-
   def waiting_on_read(component)
     WAITING_ON_READ_KEYS.each do |key|
       return true if component.callbacks[key]
@@ -169,6 +159,16 @@ class BoardMock < Denko::Board
     false
   end
 
+  def single_pin_component_exists(pin)
+    return single_pin_components[pin]
+    false
+  end
+
+  def hw_i2c_exists(index)
+    return hw_i2c_comps[index]
+    false
+  end
+
   #
   # Inject a message into the Board instance as if it were coming from the phsyical board.
   # Use this to mock input data for the blocking #read pattern in the Reader behavior.
@@ -179,36 +179,39 @@ class BoardMock < Denko::Board
       component = false
       while !component
         sleep(0.001)
-        component = component_exists_for_pin(pin)
+        component = single_pin_component_exists(pin)
       end
+      inject_read(component, "#{pin}:#{message}")
+    end
+  end
 
-      # Wait for the component to have a "WAITING_ON_READ" callback.
-      sleep(0.001) while !component.callback_mutex
-      sleep(0.001) while !component.callbacks
-      sleep(0.001) while !waiting_on_read(component)
-
-      # Then inject the message.
-      @read_injection_mutex.synchronize do
-        self.update("#{pin}:#{message}")
+  def inject_read_for_i2c(index, message)
+    Thread.new do
+      # Wait for a component to be added.
+      component = false
+      while !component
+        sleep(0.001)
+        component = hw_i2c_exists(index)
       end
+      inject_read(component, "I2C#{index}:#{message}")
     end
   end
 
-  #
-  # Inject a message into the Board instance as if it were coming from the phsyical board.
-  # Use this to mock input data for the blocking #read pattern in the Reader behavior.
-  #
   def inject_read_for_component(component, pin, message)
     Thread.new do
-      # Wait for the component to have a "WAITING_ON_READ" callback.
-      sleep(0.001) while !component.callback_mutex
-      sleep(0.001) while !component.callbacks
-      sleep(0.001) while !waiting_on_read(component)
-
-      # Then inject the message.
-      @read_injection_mutex.synchronize do
-        self.update("#{pin}:#{message}")
-      end
+      inject_read(component, "#{pin}:#{message}")
+    end
+  end
+
+  def inject_read(component, string)
+    # Wait for the component to have a "WAITING_ON_READ" callback.
+    sleep(0.001) while !component.callback_mutex
+    sleep(0.001) while !component.callbacks
+    sleep(0.001) while !waiting_on_read(component)
+
+    # Then inject the message.
+    @read_injection_mutex.synchronize do
+      self.update(string)
     end
   end
 end