denko 0.13.5 → 0.14.0

data/lib/denko/spi/bit_bang.rb

@@ -2,28 +2,28 @@ module Denko
   module SPI
     class BitBang
       include Behaviors::MultiPin
-      include Behaviors::BusController
-      include Behaviors::Reader
+      include Behaviors::Lifecycle
+      include BusCommon
 
-      def initialize_pins(options={})
+      before_initialize do
+        param_pins = params[:pins]
         # Allow pin aliases.
-        pins[:input]  = pins[:input]  || pins[:poci] || pins[:miso]
-        pins[:output] = pins[:output] || pins[:pico] || pins[:mosi]
-        pins[:clock]  = pins[:clock]  || pins[:sck]  || pins[:clk]
-
-        # Clean up the pins hash.
-        [:poci, :miso, :pico, :mosi, :sck, :clk].each { |key| pins.delete(key) }
+        param_pins[:input]  = param_pins[:input]  || param_pins[:poci] || param_pins[:miso]
+        param_pins[:output] = param_pins[:output] || param_pins[:pico] || param_pins[:mosi]
+        param_pins[:clock]  = param_pins[:clock]  || param_pins[:sck]  || param_pins[:clk]
 
-        # Validate input or output pin.
-        unless pins[:input] || pins[:output]
-          raise ArgumentError, "no input or output pin given. Require either or both"
-        end
+        # Clean up the params hash.
+        [:poci, :miso, :pico, :mosi, :sck, :clk].each { |key| param_pins.delete(key) }
 
-        # If only output or input, set the other 255 for a one-directional bus.
-        pins[:input]  = 255 if pins[:output] && !pins[:input]
-        pins[:output] = 255 if pins[:input]  && !pins[:output]
+        # Validate param_pins.
+        raise ArgumentError, "either output or input pin required" unless param_pins[:input] || param_pins[:output]
+        raise ArgumentError, "clock pin required" unless param_pins[:clock]
+      end
 
-        require_pins(:clock, :input, :output)
+      def initialize_pins(options={})
+        proxy_pin :clock,   DigitalIO::CBitBang
+        proxy_pin :output,  DigitalIO::CBitBang if pins[:output]
+        proxy_pin :input,   DigitalIO::CBitBang if pins[:input]
       end
 
       def transfer(select_pin, write: [], read: 0, frequency: nil, mode: 0, bit_order: :msbfirst)
@@ -35,40 +35,6 @@ module Denko
         board.spi_bb_listen select_pin, clock: pins[:clock], input: pins[:input],
                                         read: read, mode: mode, bit_order: bit_order
       end
-
-      # Uses regular Board#spi_stop since listeners are shared.
-      def stop(pin)
-        board.spi_stop(pin)
-      end
-
-      # Delegate this to board so peripherals can initialize their select pins.
-      def set_pin_mode(*args)
-        board.set_pin_mode(*args)
-      end
-
-      def convert_pin(pin)
-        board.convert_pin(pin)
-      end
-
-      # Add peripheral to self and the board. It gets callbacks directly from the board.
-      def add_component(component)
-        # Treat pin 255 as the component having no select pin. Mostly for APA102.
-        return if component.pin == 255
-
-        pins = components.map { |c| c.pin }
-        if pins.include? component.pin
-          raise ArgumentError, "duplicate select pin for #{component}"
-        end
-
-        components << component
-        board.add_component(component)
-      end
-
-      # Remove peripheral from self and the board.
-      def remove_component(component)
-        components.delete(component)
-        board.remove_component(component)
-      end
     end
   end
 end

data/lib/denko/spi/bus.rb

@@ -1,43 +1,29 @@
 module Denko
   module SPI
     class Bus
-      include Behaviors::Component
-      include Behaviors::BusController
-      include Behaviors::Reader
+      include BusCommon
 
       # Board expects all components to have #pin.
       attr_reader :pin
 
-      # Forward some methods directly to the board.
-      extend Forwardable
-
-      # Forward SPI methods with prefixed names.
-      def_delegator :board, :spi_transfer,  :transfer
-      def_delegator :board, :spi_listen,    :listen
-      def_delegator :board, :spi_stop,      :stop
-
-      # Forward pin control methods with same names for board proxying.
-      def_delegator :board, :convert_pin
-      def_delegator :board, :set_pin_mode
-
-      # Add peripheral to self and the board. It gets callbacks directly from the board.
-      def add_component(component)
-        # Treat pin 255 as the component having no select pin. Mostly for APA102.
-        return if component.pin == 255
+      def spi_index
+        @spi_index ||= params[:spi_index] || params[:index] || 0
+      end
 
-        pins = components.map { |c| c.pin }
-        if pins.include? component.pin
-          raise ArgumentError, "duplicate select pin for #{component}"
-        end
+      # Prepend spi_index to these and forward to the board.
+      def transfer(*args, **kwargs)
+        args.unshift(spi_index)
+        board.spi_transfer(*args, **kwargs)
+      end
 
-        components << component
-        board.add_component(component)
+      def listen(*args, **kwargs)
+        args.unshift(spi_index)
+        board.spi_listen(*args, **kwargs)
       end
 
-      # Remove peripheral from self and the board.
-      def remove_component(component)
-        components.delete(component)
-        board.remove_component(component)
+      # This is for WS2812 strips on PiBoard.
+      def show_ws2812(*args)
+        board.show_ws2812(*args, spi_index: spi_index)
       end
     end
   end

data/lib/denko/spi/bus_common.rb

@@ -0,0 +1,36 @@
+module Denko
+  module SPI
+    module BusCommon
+      include Behaviors::BusController
+      include Behaviors::Reader
+      extend Forwardable
+
+      # Add peripheral to self and the board. It gets callbacks directly from the board.
+      def add_component(component)
+        # Ignore components with no select pin. Mostly for APA102.
+        return unless component.pin
+
+        pins = components.map { |c| c.pin }
+        if pins.include? component.pin
+          raise ArgumentError, "duplicate select pin for #{component}"
+        end
+
+        components << component
+        board.add_component(component)
+      end
+
+      # Remove peripheral from self and the board.
+      def remove_component(component)
+        components.delete(component)
+        board.remove_component(component)
+      end
+
+      # Forward pin control methods to the board, for select pin setup.
+      def_delegator :board, :convert_pin
+      def_delegator :board, :set_pin_mode
+
+      # If a component calls #stop, that's just a call to Board#spi_stop giving its select pin.
+      def_delegator :board, :spi_stop, :stop
+    end
+  end
+end

data/lib/denko/spi/input_register.rb

@@ -1,28 +1,30 @@
 module Denko
   module SPI
     class InputRegister < BaseRegister
+      include Behaviors::Lifecycle
 
-      def before_initialize(options={})
-        super(options)
-        #
-        # Keep track of whether anything is listening or reading a specific pin.
-        # This might be separate from whether a component is attached or not.
-        #
-        @reading_pins   = Array.new(@bytes*8) { false }
-        @listening_pins = Array.new(@bytes*8) { false }
+      #
+      # Keep track of whether anything is listening or reading a specific pin.
+      # This might be separate from whether a component is attached or not.
+      #
+      def reading_pins
+        @reading_pins ||= Array.new(bytes*8) { false }
+      end
+
+      def listening_pins
+        @listening_pins ||= Array.new(bytes*8) { false }
       end
 
-      def after_initialize(options={})
-        super(options)
+      after_initialize do
         enable_proxy
       end
 
       def read
-        spi_read(@bytes)
+        spi_read(bytes)
       end
 
       def listen
-        spi_listen(@bytes)
+        spi_listen(bytes)
       end
 
       def stop
@@ -35,7 +37,7 @@ module Denko
       def digital_read(pin)
         # Remember what pin was read and force callbacks to run next update.
         add_callback(:force_update) { Proc.new{} }
-        @reading_pins[pin] = true
+        reading_pins[pin] = true
 
         # Don't actually call #read if already listening.
         read unless any_listening
@@ -43,16 +45,16 @@ module Denko
 
       def digital_listen(pin, divider)
         listen unless any_listening
-        @listening_pins[pin] = true
+        listening_pins[pin] = true
       end
 
       def stop_listener(pin)
-        @listening_pins[pin] = false
+        listening_pins[pin] = false
         stop unless any_listening
       end
 
       def any_listening
-        @listening_pins.each { |p| return true if p }
+        listening_pins.each { |p| return true if p }
         false
       end
 
@@ -67,7 +69,7 @@ module Denko
             components.each do |part|
               update_component(part, pin, value) if pin == part.pin
             end
-            @reading_pins[pin] = false
+            reading_pins[pin] = false
           end
         end
       end
@@ -77,14 +79,17 @@ module Denko
       # within the main mutex lock.
       #
       def update(message)
-        bits = byte_array_to_bit_array(message.split(","))
-
-        @callback_mutex.synchronize {
-          #
-          # The Arduino code does not de-duplicate repeated state.
-          # Do it here, but if a :force_update callback exists, run anyway.
-          #
-          if (bits != @state)|| @callbacks[:force_update]
+        # Since overriding update, make sure this is a byte array first.
+        byte_array = ensure_byte_array(message)
+
+        bits = byte_array_to_bit_array(byte_array)
+
+        callback_mutex.synchronize {
+          break unless @callbacks
+          break if @callbacks.empty?
+
+          # Arduino doesn't de-duplicate state. Do it, but honor :force_update callbacks.
+          if (bits != state) || @callbacks[:force_update]
             @callbacks.each_value do |array|
               array.each { |callback| callback.call(bits) }
             end
@@ -94,15 +99,16 @@ module Denko
           @callbacks.delete(:read)
           @callbacks.delete(:force_update)
         }
-        @state = bits
+        self.state = bits
       end
 
       def update_component(part, pin, value)
         # Update if component is listening and value has changed.
-        if @listening_pins[pin] && (value != @state[pin])
+        if listening_pins[pin] && (value != state[pin])
           part.update(value)
         # Also update if the component forced a read.
-        elsif @reading_pins[pin] && @callbacks[:force_update]
+        # Always called inside callback_mutex, so @callbacks, not callbacks
+        elsif reading_pins[pin] && @callbacks[:force_update]
           part.update(value)
         end
       end
@@ -114,14 +120,14 @@ module Denko
       def byte_array_to_bit_array(byte_array)
         #
         # For each array element (1 byte):
-        # decimal number as string -> integer -> padded string of binary digits 
+        # decimal number as string -> integer -> padded string of binary digits
         # -> reverse digits from reading order to array indexing order
         # -> join digits of all bytes into one string
         #
         binary_string = byte_array.map do |byte|
           byte.to_i.to_s(2).rjust(8, "0").reverse
         end.join
-        
+
         # Split the digits out of the string into individual integers.
         binary_string.split("").map { |bit| bit.to_i }
       end

data/lib/denko/spi/output_register.rb

@@ -1,39 +1,33 @@
 module Denko
   module SPI
     class OutputRegister < BaseRegister
+      include Behaviors::Lifecycle
 
-      def before_initialize(options={})
-        super(options)
-        #
-        # When used as a board proxy, only write sate if @write_delay seconds
-        # have passed since this object last got input. Better for things like SSDs
-        # where many bits change in sequence, but not at exactly the same time.
-        #
-        @buffer_writes = true
-        @buffer_writes = false if options[:buffer_writes] == false
-        @write_delay = options[:write_delay] || 0.001
-      end
-      
-      def after_initialize(options={})
+      after_initialize do
+        state
         write
       end
 
       #
-      # Overrides Peripheral#write to always write @state.
+      # Overrides Peripheral#write to always write state.
       # Convert bit state to array of 0-255 integers (bytes) first.
       #
       def write
         bytes = []
-        @state.each_slice(8) do |slice|
-          # Convert nils in the slice to zero.
-          zeroed = slice.map { |bit| bit.to_i }
-          
-          # Each slice is 8 bits of a byte, with the lowest on the left.
-          # Reverse to reading order (lowest right) then join into string, and convert to integer.
-          byte = zeroed.reverse.join.to_i(2)
-          
-          # Pack bytes in reverse order.
-          bytes.unshift byte
+        state_mutex.synchronize do
+          return if @previous_state == @state
+          @state.each_slice(8) do |slice|
+            # Convert nils in the slice to zero.
+            zeroed = slice.map { |bit| bit.to_i }
+
+            # Each slice is 8 bits of a byte, with the lowest on the left.
+            # Reverse to reading order (lowest right) then join into string, and convert to integer.
+            byte = zeroed.reverse.join.to_i(2)
+
+            # Pack bytes in reverse order.
+            bytes.unshift byte
+          end
+          @previous_state = @state.dup
         end
         spi_write(bytes)
       end
@@ -42,25 +36,16 @@ module Denko
       # BoardProxy interface
       #
       def digital_write(pin, value)
-        state[pin] = value  # Might not be atomic?
-        @buffer_writes ? write_buffered(state) : write
+        bit_set(pin, value)
+        write
       end
-      
-      def digital_read(pin)
-        state[pin]
+
+      def bit_set(pin, value)
+        state_mutex.synchronize { @state[pin] = value }
       end
 
-      #
-      # If acting as board, do writes in a separate thread and with small delay.
-      # Lets us catch multiple changed bits, like when hosting an SSD.
-      #
-      include Behaviors::Threaded
-      def write_buffered(old_state)
-        threaded do
-          sleep @write_delay
-          # Keep delaying if state has changed.
-          write if (old_state == state)
-        end
+      def digital_read(pin)
+        state[pin]
       end
     end
   end

data/lib/denko/spi/peripheral.rb

@@ -1,42 +1,111 @@
 module Denko
   module SPI
     module Peripheral
-      include Behaviors::OutputPin
-      include Behaviors::Callbacks
-      include Behaviors::BusPeripheral
+      module Core
+        include Behaviors::BusPeripheral
+        include Behaviors::Callbacks
 
-      attr_reader :spi_frequency, :spi_mode, :spi_bit_order
+        def spi_frequency
+          @spi_frequency ||= params[:spi_frequency] || 1_000_000
+        end
 
-      def before_initialize(options={})
-        super(options)
+        def spi_mode
+          @spi_mode ||= params[:spi_mode] || 0
+        end
 
-        # Save SPI settings.
-        @spi_frequency  = options[:spi_frequency]
-        @spi_mode       = options[:spi_mode]
-        @spi_bit_order  = options[:spi_bit_order]
-      end
+        def spi_bit_order
+          @spi_bit_order ||= params[:spi_bit_order] || :msbfirst
+        end
+
+        attr_writer :spi_frequency, :spi_mode, :spi_bit_order
+
+        #
+        # Delegate methods to the bus.
+        #
+        def spi_transfer(write: [], read: 0)
+          bus.transfer(select_pin, write: write, read: read, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        end
+
+        def spi_write(byte_array)
+          bus.transfer(select_pin, write: byte_array, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        end
+
+        def spi_read(num_bytes)
+          bus.transfer(select_pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        end
+
+        def spi_listen(num_bytes)
+          bus.listen(select_pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        end
+
+        def spi_stop
+          bus.stop(select_pin)
+        end
 
-      #
-      # Delegate methods to the bus.
-      #
-      def spi_transfer(write: [], read: 0)
-        bus.transfer(pin, write: write, read: read, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        def ensure_byte_array(message)
+          if message.class == Array
+            # Byte array coming from PiBoard.
+            return message
+          else
+            # Split up comma delimited bytes coming from a microcontroller.
+            return message.split(",").map { |b| b.to_i }
+          end
+        end
+
+        def update(message)
+          super(ensure_byte_array(message))
+        end
       end
 
-      def spi_write(byte_array)
-        bus.transfer(pin, write: byte_array, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      module ChipSelectBehavior
+        include Behaviors::SinglePin
+        include Behaviors::Callbacks
+        include Behaviors::Lifecycle
+
+        before_initialize do
+          # It actually functions as an output.
+          params[:mode] = :output
+
+          # But we can't claim it on Linux (the SPI hardware handles it), so don't.
+          if Object.const_defined?("Denko::PiBoard")
+            bus = params[:bus] || params[:board]
+            if bus.board.class.ancestors.include?(Denko::PiBoard)
+              params[:mode] = nil
+            end
+          end
+        end
       end
 
-      def spi_read(num_bytes)
-        bus.transfer(pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      class ChipSelect
+        include ChipSelectBehavior
       end
 
-      def spi_listen(num_bytes)
-        bus.listen(pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+      module SinglePin
+        include Core
+        include ChipSelectBehavior
+
+        def select_pin
+          pin
+        end
       end
 
-      def spi_stop
-        bus.stop(pin)
+      module MultiPin
+        include Core
+        include Behaviors::MultiPin
+        include Behaviors::Lifecycle
+
+        def select_pin
+          self.select.pin
+        end
+
+        def initialize_pins(params={})
+          super(params)
+          proxy_pin :select, ChipSelect, { board: bus.board, mode: :output }
+        end
+
+        after_initialize do
+          select.add_callback(:peripheral_forwarder) { |data| self.update(data) }
+        end
       end
     end
   end

data/lib/denko/spi.rb

@@ -1,8 +1,13 @@
 module Denko
   module SPI
+    autoload :BusCommon,      "#{__dir__}/spi/bus_common"
     autoload :Bus,            "#{__dir__}/spi/bus"
     autoload :BitBang,        "#{__dir__}/spi/bit_bang"
-    autoload :Peripheral,     "#{__dir__}/spi/peripheral"
+    module Peripheral
+      autoload :Core,         "#{__dir__}/spi/peripheral"
+      autoload :SinglePin,    "#{__dir__}/spi/peripheral"
+      autoload :MultiPin,     "#{__dir__}/spi/peripheral"
+    end
     autoload :BaseRegister,   "#{__dir__}/spi/base_register"
     autoload :InputRegister,  "#{__dir__}/spi/input_register"
     autoload :OutputRegister, "#{__dir__}/spi/output_register"

data/lib/denko/uart/bit_bang.rb

@@ -3,12 +3,14 @@ module Denko
     class UARTRxPin
       include Behaviors::InputPin
       include Behaviors::Callbacks
+      include Behaviors::Lifecycle
     end
 
     class BitBang
       include Behaviors::MultiPin
       include Behaviors::Callbacks
-      
+      include Behaviors::Lifecycle
+
       attr_reader :baud
 
       def initialize_pins(options={})
@@ -16,10 +18,10 @@ module Denko
         proxy_pin(:rx, UARTRxPin)
       end
 
-      def after_initialize(options={})
+      after_initialize do
         hook_rx_callback
         initialize_buffer
-        start(options[:baud] || 9600)
+        start(params[:baud] || 9600)
       end
 
       def initialize_buffer

data/lib/denko/uart/hardware.rb

@@ -3,23 +3,24 @@ module Denko
     class Hardware
       include Behaviors::SinglePin
       include Behaviors::Callbacks
+      include Behaviors::Lifecycle
 
       attr_reader :index, :baud
-      
-      def before_initialize(options={})
-        if options[:index] && (options[:index] > 0) && (options[:index] < 4)
-          @index = options[:index]
+
+      before_initialize do
+        if params[:index] && (params[:index] > 0) && (params[:index] < 4)
+          @index = params[:index]
         else
-          raise ArgumentError, "UART index (#{options[:index]}) not given or out of range (1..3)"
+          raise ArgumentError, "UART index (#{params[:index]}) not given or out of range (1..3)"
         end
 
         # Set pin to a "virtual pin" in 251 - 253 that will match the board.
-        options[:pin] = 250 + options[:index]
+        params[:pin] = 250 + params[:index]
       end
 
-      def after_initialize(options={})
+      after_initialize do
         initialize_buffer
-        start(options[:baud] ||= 9600)
+        start(params[:baud] ||= 9600)
       end
 
       def initialize_buffer

data/lib/denko/version.rb

@@ -1,3 +1,3 @@
 module Denko
-  VERSION = "0.13.5"
+  VERSION = "0.14.0"
 end

data/lib/denko.rb

@@ -4,11 +4,18 @@ module Denko
   def self.root
     File.expand_path '../..', __FILE__
   end
+
+  def self.cruby?
+    RUBY_ENGINE == "ruby"
+  end
 end
 
 # For method delegation.
 require 'forwardable'
 
+# Bypass mutexes where possible for CRuby.
+require_relative 'denko/mutex_stub'
+
 # Component support stuff.
 require_relative 'denko/version'
 require_relative 'denko/behaviors'
@@ -37,3 +44,6 @@ require_relative 'denko/led'
 require_relative 'denko/motor'
 require_relative 'denko/rtc'
 require_relative 'denko/sensor'
+
+# Diagnostics
+require_relative 'denko/connection/binary_echo'