denko 0.13.0

data/src/lib/DenkoTone.cpp

@@ -0,0 +1,25 @@
+//
+// This file adds to the Denko class only if DENKO_TONE is defined in Denko.h.
+//
+#include "Denko.h"
+#ifdef DENKO_TONE
+
+// CMD = 20
+void Denko::tone() {
+  uint16_t frequency = *reinterpret_cast<uint16_t*>(auxMsg);
+  uint16_t duration = *reinterpret_cast<uint16_t*>(auxMsg + 2); // in milliseconds
+  
+  // val is 1 if a duration was given, 0 if not.
+  if (val !=0) {
+    ::tone(pin, frequency, duration);
+  } else {
+    ::tone(pin, frequency);
+  }
+}
+
+// CMD = 21
+void Denko::noTone() {
+  ::noTone(pin);
+}
+
+#endif

data/src/lib/DenkoUART.cpp

@@ -0,0 +1,118 @@
+#include "Denko.h"
+#ifdef DENKO_UARTS
+
+void Denko::uartBegin(uint8_t index, uint32_t baud) {
+  #if DENKO_UARTS
+    if (index == 1) {
+      uarts[1] = &Serial1;
+      Serial1.begin(baud);
+    }
+  #endif
+  #if (DENKO_UARTS == 2) || (DENKO_UARTS == 3)
+    else if (index == 2) {
+      uarts[2] = &Serial2;
+      Serial2.begin(baud);
+    }
+  #endif
+  #if (DENKO_UARTS == 3)
+    else if (index == 3){
+      uarts[3] = &Serial3;
+      Serial3.begin(baud);
+    }
+  #endif
+}
+
+void Denko::uartEnd(uint8_t index) {
+  #if DENKO_UARTS
+    if (index == 1) {
+      Serial1.end();
+    }
+  #endif
+  #if (DENKO_UARTS == 2) || (DENKO_UARTS == 3)
+    else if (index == 2) {
+      Serial2.end();
+    }
+  #endif
+  #if (DENKO_UARTS == 3)
+    else if (index == 3){
+      Serial3.end();
+    }
+  #endif
+  uartListenStates[index] = false;
+  uartRxPins[index] = NULL;
+}
+
+// CMD = 13
+// Start or stop one of the open hardware UARTS on the board.
+//
+// pin
+//   Bit 0..1  = UART index (Serial1, Serial2 or Serial 3)
+//   Bit 2..5  = < unused >
+//   Bit 6     = Starting or stopping? 0 = STOP, 1 = START
+//   Bit 7     = If starting, read or not? 0 = NO, 1 = YES
+//
+// val         = < unused >
+// auxMsg[0-3] = Baud rate if starting.
+//
+void Denko::uartSetup() {
+  // Don't do anything if UART index is out of range.
+  uint8_t index  = pin & 0b00000011;
+  if ((index < 1) || (index > DENKO_UARTS)) return;
+
+  uint8_t enable = pin & 0b01000000;
+  uint8_t listen = pin & 0b10000000;
+
+  if (enable > 0) {
+    // RP2040 crashes with 32-bit reinterpret_cast.
+    uint32_t  baud  = (uint32_t)auxMsg[0];
+              baud |= (uint32_t)auxMsg[1] << 8;
+              baud |= (uint32_t)auxMsg[2] << 16;
+              baud |= (uint32_t)auxMsg[3] << 24;
+
+    // Serial1 on ESP8266 can't read.
+    #ifndef ESP8266
+      if (listen > 0) {
+        uartListenStates[index] = true;
+
+        // Use "virtual pins" 251 - 253 to represent the UARTs;
+        uartRxPins[index] = 250 + index;
+      }
+    #endif
+
+    uartBegin(index, baud);
+  } else {
+    uartEnd(index);
+  }
+}
+
+// CMD = 14
+// Write bytes to the Tx pin of one of the UARTS
+//
+// pin         = UART index to write to (Serial1, Serial2 or Serial 3)
+// val         = Length of data bytes
+// auxMsg[0+]  = Data bytes
+//
+void Denko::uartWrite() {
+  if ((pin < 1) || (pin > DENKO_UARTS)) return;
+  uarts[pin]->write(auxMsg, val);
+}
+
+void Denko::uartUpdateListeners() {
+  // Start from Serial1, up to highest available.
+  for (byte i = 1; i <= DENKO_UARTS; i++) {
+    if ((uartListenStates[i]) && uarts[i]->available()) {
+      stream->print(uartRxPins[i]);
+      stream->print(':');
+
+      char tempChar;
+      while (uarts[i]->available()) {
+        tempChar = uarts[i]->read();
+        // Escape backslashes and newlines.
+        if ((tempChar == '\\') || (tempChar == '\n')) stream->print('\\');
+        stream->print(tempChar);
+      }
+      stream->print('\n');
+    }
+  }
+}
+#endif

data/src/lib/DenkoUARTBB.cpp

@@ -0,0 +1,62 @@
+#include "Denko.h"
+#ifdef DENKO_UART_BB
+
+void Denko::uartBBBegin(uint32_t baud) {
+  pinMode(uartBBTx, OUTPUT);
+  pinMode(uartBBRx, INPUT);
+  
+  uartBB = SoftwareSerial(uartBBRx, uartBBTx);
+  uartBB.begin(baud);
+}
+
+void Denko::uartBBEnd() {
+  uartBB.end();
+  pinMode(uartBBTx, INPUT);
+  pinMode(uartBBRx, INPUT);
+  uartBBListen = false;
+}
+
+void Denko::uartBBSetup() {
+  // Config format is sames hardware UART, but held in auxMsg[4] instead of pin.
+  uint8_t enable = auxMsg[4] & 0b01000000;
+  uint8_t listen = auxMsg[4] & 0b10000000;
+
+  if (enable > 0) {
+    // Do nothing if TX (pin) and RX (val) are out of range.
+    if ((pin < 0) || (pin > 250) || (val < 0) || (val > 250)) return;
+
+    uartBBEnd();
+    uartBBTx = pin;
+    uartBBRx = val;
+    uint32_t baud = *reinterpret_cast<uint32_t*>(auxMsg);
+
+    uartBBBegin(baud);
+    if (listen > 0) {
+      uartBBListen = true;
+      uartBB.listen();
+    }
+  } else {  
+    uartBBEnd();
+  }
+}
+
+void Denko::uartBBWrite() {
+  uartBB.write(auxMsg, val);
+}
+
+void Denko::uartBBUpdateListener() {
+  if (uartBBListen && uartBB.available()) {
+    stream->print(uartBBRx);
+    stream->print(':');
+
+    char tempChar;
+    while (uartBB.available()) {
+      tempChar = uartBB.read();
+      // Escape backslashes and newlines.
+      if ((tempChar == '\\') || (tempChar == '\n')) stream->print('\\');
+      stream->print(tempChar);
+    }
+    stream->print('\n');
+  }
+}
+#endif

data/target.yml

@@ -0,0 +1,3 @@
+name: mega
+fqbn: arduino:avr:uno
+port: /dev/cu.usbmodem14B01

data/test/analog_io/input_test.rb

@@ -0,0 +1,38 @@
+require_relative '../test_helper'
+
+class AnalogIOInputTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::AnalogIO::Input.new(board: board, pin: 14)
+  end
+
+  def test__read
+    mock = MiniTest::Mock.new.expect :call, nil, [14, nil, nil, nil]
+    board.stub(:analog_read, mock) do
+      part._read
+    end
+    mock.verify
+  end
+
+  def test__listen
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [14, 16]
+    mock.expect :call, nil, [14, 32]
+    board.stub(:analog_listen, mock) do
+      part._listen
+      part._listen(32)
+    end
+    mock.verify
+  end
+
+  def test__stop_listen
+    mock = MiniTest::Mock.new.expect :call, nil, [14]
+    board.stub(:stop_listener, mock) do
+      part._stop_listener
+    end
+    mock.verify
+  end
+end

data/test/analog_io/output_test.rb

@@ -0,0 +1,26 @@
+require_relative '../test_helper'
+
+class AnalogIOOutputTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::AnalogIO::Output.new(board: board, pin: 14)
+  end
+  
+  def test_mode_set
+    assert_equal :output_dac, part.mode
+  end
+  
+  def test_dac_write
+    mock = MiniTest::Mock.new.expect :call, nil, [14, 128]
+
+    board.stub(:dac_write, mock) do
+      part.write 128
+    end
+    mock.verify
+    
+    assert_equal 128, part.state
+  end
+end

data/test/analog_io/potentiometer_test.rb

@@ -0,0 +1,62 @@
+require_relative '../test_helper'
+
+class AnalogIOPotentiometerTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::AnalogIO::Potentiometer.new(board: board, pin:14)
+  end
+
+  def test_setup
+    mock = MiniTest::Mock.new.expect(:call, nil, [14,8])
+    board.stub(:analog_listen, mock) do
+      part
+    end
+
+    assert part.smoothing
+    assert_equal 8,   part.divider
+    assert_equal [],  part.instance_variable_get(:@smoothing_set)
+  end
+  
+  def test_smoothing_on
+    7.times do
+      part.update(10)
+    end
+    part.update(50)
+    
+    # 120/8 = 15
+    assert_equal part.state, 15
+  end
+  
+  def test_smoothing_off
+    part.smoothing = false
+    7.times do
+      part.update(10)
+    end
+    part.update(50)
+    
+    # Give latest value.
+    assert_equal part.state, 50
+  end
+  
+  def test_on_change
+    mock = Minitest::Mock.new.expect(:call, nil)
+    
+    # Turn off smoothing and set an initial value
+    part.smoothing = false
+    part.update(100)
+    
+    # Add the callback
+    part.on_change { mock.call }
+    
+    # Send a few updates
+    part.update(100)
+    part.update(100)
+    part.update(101)
+        
+    # Should have only been called once.
+    mock.verify
+  end
+end

data/test/behaviors/board_proxy_test.rb

@@ -0,0 +1,24 @@
+require_relative '../test_helper'
+
+class ProxiedComponent
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BoardProxy
+end
+
+class BoardProxyTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= ProxiedComponent.new(board: board)
+  end
+  
+  def test_methods
+    assert_equal part.high, 1
+    assert_equal part.low, 0
+    assert_equal part.convert_pin("7"), 7
+    part.set_pin_mode(1, :output, :pullup)
+    part.start_read
+  end
+end

data/test/behaviors/bus_controller_addressed_test.rb

@@ -0,0 +1,40 @@
+require_relative '../test_helper'
+
+class AddressedBus
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusControllerAddressed
+end
+
+class AddressedPeripheral
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusPeripheralAddressed
+end
+
+class BusControllerAddressedTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= AddressedBus.new(board: board)
+  end
+  
+  def test_has_mutex
+    assert_equal part.mutex.class, Mutex
+  end
+  
+  def test_components
+    peripheral = AddressedPeripheral.new(bus: part, address: 1)
+    assert_equal part.components, [peripheral]
+    
+    part.remove_component peripheral
+    assert_equal part.components, []
+  end
+
+  def test_prevents_duplicate_addresses
+    AddressedPeripheral.new(bus: part, address: 1)
+    assert_raises do
+      AddressedPeripheral.new(bus: part, address: 1)
+    end
+  end
+end

data/test/behaviors/bus_controller_test.rb

@@ -0,0 +1,28 @@
+require_relative '../test_helper'
+
+class NoAddressController
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusController
+end
+
+class BusControllerTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= NoAddressController.new(board: board)
+  end
+  
+  def test_has_mutex
+    assert_equal Mutex, part.mutex.class
+  end
+  
+  def test_components
+    part.add_component "1"
+    assert_equal part.components, ["1"]
+    
+    part.remove_component "1"
+    assert_equal part.components, []
+  end
+end

data/test/behaviors/bus_peripheral_addressed.rb

@@ -0,0 +1,44 @@
+require_relative '../test_helper'
+
+class AddressedBus
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusControllerAddressed
+end
+
+class AddressedPeripheral
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusPeripheralAddressed
+end
+
+class BusPeripheralAddressedTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    @bus ||= AddressedBus.new(board: board)
+  end
+  
+  def part
+    @part ||= AddressedPeripheral.new(bus: bus, address: 0x22)
+  end
+  
+  def test_initialize
+    assert_equal part.board, bus
+    assert_equal part.address, 0x22
+  end
+  
+  def test_requires_address
+    assert_raises(ArgumentError) { AddressedPeripheral.new(bus: bus) }
+  end
+  
+  def test_can_use_bus_atomically   
+    mock = MiniTest::Mock.new
+    1.times {mock.expect(:call, nil)}
+    
+    bus.mutex.stub(:synchronize, mock) do
+      part.atomically { true; false; }
+    end
+    mock.verify
+  end
+end

data/test/behaviors/bus_peripheral_test.rb

@@ -0,0 +1,39 @@
+require_relative '../test_helper'
+
+class NoAddressController
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusController
+end
+
+class NoAddressPeripheral
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::BusPeripheral
+end
+
+class BusPeripheralTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def bus
+    @bus ||= NoAddressController.new(board: board)
+  end
+  
+  def part
+    @part ||= NoAddressPeripheral.new(bus: bus, address: 0x22)
+  end
+  
+  def test_initialize
+    assert_equal part.board, bus
+  end
+
+  def test_can_use_bus_atomically   
+    mock = MiniTest::Mock.new
+    1.times {mock.expect(:call, nil)}
+    
+    bus.mutex.stub(:synchronize, mock) do
+      part.atomically { true; false; }
+    end
+    mock.verify
+  end
+end

data/test/behaviors/callbacks_test.rb

@@ -0,0 +1,118 @@
+require_relative '../test_helper'
+
+class CallbackComponent
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::Callbacks
+
+  def pre_callback_filter(data)
+    "denko: #{data}"
+  end
+end
+
+class CallbackComponentNilFilter
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::Callbacks
+
+  def pre_callback_filter(data)
+    nil
+  end
+end
+
+class CallbacksTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= CallbackComponent.new(board: board, pin: 1)
+  end
+
+  def test_callback_mutex
+    callback = Proc.new{}
+    mock = MiniTest::Mock.new
+    3.times {mock.expect(:call, nil)}
+    
+    part.callback_mutex.stub(:synchronize, mock) do
+      part.callbacks
+      part.add_callback(:key, &callback)
+      part.remove_callbacks(:key)
+    end
+    mock.verify
+  end
+
+  def test_add_callback
+    callback = Proc.new{}
+    part.add_callback(&callback)
+    assert_equal part.callbacks, {persistent: [callback]}
+  end
+
+  def test_add_callback_with_key
+    callback = Proc.new{}
+    part.add_callback(:key, &callback)
+    assert_equal({key: [callback]}, part.callbacks)
+  end
+
+  def add_two_callbacks
+    @callback1 = Proc.new{}
+    @callback2 = Proc.new{}
+    part.add_callback(&@callback1)
+    part.add_callback(:read, &@callback2)
+  end
+
+  def test_remove_callback
+    add_two_callbacks
+    part.remove_callbacks
+    assert_equal({}, part.callbacks)
+  end
+
+  def test_remove_callback_with_key
+    add_two_callbacks
+    part.remove_callbacks(:read)
+    assert_nil part.callbacks[:read]
+    assert_equal [@callback1], part.callbacks[:persistent]
+  end
+
+  def test_update_runs_callbacks_and_removes_read_callbacks
+    cb1 = MiniTest::Mock.new.expect :call, nil
+    cb2 = MiniTest::Mock.new.expect :call, nil
+    part.add_callback        { cb1.call }
+    part.add_callback(:read) { cb2.call }
+    part.update("data")
+    assert_nil part.callbacks[:read]
+    cb1.verify
+    cb2.verify
+  end
+
+  def test_pre_callback_filter_modifies_data
+    cb = MiniTest::Mock.new.expect :call, nil, ["denko: value"]
+    part.add_callback { |x| cb.call(x) }
+    part.update("value")
+    cb.verify
+  end
+
+  def test_update_state
+    part.update("test")
+    assert_equal "denko: test", part.state
+  end
+
+  def test_no_state_update_when_data_nil
+    part.update("test")
+    part.update(nil)
+    assert_equal "denko: test", part.state
+  end
+
+  def test_no_callback_with_data_input_nil
+    value = 0
+    part.add_callback { value = 1 }
+    part.update(nil)
+    assert_equal 0, value 
+  end
+
+  def test_no_callbacks_with_filter_returning_nil
+    part2 = CallbackComponentNilFilter.new(board: board, pin: 2)
+    value = 0
+    part2.add_callback { value = 1 }
+    part2.update("anything")
+    assert_equal 0, value 
+  end
+end

data/test/behaviors/component_test.rb

@@ -0,0 +1,56 @@
+require_relative '../test_helper'
+
+class BaseComponent
+  include Denko::Behaviors::Component
+end
+
+class ComponentTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+  
+  def part
+    @part ||= BaseComponent.new(board: board)
+  end
+
+  def test_requires_board
+    assert_raises(ArgumentError) { BaseComponent.new }
+  end
+
+  def test_registers_with_board
+    assert_equal board.components, [part]
+  end
+  
+  def test_unregisters_with_board
+    part.send(:unregister)
+    assert_equal board.components, []
+  end
+  
+  def test_start_with_nil_state
+    assert_nil BaseComponent.new(board: board).state
+  end
+  
+  def test_sets_and_gets_state
+    part.send(:state=, 10)
+    assert_equal part.state, 10
+  end
+  
+  def test_state_through_mutex
+    mock = MiniTest::Mock.new
+    2.times {mock.expect(:call, nil)}
+    
+    part.instance_variable_get(:@state_mutex).stub(:synchronize, mock) do
+      part.state
+      part.send(:state=, nil)
+    end
+    mock.verify
+  end
+  
+  def test_micro_delay
+    mock = MiniTest::Mock.new.expect :call, nil, [1000]
+    
+    board.stub(:micro_delay, mock) do
+      part.micro_delay(1000)
+    end
+  end
+end