denko 0.13.0

data/test/spi/input_register_test.rb

@@ -0,0 +1,140 @@
+require_relative '../test_helper'
+
+class InputRegisterTest < 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::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 }
+    refute_nil   part.callbacks[:board_proxy]
+  end
+
+  def test_read
+    mock = MiniTest::Mock.new.expect :call, nil, [9], read: 2, frequency: 800000, mode: 2, bit_order: :lsbfirst
+    bus.stub(:transfer, mock) do
+      part.read
+    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
+      part.listen
+    end
+    mock.verify
+  end
+  
+  def test_stop
+    mock = MiniTest::Mock.new.expect :call, nil, [9]
+    bus.stub(:stop, mock) do
+      part.stop
+    end
+    mock.verify
+  end
+  
+  def test_updates_child_components
+    button
+    part.update("1")
+    assert button.high?
+    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
+
+    new_part = Denko::SPI::InputRegister.new(options.merge(bytes: 2, pin: 10))
+    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|
+      mock.call(data)
+    end
+    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]
+      part.update("255")
+    end
+
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil
+    part.stub(:read, mock) do
+      button.read
+    end
+    mock.verify
+  end
+
+  def test_listener_proxy
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil
+    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
+
+    # 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
+    mock = MiniTest::Mock.new.expect :call, nil, ["127,255"]
+    part.stub(:update, mock) do
+      board.update("#{part.pin}:127,255")
+    end
+    mock.verify
+  end
+end

data/test/spi/output_register_test.rb

@@ -0,0 +1,93 @@
+require_relative '../test_helper'
+
+class OutputRegisterTest < 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::OutputRegister.new(options)
+  end
+  
+  def led
+    @led ||= Denko::LED.new(board: part, pin: 0)
+  end
+
+  def test_write
+    part
+    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.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)
+      part.write
+      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/test_helper.rb

@@ -0,0 +1,223 @@
+require "minitest/autorun"
+
+if RUBY_ENGINE == "ruby"
+  require 'simplecov'
+  SimpleCov.start do
+    track_files "lib/**/*.rb"
+    add_filter "test"
+    add_filter "lib/denko_cli"
+  end
+end
+
+require 'bundler/setup'
+require 'denko'
+
+# Touch each class to trigger auto load for simplecov.
+# Analog IO
+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.
+
+# Board
+# BoardMock inherits from Denko::Board
+
+# Connection
+Denko::Connection::Serial
+Denko::Connection::TCP
+
+# Digital IO
+Denko::DigitalIO::Button
+Denko::DigitalIO::Input
+Denko::DigitalIO::Output
+Denko::DigitalIO::Relay
+Denko::DigitalIO::RotaryEncoder
+
+# Display
+Denko::Display::Canvas
+Denko::Display::HD44780
+Denko::Display::SSD1306
+
+# EEPROM
+Denko::EEPROM::BuiltIn
+
+# I2C
+Denko::I2C::Bus
+Denko::I2C::Peripheral
+
+# LED
+Denko::LED::APA102
+Denko::LED::Base
+Denko::LED::RGB
+Denko::LED::SevenSegment
+Denko::LED::WS2812
+
+# Motor
+Denko::Motor::L298
+Denko::Motor::Servo
+Denko::Motor::Stepper
+
+# OneWire
+Denko::OneWire::Bus
+Denko::OneWire::Peripheral
+Denko::OneWire::Helper
+
+# Pulse IO
+Denko::PulseIO::Buzzer
+Denko::PulseIO::IRTransmitter
+Denko::PulseIO::PWMOutput
+
+# RTC
+Denko::RTC::DS3231
+
+# Sensor
+Denko::Sensor::Temperature
+Denko::Sensor::Humidity
+Denko::Sensor::BME280
+Denko::Sensor::BMP280
+Denko::Sensor::DHT
+Denko::Sensor::DS18B20
+Denko::Sensor::HTU21D
+
+# SPI
+Denko::SPI::BaseRegister
+Denko::SPI::BitBang
+Denko::SPI::Bus
+Denko::SPI::InputRegister
+Denko::SPI::OutputRegister
+
+# UART
+Denko::UART::BitBang
+
+# Helper module to redefine constants quietly.
+module Constants
+  def self.redefine(const, value, opts={})
+    opts = {:on => self.class}.merge(opts)
+    opts[:on].send(:remove_const, const) if self.class.const_defined?(const)
+    opts[:on].const_set(const, value)
+  end
+  ACK = "SAMD_ZERO,0.13.0,528,1024"
+
+  # Some test redefine RUBY_PLATFORM. Save the original to reset it.
+  ORIGINAL_RUBY_PLATFORM = RUBY_PLATFORM
+end
+
+# Taken from: https://gist.github.com/moertel/11091573
+def suppress_output
+  begin
+    original_stderr = $stderr.clone
+    original_stdout = $stdout.clone
+    if Constants::ORIGINAL_RUBY_PLATFORM.match(/mswin|mingw/i)
+      $stderr.reopen('NUL:')
+      $stdout.reopen('NUL:')
+    else
+      $stderr.reopen(File.new('/dev/null', 'w'))
+      $stdout.reopen(File.new('/dev/null', 'w'))
+    end
+    retval = yield
+  rescue Exception => e
+    $stdout.reopen(original_stdout)
+    $stderr.reopen(original_stderr)
+    raise e
+  ensure
+    $stdout.reopen(original_stdout)
+    $stderr.reopen(original_stderr)
+  end
+  retval
+end
+
+class ConnectionMock
+  def add_observer(board); true; end
+  def read; true; end
+  def write(str); true; end
+  def handshake
+    Constants::ACK
+  end
+end
+
+class BoardMock < Denko::Board
+  def initialize
+    super(ConnectionMock.new)
+    @read_injection_mutex = Mutex.new
+  end
+
+  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]
+    end
+    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.
+  #
+  def inject_read_for_pin(pin, message)
+    Thread.new do
+      # Wait for a component to be added.
+      component = false
+      while !component
+        sleep(0.001)
+        component = component_exists_for_pin(pin)
+      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}")
+      end
+    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
+    end
+  end
+end
+
+module TestPacker
+  def pack(*args, **kwargs)
+    Denko::Message.pack(*args, **kwargs)
+  end
+end
+
+# Speed up one wire tests.
+module Denko
+  module OneWire
+    class Bus
+      def sleep(time)
+        super(0.001)
+      end
+    end
+  end
+end

data/test/uart/bitbang_test.rb

@@ -0,0 +1,37 @@
+require_relative '../test_helper'
+
+class UARTBitBangTest < MiniTest::Test
+  include TestPacker
+
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::UART::BitBang.new board: board, pins: { rx: 10, tx: 11 }, baud: 4800
+  end
+
+  def test_initialize
+    mock = MiniTest::Mock.new
+    # Set RX to input
+    mock.expect :call, nil, ["0.10.1\n"]
+    # Start BB UART
+    aux = pack(:uint32, 4800) + pack(:uint8, 0b11000000)
+    mock.expect :call, nil, ["12.11.10.#{aux}\n"]
+
+    board.stub(:write, mock) do
+      part
+    end
+    mock.verify
+  end
+
+  def test_write
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, ["13..8.Testing\\\n\n"]
+    board.stub(:write, mock) do
+      part.write("Testing\n")
+    end
+    mock.verify
+  end
+end

data/tutorial/01-led/led.rb

@@ -0,0 +1,73 @@
+#
+# Example 1: Controlling an LED
+#
+require 'bundler/setup'
+require 'denko'
+
+# If the board is plugged into a USB port, we can connect with serial over USB.
+connection = Denko::Connection::Serial.new
+
+# Create a new board object, giving the connection.
+board = Denko::Board.new(connection)
+
+#
+# Create an LED object, giving the board, and the pin that the positive
+# leg of the LED is connected to. The longer leg is usually positive.
+#
+# See led.pdf in this folder for a hook-up diagram.
+# Use a current limiting resistor with external LEDs to protect them.
+#
+# The on-board LED can also be used. It is connected to pin 13 on most Arduinos,
+# but can vary for other boards. The symbol :LED_BUILTIN should map to the right pin.
+# If it doesn't, change it to the pin number from your board's documentation.
+#
+# Note: Some boards use an addressable LED on-board. In those cases, connect an external
+# LED and use its pin for this example instead.
+#
+led = Denko::LED.new(board: board, pin: :LED_BUILTIN)
+
+# Now we can make it blink.
+puts "Blinking every half second..."
+
+#
+# A digital output can only have one of two states:
+# 1 / high / on
+# 0 / low / off
+# We can use led.digital_write to set it directly, or named convenience methods.
+# These 3 lines all do the same thing: turn on, wait half a second, turn off.
+#
+led.digital_write(1); sleep 0.5; led.digital_write(0)
+led.high;             sleep 0.5; led.low
+led.on;               sleep 0.5; led.off
+
+#
+# led.toggle will set it to the opposite state each time it's called.
+# Keep it blinking for 3 more seconds using #toggle.
+#
+6.times do
+  led.toggle
+  sleep 0.5
+end
+
+#
+# What if we want to blink in the background?
+#
+# led.blink runs in a separate thread, managed by the led, and doesn't block the
+# main thread. Give it the blink interval in seconds.
+#
+led.blink 0.5
+puts "Blinking in the background... Hello from the main thread!"
+sleep 3
+
+#
+# Calling a method that sets the state (#digital_write, #high, #low, #on, #off)
+# automatically stops the blink thread.
+#
+puts "Turning off for 2 seconds..."
+led.off
+sleep 2
+
+# Blink faster indefinitely.
+puts "Blinking faster forever... (Press Ctrl+C to exit)"
+led.blink 0.1
+sleep

data/tutorial/02-button/button.rb

@@ -0,0 +1,64 @@
+#
+# Example 2: Using a Button
+#
+require 'bundler/setup'
+require 'denko'
+
+# Set up the board, connecting with serial over USB.
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+#
+# Create an object for a momentary button, giving the board, and the pin that
+# the ungrounded side of the button is connected to.
+#
+# `pullup: true` tells the board to keep the input pin high (logical 1) when the
+# button is not pressed. Without this (or an external pullup resistor), the pin
+# might float between 0 and 1, giving incorrect readings. When the button is
+# pressed, it pulls the input pin down to ground (0).
+#
+# See button.pdf in this folder for a hook-up diagram.
+#
+button = Denko::DigitalIO::Button.new(board: board, pin: 7, pullup: true)
+
+#
+# As soon as a Button (or any DigitalInput) is created, the board starts
+# listening for changes to the physical button. When that happens, our button
+# object is notified. To catch these notifications, we have to use a callback.
+# button.add_callback saves a block of code to run each time the button state changes.
+# 
+# The callback below checks if the state is 0 (the button went from up to down),
+# then counts and prints the number of times pressed.
+#
+presses = 0
+button.add_callback(:count_presses) do |state|
+  if state == 0
+    presses = presses + 1
+    puts "Button press ##{presses}"
+  end
+end
+
+# Wait for the button to be pressed 3 times.
+sleep 0.005 while presses < 3
+
+# Button keeps its callbacks in a Hash. We can be specific and use keys to add and remove.
+button.remove_callback(:count_presses)
+
+# Or remove them all. Either way, the block above won't run anymore.
+button.remove_callbacks
+
+#
+# button.down and button.up add callbacks that automatically check state for you.
+#
+# #down runs only when state goes from high (1) to low (0).
+# #up runs only when state goes from low (0) to high (1).
+#
+# We can use them to control the internal LED from example 1.
+#
+led = Denko::LED.new(board: board, pin: 13)
+
+button.up   { led.off } 
+button.down { led.on }
+
+puts "Press the button to turn on the LED... (Ctrl+C to exit)"
+
+sleep

data/tutorial/03-potentiometer/potentiometer.rb

@@ -0,0 +1,62 @@
+#
+# Example 3: Potentiometer and Analog Inputs
+#
+require 'bundler/setup'
+require 'denko'
+
+# Set up the board, connecting with serial over USB.
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+#
+# Connect the potentiometer's outer 2 pins to Ground and Vcc respectively.
+# The center is the wiper, and should be connected to one of the board's analog
+# pins. On most boards these pins start with 'A' and can be given as strings.
+#
+# See potentiometer.pdf in this folder for a hook-up diagram.
+# 
+potentiometer = Denko::AnalogIO::Potentiometer.new(pin: 'A0', board: board)
+
+#
+# Like with Button, the Board starts reading the Potentiometer value immediately,
+# but we need to add a callback to do something with it.
+#
+potentiometer.on_change do |value|
+  print "Potentiometer value: #{value} \r"
+end
+puts "Turn the potentiometer to change value. Press Enter to continue..."
+
+# Stop the callback.
+gets; puts
+potentiometer.remove_callbacks
+
+#
+# The default resolution for Analog Input is 10-bits, so you should have seen
+# values from 0 - 1023. We can use the value to control the blinking
+# speed of the LED from the earlier example.
+# 
+led = Denko::LED.new(board: board, pin: 13)
+
+# Helper method to calculate the blink time.
+def map_pot_value(value)
+  # Map 10 bit value into 0 to 1 range.
+  fraction = value / 1023.to_f
+
+  # Linearization hack for audio taper potentiometers.
+  # Adjust k for different tapers. This was an A500K.
+  k = 5
+  linearized = (fraction * (k + 1)) / ((k * fraction) + 1)
+  # Use this for linear potentiometers instead.
+  # linearized = fraction 
+  
+  # Map to the 0.1 to 0.5 seconds range in reverse. Clockwise = faster.
+  0.5 - (linearized * 0.4)
+end
+
+# Callback that calculates the blink interval and tells the LED.
+potentiometer.on_change do |value|
+  interval = map_pot_value(value)
+  print "LED blink interval: #{interval.round(4)} seconds    \r"
+  led.blink(interval)
+end
+puts "Turn potentiometer to control the LED blink. Press Ctrl+C to exit..."
+sleep