denko 0.13.0

data/test/one_wire/peripheral_test.rb

@@ -0,0 +1,158 @@
+require_relative '../test_helper'
+
+class OneWirePeripheralTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    return @bus if @bus
+    # Respond with disabled parasite power.
+    board.inject_read_for_pin(1, "1")
+    @bus ||= Denko::OneWire::Bus.new(board: board, pin: 1)
+  end
+
+  def part
+    @part ||= Denko::OneWire::Peripheral.new(bus: bus, address: 0xFFFFFFFFFFFFFFFF)
+  end
+
+  def test_requires_address
+    assert_raises(ArgumentError) { Denko::OneWire::Peripheral.new(bus: bus) }
+  end
+
+  def test_atomically_locks_the_bus_mutex
+    mock = MiniTest::Mock.new.expect(:synchronize, nil)
+    bus.stub(:mutex, mock) do
+      part.atomically {}
+    end
+    mock.verify
+  end
+
+  def test_atomically_calls_the_block_once
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.atomically { mock.call }
+    mock.verify
+  end
+
+  def test_match_calls_reset
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    bus.stub(:reset, mock) do
+      part.match
+    end
+    mock.verify
+  end
+
+  def test_match_skips_rom_if_alone
+    mock = MiniTest::Mock.new.expect(:call, nil, [0xCC])
+    bus.stub(:write, mock) do
+      part.match
+    end
+    mock.verify
+  end
+
+  def test_match_matches_rom_if_not_alone
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [0x55])
+    mock.expect(:call, nil, [[255,255,255,255,255,255,255,255]])
+    bus.instance_variable_set(:@found_devices, [1,2])
+    bus.stub(:write, mock) do
+      part.match
+    end
+    mock.verify
+  end
+
+  def test_copy_scratch_is_atomic
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:atomically, mock) { part.copy_scratch }
+    mock.verify
+  end
+
+  def test_copy_scratch_matches_first
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:match, mock) { part.copy_scratch }
+    mock.verify
+  end
+
+  def test_copy_scratch_sends_the_command
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [0xCC])
+    mock.expect(:call, nil, [0x48])
+    bus.stub(:write, mock) { part.copy_scratch }
+    mock.verify
+  end
+
+  def test_copy_scratch_resets_after_command_if_parasite_power
+    mock = MiniTest::Mock.new.expect(:call, nil).expect(:call, nil)
+    bus.stub(:parasite_power, true) do
+      bus.stub(:reset, mock) { part.copy_scratch }
+    end
+    mock.verify
+  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")
+
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:atomically, mock) { part.read_scratch(9) }
+    mock.verify
+  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")
+
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:match, mock) { part.read_scratch(9) }
+    mock.verify
+  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")
+
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [0xCC])
+    mock.expect(:call, nil, [0xBE])
+    bus.stub(:write, mock) { part.read_scratch(9) }
+    mock.verify
+  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")
+
+    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) }
+    mock.verify
+  end
+
+  def test_write_scratch_matches_first
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:match, mock) { part.write_scratch(1) }
+    mock.verify
+  end
+
+  def test_write_scratch_sends_the_command_and_data
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [0xCC])
+    mock.expect(:call, nil, [0x4E])
+    mock.expect(:call, nil, [1,2,3])
+    bus.stub(:write, mock) { part.write_scratch(1, 2, 3) }
+    mock.verify
+  end
+end

data/test/pulse_io/buzzer_test.rb

@@ -0,0 +1,48 @@
+require_relative '../test_helper'
+
+class BuzzerTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::PulseIO::Buzzer.new(board: board, pin:8)
+  end
+
+  def test_low_on_initialize
+    assert_equal part.state, board.low
+  end
+  
+  def test_tone
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [part.pin, 60, nil]
+    mock.expect :call, nil, [part.pin, 120, 2000]
+    board.stub(:tone, mock) do
+      part.tone(60)
+      part.tone(120, 2000)
+    end
+    mock.verify
+  end
+  
+  def test_no_tone
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [part.pin]
+    board.stub(:no_tone, mock) do
+      part.no_tone
+    end
+    mock.verify
+  end
+  
+  def stop
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil
+    mock.expect :call, nil
+    part.stub(:kill_thread, mock) do
+      part.stub(:no_tone, mock) do
+        part.stop
+      end
+    end
+    mock.verify
+  end
+end

data/test/pulse_io/ir_transmitter_test.rb

@@ -0,0 +1,38 @@
+require_relative '../test_helper'
+
+class IRTransmitterTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::PulseIO::IRTransmitter.new(board: board, pin:1)
+  end
+  
+  def test_pulse_count_validation
+    assert_raises(ArgumentError) do
+      part.emit Array.new(257) { 0 }
+    end
+  end
+  
+  def test_numeric_validation
+    assert_raises(ArgumentError) do
+      part.emit ["a", "b", "c"]
+    end
+  end
+  
+  def test_pulse_length_validation
+    assert_raises(ArgumentError) do
+      part.emit [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])
+    end
+    mock.verify
+  end
+end

data/test/pulse_io/pwm_output_test.rb

@@ -0,0 +1,72 @@
+require_relative '../test_helper'
+
+class PWMOutTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::PulseIO::PWMOutput.new(board: board, pin: 14)
+  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
+        part.pwm_write(128)
+        assert_equal 128, part.state
+      end
+    end
+    
+    part.pwm_write(64)
+    assert_equal 64, part.state
+    assert_equal :output_pwm, part.mode
+
+    write_mock.verify
+    enable_mock.verify
+  end
+
+  def test_write_uses_digital_write_at_limits
+    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)
+    end
+    mock.verify
+  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)
+    end
+    mock.verify
+  end
+  
+  def test_pwm_enable
+    part
+    mock = Minitest::Mock.new.expect :call, nil, [14, :output_pwm]
+    board.stub(:set_pin_mode, mock) do
+      part.pwm_enable
+    end
+    mock.verify
+    assert_equal :output_pwm, part.mode
+  end
+    
+  def test_pwm_disable
+    part.pwm_enable
+    mock = Minitest::Mock.new
+    mock.expect :call, nil, [14, :output]
+    board.stub(:set_pin_mode, mock) do
+      part.pwm_disable
+    end
+    mock.verify
+    assert_equal :output, part.mode
+  end
+end

data/test/rtc/ds3231_test.rb

@@ -0,0 +1,55 @@
+require_relative '../test_helper'
+
+class DS3231Test < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    return @bus if @bus
+    @bus = Denko::I2C::Bus.new(board: board, pin:5)
+    @bus
+  end
+  
+  def part
+    @part ||= Denko::RTC::DS3231.new(bus: bus, address: 0x68)
+  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]]]
+    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")
+    
+    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
+      bus.send(:update, "104-0,0,0,6,1,1,48")
+    end
+    mock.verify
+  end
+end

data/test/sensor/dht_test.rb

@@ -0,0 +1,64 @@
+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
+
+  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)
+    board.stub(:pulse_read, mock) do
+      part._read
+    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
+    mock = MiniTest::Mock.new.expect(:call, nil, [GOOD_ARRAY])
+    part.stub(:decode, mock) do
+      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}
+  end
+  
+  def test_crc
+    refute part.crc(bad_crc)
+  end
+end

data/test/sensor/ds18b20_test.rb

@@ -0,0 +1,107 @@
+require_relative '../test_helper'
+
+class DS18B20Test < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    return @bus if @bus
+    # Respond with disabled parasite power.
+    board.inject_read_for_pin(1, "1")
+    @bus ||= Denko::OneWire::Bus.new(board: board, pin: 1)
+  end
+
+  def part
+    @part ||= Denko::Sensor::DS18B20.new(bus: bus, address: 0xFFFFFFFFFFFFFFFF)
+  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]))
+  end
+
+  def test_decode_resolution
+    assert_equal 12, part.decode_resolution([0,0,0,0,0b01100000])
+    assert_equal 11, part.decode_resolution([0,0,0,0,0b01000000])
+    assert_equal 10, part.decode_resolution([0,0,0,0,0b00100000])
+    assert_equal  9, part.decode_resolution([0,0,0,0,0b00000000])
+  end
+
+  def test_set_convert_time
+    part.instance_variable_set(:@resolution, 9)
+    part.set_convert_time
+    assert_equal 0.09375, part.instance_variable_get(:@convert_time)
+    part.instance_variable_set(:@resolution, 12)
+    part.set_convert_time
+    assert_equal 0.75, part.instance_variable_get(:@convert_time)
+  end
+
+  # test resolution=
+
+  def test_convert_is_atomic
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:atomically, mock) do
+      part.convert
+    end
+    mock.verify
+  end
+
+  def test_convert_matches_first
+    match_mock = MiniTest::Mock.new.expect(:call, nil)
+    sleep_mock = MiniTest::Mock.new.expect(:call, nil, [0.75])
+    
+    part.stub(:match, match_mock) do
+      part.stub(:sleep, sleep_mock) do
+        part.convert
+      end
+    end
+    match_mock.verify
+  end
+
+  def test_convert_sends_the_command
+    write_mock = MiniTest::Mock.new
+    write_mock.expect(:call, nil, [0xCC])
+    write_mock.expect(:call, nil, [0x44])
+    sleep_mock = MiniTest::Mock.new.expect(:call, nil, [0.75])
+
+    bus.stub(:write, write_mock) do
+      part.stub(:sleep, sleep_mock) do
+        part.convert
+      end  
+    end
+    write_mock.verify
+  end
+
+  def test_convert_sets_max_convert_time_first
+    sleep_mock = MiniTest::Mock.new.expect(:call, nil, [0.75])
+    part.stub(:sleep, sleep_mock) do 
+      part.convert
+    end
+
+    assert_equal 0.75, part.instance_variable_get(:@convert_time)
+  end
+
+  def test_convert_sleeps_for_convert_time
+    mock = MiniTest::Mock.new.expect(:call, nil, [0.75])
+    part.stub(:sleep, mock) do
+      part.convert
+    end
+    mock.verify
+  end
+
+  def test_convert_sleeps_inside_lock_if_parasite_power
+    bus.instance_variable_set(:@parasite_power, true)
+    Thread.new do
+      part.convert
+    end
+    sleep 0.05
+    assert_equal true, bus.mutex.locked?
+  end
+end

data/test/spi/base_register_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+
+class BaseRegisterTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    @bus ||= Denko::SPI::Bus.new(board: board)
+  end
+
+  def options
+    { bus: bus, pin: 9, bytes: 2, spi_frequency: 800000, spi_mode: 2, spi_bit_order: :lsbfirst }
+  end
+
+  def part
+    @part ||= Denko::SPI::BaseRegister.new(options)
+  end
+
+  def test_defaults
+    new_part = Denko::SPI::BaseRegister.new bus: bus, pin: 9
+    assert_equal 1,                     new_part.bytes
+    assert_equal Array.new(8) {|i| 0},  new_part.state
+  end
+  
+  def test_options
+    assert_equal 800000,      part.spi_frequency
+    assert_equal 2,           part.spi_mode
+    assert_equal :lsbfirst,   part.spi_bit_order
+    assert_equal 2,           part.bytes
+    new_part = Denko::SPI::BaseRegister.new(options.merge(bytes: 3, pin: 10))
+    assert_equal new_part.state, Array.new(24) {|i| 0}
+  end
+end

data/test/spi/bus_test.rb

@@ -0,0 +1,76 @@
+require_relative '../test_helper'
+
+class TempSpiPeripheral
+  def initialize(pin)
+    @pin = pin
+  end
+  
+  attr_reader :pin
+end
+
+class SPIBusTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @bus ||= Denko::SPI::Bus.new(board: board)
+  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
+    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
+    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
+      part.stop(PIN)
+    end
+    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
+    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