denko 0.13.6 → 0.15.0

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,33 @@
+module Denko
+  module SPI
+    module BusCommon
+      include Behaviors::BusController
+      include Behaviors::Reader
+
+      # Add peripheral to self and the board. It gets callbacks directly from the board.
+      def add_component(component)
+        # Don't check for select pin uniqueness. Board handles that.
+        components << component
+      end
+
+      # Remove peripheral from self and the board.
+      def remove_component(component)
+        components.delete(component)
+      end
+
+      # Pass through to the real board for converting select/other pins.
+      def convert_pin(*args, **kwargs)
+        board.convert_pin(*args, **kwargs)
+      end
+
+      def set_pin_mode(*args, **kwargs)
+        board.set_pin_mode(*args, **kwargs)
+      end
+
+      # If a component calls #stop, that's just a call to Board#spi_stop giving its select pin.
+      def stop(*args, **kwargs)
+        board.spi_stop(*args, **kwargs)
+      end
+    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,15 @@ 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.lock
+        if @callbacks && !@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
@@ -93,16 +96,19 @@ module Denko
           # Remove both :read and :force update while inside the lock.
           @callbacks.delete(:read)
           @callbacks.delete(:force_update)
-        }
-        @state = bits
+        end
+        @callback_mutex.unlock
+
+        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,66 +1,60 @@
 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.lock
+        if @state != @previous_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
+          spi_write(bytes)
+          @previous_state = @state.dup
         end
-        spi_write(bytes)
+        @state_mutex.unlock
+        @state
       end
 
       #
       # 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 bit_set(pin, value)
+        @state_mutex.lock
+        @state[pin] = value
+        @state_mutex.unlock
+        value
       end
-      
+
       def digital_read(pin)
         state[pin]
       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 pin_is_pwm?(pin)
+        false
       end
     end
   end

data/lib/denko/spi/peripheral.rb

@@ -1,42 +1,109 @@
 module Denko
   module SPI
-    module Peripheral
-      include Behaviors::OutputPin
+    class ChipSelect
+      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 !Denko.mruby? && Object.const_defined?("Denko::PiBoard")
+          board = params[:board]
+          if board.class.ancestors.include?(Denko::PiBoard)
+            params[:mode] = nil
+          end
+        end
+      end
+    end
+
+    module Peripheral
+      include Behaviors::MultiPin
       include Behaviors::BusPeripheral
+      include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+
+      # We have the SPI bus set as our board, but the select pin,
+      # and any other pins, need to attach to the underlying board.
+      def proxy_pin(*args, **kwargs)
+        kwargs[:board] = bus.board
+        super(*args, **kwargs)
+      end
 
-      attr_reader :spi_frequency, :spi_mode, :spi_bit_order
+      # If given just one value in pin:, treat that as the select pin.
+      before_initialize do
+        if (params[:pin].class != Hash) && (!params[:pins])
+          params[:pins] = { select: params[:pin] }
+          params[:pin] = nil
+        end
+      end
 
-      def before_initialize(options={})
-        super(options)
+      # Chip select pin is always treated as a subcomponent
+      def initialize_pins(params={})
+        super(params)
+        proxy_pin :select, ChipSelect, mode: :output
+      end
 
-        # Save SPI settings.
-        @spi_frequency  = options[:spi_frequency]
-        @spi_mode       = options[:spi_mode]
-        @spi_bit_order  = options[:spi_bit_order]
+      # SelectPin is a separate component that receives updates from Board.
+      # Forward them to the Peripheral
+      after_initialize do
+        select.add_callback(:peripheral_forwarder) { |data| self.update(data) }
       end
 
+      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
+
+      #
+      # SPI Properties
+      #
+      def spi_frequency
+        @spi_frequency ||= params[:spi_frequency] || 1_000_000
+      end
+
+      def spi_mode
+        @spi_mode ||= params[:spi_mode] || 0
+      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(pin, write: write, read: read, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        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(pin, write: byte_array, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        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(pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        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(pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
+        bus.listen(select.pin, read: num_bytes, frequency: spi_frequency, mode: spi_mode, bit_order: spi_bit_order)
       end
 
       def spi_stop
-        bus.stop(pin)
+        bus.stop(select.pin)
       end
     end
   end

data/lib/denko/spi.rb

@@ -1,10 +1,25 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+SPI_FILES = [
+  [:BusCommon,      "bus_common"],
+  [:Bus,            "bus"],
+  [:BitBang,        "bit_bang"],
+  [:ChipSelect,     "peripheral"],
+  [:Peripheral,     "peripheral"],
+  [:BaseRegister,   "base_register"],
+  [:InputRegister,  "input_register"],
+  [:OutputRegister, "output_register"],
+]
+
 module Denko
   module SPI
-    autoload :Bus,            "#{__dir__}/spi/bus"
-    autoload :BitBang,        "#{__dir__}/spi/bit_bang"
-    autoload :Peripheral,     "#{__dir__}/spi/peripheral"
-    autoload :BaseRegister,   "#{__dir__}/spi/base_register"
-    autoload :InputRegister,  "#{__dir__}/spi/input_register"
-    autoload :OutputRegister, "#{__dir__}/spi/output_register"
+    SPI_FILES.each do |file|
+      file_path = "#{__dir__}/spi/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/uart/bit_bang.rb

@@ -3,12 +3,15 @@ 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
+      include Common
+
       attr_reader :baud
 
       def initialize_pins(options={})
@@ -16,36 +19,10 @@ module Denko
         proxy_pin(:rx, UARTRxPin)
       end
 
-      def after_initialize(options={})
+      after_initialize do
         hook_rx_callback
         initialize_buffer
-        start(options[:baud] || 9600)
-      end
-
-      def initialize_buffer
-        @buffer       = ""
-        @buffer_mutex = Mutex.new
-        self.add_callback(:buffer) do |data|
-          @buffer_mutex.synchronize do
-            @buffer = "#{@buffer}#{data}"
-          end
-        end
-      end
-
-      def gets
-        @buffer_mutex.synchronize do
-          newline = @buffer.index("\n")
-          return nil unless newline
-          line = @buffer[0..newline-1]
-          @buffer = @buffer[newline+1..-1]
-          return line
-        end
-      end
-
-      def flush
-        @buffer_mutex.synchronize do
-          @buffer = ""
-        end
+        start(params[:baud] || 9600)
       end
 
       def start(baud)
@@ -62,7 +39,7 @@ module Denko
       end
 
       def hook_rx_callback
-        rx.add_callback {|data| self.update(data)}
+        rx.add_callback { |data| self.update(data) }
       end
     end
   end

data/lib/denko/uart/common.rb

@@ -0,0 +1,33 @@
+module Denko
+  module UART
+    module Common
+      def initialize_buffer
+        @buffer       = String.new
+        @buffer_mutex = Denko.gil? ? Denko::MutexStub.new : Mutex.new
+        self.add_callback(:buffer) do |data|
+          @buffer_mutex.lock
+          @buffer = "#{@buffer}#{data}"
+          @buffer_mutex.unlock
+        end
+      end
+
+      def gets
+        line = nil
+        @buffer_mutex.lock
+        newline = @buffer.index("\n")
+        if newline
+          line = @buffer[0..newline-1]
+          @buffer = @buffer[newline+1..-1]
+        end
+        @buffer_mutex.unlock
+        line
+      end
+
+      def flush
+        @buffer_mutex.lock
+        @buffer = ""
+        @buffer_mutex.unlock
+      end
+    end
+  end
+end

data/lib/denko/uart/hardware.rb

@@ -3,49 +3,25 @@ module Denko
     class Hardware
       include Behaviors::SinglePin
       include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+      include Common
 
       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)
-      end
-
-      def initialize_buffer
-        @buffer       = ""
-        @buffer_mutex = Mutex.new
-        self.add_callback(:buffer) do |data|
-          @buffer_mutex.synchronize do
-            @buffer = "#{@buffer}#{data}"
-          end
-        end
-      end
-
-      def gets
-        @buffer_mutex.synchronize do
-          newline = @buffer.index("\n")
-          return nil unless newline
-          line = @buffer[0..newline-1]
-          @buffer = @buffer[newline+1..-1]
-          return line
-        end
-      end
-
-      def flush
-        @buffer_mutex.synchronize do
-          @buffer = ""
-        end
+        start(params[:baud] ||= 9600)
       end
 
       def start(baud)

data/lib/denko/uart.rb

@@ -1,6 +1,20 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+UART_FILES = [
+  [nil,        "common"],
+  [:Hardware,  "hardware"],
+  [:BitBang,   "bit_bang"],
+]
+
 module Denko
   module UART
-    autoload :Hardware, "#{__dir__}/uart/hardware"
-    autoload :BitBang,  "#{__dir__}/uart/bit_bang"
+    UART_FILES.each do |file|
+      file_path = "#{__dir__}/uart/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/version.rb

@@ -1,3 +1,3 @@
 module Denko
-  VERSION = "0.13.6"
+  VERSION = "0.15.0"
 end