denko 0.14.0 → 0.15.0

data/lib/denko/board/spi.rb

@@ -1,47 +1,47 @@
 module Denko
   class Board
-    def spi_header_generic(select_pin, write, read, mode, bit_order)
-      # Defaults.
-      mode      ||= 0
-      bit_order ||= :msbfrst
+    # Use all of the board's aux buffer, except 8 bytes for header, or default to 512.
+    # NOTE: SPI lengths are sent as 12-bit, so hard upper limit of 4095.
+    def spi_limit
+      @spi_limit ||= aux_limit ? aux_limit-8 : 512
+    end
 
-      raise ArgumentError, "can't read more than 255 SPI bytes at a time" if read > 255
-      raise ArgumentError, "can't write more than 255 SPI bytes at a time" if write.length > 255
+    def spi_header_generic(select_pin, write, read, mode=0, bit_order=:msbfirst)
+      raise ArgumentError, "can't read more than #{spi_limit} SPI bytes at a time" if read > spi_limit
+      raise ArgumentError, "can't write more than #{spi_limit} SPI bytes at a time" if write.length > spi_limit
 
-      # Lowest 2 bits of settings control the SPI mode.
+      # Lowest 2 bits of settings hold the SPI mode number.
+      raise ArgumentError, "invalid SPI mode: #{mode}. Must be 0, 1, 2, or 3" unless (0..3).include? mode
       settings = mode
-      unless (0..3).include? settings
-        raise ArgumentError, "invalid SPI mode: #{settings.inspect}. Must be 0, 1, 2, or 3"
-      end
-
-      # Bit 6 of settings indicates wiether a select pin needs to be toggled.
-      settings |= 0b01000000 if select_pin
 
       # Bit 7 of settings toggles MSBFIRST (1) or LSBFIRST (0) for both read and write.
       settings |= 0b10000000 unless bit_order == :lsbfirst
 
-      # Return generic portion of header (used by both hardware and bit bang SPI).
-      pack(:uint8, [settings, read, write.length])
-    end
+      # Bit 6 of settings indicates whether a select pin needs to be toggled.
+      settings |= 0b01000000 if select_pin
+
+      # 3 bytes are available for read and write length, so 12-bits each.
+      # Bytes 1 and 2 are lower 8 bits for read and write respectively.
+      # Byte 3 is shared: upper 4 hold read[8..12], lower 4 hold write.length[8..12]
+      shared_byte = ((read & 0xF00) >> 4) | ((write.length & 0xF00) >> 8)
 
-    def spi_header(select_pin, write, read, frequency, mode, bit_order)
-      # Set default frequency and validate.
-      frequency ||= 1000000
-      unless [Integer, Float].include? frequency.class
-        raise ArgumentError, "error in SPI frequency: #{frequency.inspect}"
-      end
+      # Generic portion (first 4 bytes), used by both hardware and bit bang SPI.
+      pack :uint8, [settings, read & 0xFF, write.length & 0xFF, shared_byte]
+    end
 
-      # Get the generic part of the SPI header.
-      header = spi_header_generic(select_pin, write, read, mode, bit_order)
+    def spi_header(select_pin, write, read, frequency=1_000_000, mode=0, bit_order=:msbfirst)
+      raise ArgumentError, "error in SPI frequency: #{frequency}" unless [Integer, Float].include?(frequency.class)
+      frequency = frequency.to_i
 
       # Generic header + packed frequency = hardware SPI header.
-      header + pack(:uint32, frequency)
+      header  = spi_header_generic(select_pin, write, read, mode, bit_order)
+      header += pack(:uint32, frequency)
     end
 
     # CMD = 26
-    def spi_transfer(spi_index, select_pin, write: [], read: 0, frequency: nil, mode: nil, bit_order: nil)
-      raise ArgumentError, "no bytes given to read or write" if (read == 0) && (write.empty?)
-      raise ArgumentError, "select_pin cannot be nil when reading or listening" if (read != 0) && (select_pin == nil)
+    def spi_transfer(spi_index, select_pin, write: [], read: 0, frequency: 1_000_000, mode: 0, bit_order: :msbfirst)
+      raise ArgumentError, "no bytes given to read or write" if (read <= 0) && (write.empty?)
+      raise ArgumentError, "select_pin cannot be nil when reading or listening" if (read > 0) && (select_pin == nil)
 
       header = spi_header(select_pin, write, read, frequency, mode, bit_order)
 
@@ -51,8 +51,8 @@ module Denko
     end
 
     # CMD = 27
-    def spi_listen(spi_index, select_pin, read: 0, frequency: nil, mode: nil, bit_order: nil)
-      raise ArgumentError, 'no bytes to read. Give read: argument > 0' unless (read > 0)
+    def spi_listen(spi_index, select_pin, read: 0, frequency: 1_000_000, mode: 0, bit_order: :msbfirst)
+      raise ArgumentError, 'no bytes to read. Give read: argument > 0' unless (read.class == Integer) && (read > 0)
       raise ArgumentError, "select_pin cannot be nil when reading or listening" if (select_pin == nil)
 
       header = spi_header(select_pin, [], read, frequency, mode, bit_order)

data/lib/denko/board/spi_bit_bang.rb

@@ -1,25 +1,22 @@
 module Denko
   class Board
-    def spi_bb_header(clock, input, output, select_pin, write, read, mode, bit_order)
-      # Validate clock and data pins
-      raise ArgumentError, "either output or input pin required" unless(input || output)
+    def spi_bb_header(clock, input, output, select_pin, write, read, mode=0, bit_order=:msbfirst)
+      raise ArgumentError, "either output or input pin required" unless (input || output)
       raise ArgumentError, "clock pin required" unless clock
 
       # Set the other to disabled if only one given.
       input  ||= 255
       output ||= 255
 
-      # Get the generic part of the SPI header. 
+      # Generic header + packed pins + empty byte = bit bang SPI header.
       header = spi_header_generic(select_pin, write, read, mode, bit_order)
-
-      # Generic header + packed pins + empty byte = bit bang SPI bheader.
       header = header + pack(:uint8, [clock, input, output, 0])
     end
 
     # CMD = 21
-    def spi_bb_transfer(select_pin, clock: nil, output: nil, input: nil, write: [], read: 0, frequency: nil, mode: nil, bit_order: nil)
-      raise ArgumentError, "no bytes given to read or write" if (read == 0) && (write.empty?)
-      raise ArgumentError, "select_pin cannot be nil when reading or listening" if (read != 0) && (select_pin == nil)
+    def spi_bb_transfer(select_pin, clock: nil, output: nil, input: nil, write: [], read: 0, frequency: nil, mode: 0, bit_order: :msbfirst)
+      raise ArgumentError, "no bytes given to read or write" if (read <= 0) && (write.empty?)
+      raise ArgumentError, "select_pin cannot be nil when reading or listening" if (read > 0) && (select_pin == nil)
 
       header = spi_bb_header(clock, input, output, select_pin, write, read, mode, bit_order)
 
@@ -29,8 +26,8 @@ module Denko
     end
 
     # CMD = 22
-    def spi_bb_listen(select_pin, clock: nil, input: nil, read: 0, frequency: nil, mode: nil, bit_order: nil)
-      raise ArgumentError, 'no bytes to read. Give read: argument > 0' unless (read > 0)
+    def spi_bb_listen(select_pin, clock: nil, input: nil, read: 0, frequency: nil, mode: 0, bit_order: :msbfirst)
+      raise ArgumentError, 'no bytes to read. Give read: argument > 0' unless (read.class == Integer) && (read > 0)
       raise ArgumentError, "select_pin cannot be nil when reading or listening" if (select_pin == nil)
 
       header = spi_bb_header(clock, input, nil, select_pin, [], read, mode, bit_order)

data/lib/denko/board.rb

@@ -6,6 +6,10 @@ module Denko
     attr_reader :name, :version, :serial_buffer_size, :aux_limit, :eeprom_length, :i2c_limit
     attr_reader :low, :high, :analog_write_resolution, :analog_read_resolution, :analog_write_high, :analog_read_high
 
+    def platform
+      :arduino
+    end
+
     def initialize(connection, options={})
       # Shake hands
       @connection = connection
@@ -23,8 +27,7 @@ module Denko
       @name = nil if @name.empty?
       load_map(@name)
 
-      # Leave room for null termination of aux messages.
-      @aux_limit = @aux_limit.to_i - 1
+      @aux_limit = @aux_limit.to_i
 
       # Set I2C transaction size limit. Safe minimum is 32.
       # This makes I2C fail silently if board does not implement.
@@ -113,7 +116,7 @@ module Denko
     #
     def eeprom
       raise StandardError, 'board has no built-in EEPROM, or EEPROM disabled in sketch' if @eeprom_length == 0
-      @eeprom ||= EEPROM::BuiltIn.new(board: self)
+      @eeprom ||= EEPROM::Board.new(board: self)
     end
   end
 end

data/lib/denko/connection/flow_control.rb

@@ -41,7 +41,7 @@ module Denko
 
         @write_buffer_mutex ||= Mutex.new
         @write_buffer_mutex.synchronize do
-          @write_buffer = ""
+          @write_buffer = String.new
           @tx_halt_points = []
         end
       end

data/lib/denko/connection/serial.rb

@@ -6,10 +6,10 @@ module Denko
       BAUD = 115200
 
       def initialize(options={})
-        @device = options[:device]
-        @baud = options[:baud] || BAUD
-        @rx_buffer = ""
-        @rx_line = ""
+        @device     = options[:device]
+        @baud       = options[:baud] || BAUD
+        @rx_buffer  = String.new
+        @rx_line    = String.new
         @rx_escaped = false
       end
 
@@ -36,7 +36,7 @@ module Denko
           else
             if (char == "\n")
               line = @rx_line
-              @rx_line = ""
+              @rx_line = String.new
               return line
             elsif (char == "\\")
               @rx_escaped = true

data/lib/denko/digital_io/output.rb

@@ -9,16 +9,24 @@ module Denko
       interrupt_with :digital_write
 
       after_initialize do
-        board.digital_read(pin)
+        board.digital_read(pin) unless @board.platform == :linux_milkv_duo
       end
 
       def pre_callback_filter(board_state)
         board_state.to_i
       end
 
-      def digital_write(value)
-        @board.digital_write(@pin, value)
-        self.state = value
+      # mruby optimization. Bypass #state= setter.
+      if Denko.mruby?
+        def digital_write(value)
+          @board.digital_write(@pin, value)
+          @state = value
+        end
+      else
+        def digital_write(value)
+          @board.digital_write(@pin, value)
+          self.state = value
+        end
       end
 
       alias :write :digital_write

data/lib/denko/digital_io/pcf8574.rb

@@ -0,0 +1,114 @@
+module Denko
+  module DigitalIO
+    class PCF8574
+      include I2C::Peripheral
+      include Behaviors::Lifecycle
+
+      # Default I2C address. Override with i2c_address: key in initialize hash.
+      I2C_ADDRESS   = 0x3F
+      I2C_FREQUENCY = 400_000
+
+      #
+      # 8 bit I/O expander where each read/write is a single I2C byte that gets/sets the whole register.
+      # - No separate data direction register.
+      # - Writing 1 to a bit puts that pin into high-impedance mode. It behaves as input or high output.
+      # - Writing 0 is low output.
+      # - Reading gives the actual state of the pins, regardless of direction.
+      #
+      after_initialize do
+        read_state
+      end
+
+      def write
+        bytes = []
+        @state_mutex.lock
+        if @state != @previous_state
+          @state.each_slice(8) do |slice|
+            byte = 0
+            slice.each_with_index do |bit, index|
+              next unless bit
+              byte |= (bit << index)
+            end
+
+            bytes.unshift byte
+          end
+          i2c_write bytes
+          @previous_state = @state.dup
+        end
+        @state_mutex.unlock
+        @state
+      end
+
+      def read_state
+        @state_mutex.lock
+        byte = i2c_read_raw(1)[0]
+        8.times do |i|
+          @state[i] = (byte >> i) & 0b1
+        end
+        @state_mutex.unlock
+        @state
+      end
+
+      #
+      # BoardProxy interface. Refactor maybe?
+      #
+      def platform
+        :pcf8574
+      end
+
+      def set_pin_mode(pin, mode, options={})
+        if mode == :output
+          digital_write(pin, 0)
+        else
+          digital_write(pin, 1)
+        end
+      end
+
+      def digital_read(pin)
+        state[pin]
+      end
+
+      def is_a_register?
+        true
+      end
+
+      #
+      # Taken from SPI::BaseRegister
+      #
+      include Behaviors::BoardProxy
+      #
+      # Default registers to 1 byte, or 8 pins when used as Board Proxy.
+      # Can be ignored if reading / writing the register directly.
+      def bytes
+        @bytes = params[:bytes] || 1
+      end
+      attr_writer :bytes
+      #
+      # When used as BoardProxy, store the state of each register
+      # pin as a 0 or 1 in an array that is (@bytes * 8) long.
+      #
+      def state
+        @state ||= Array.new(bytes*8) { 1 }
+      end
+
+      #
+      # Taken from SPI::Output Register.
+      #
+      def digital_write(pin, value)
+        bit_set(pin, value)
+        write
+      end
+
+      def bit_set(pin, value)
+        @state_mutex.lock
+        @state[pin] = value
+        @state_mutex.unlock
+        value
+      end
+
+      def pin_is_pwm?(pin)
+        false
+      end
+    end
+  end
+end

data/lib/denko/digital_io/rotary_encoder.rb

@@ -65,7 +65,7 @@ module Denko
       end
 
       def state
-        state_mutex.synchronize { @state ||= { count: 0, angle: 0 } }
+        @state ||= { count: 0, angle: 0 }
       end
 
       def reading
@@ -104,7 +104,10 @@ module Denko
       def pre_callback_filter(step)
         step = -step if reversed
 
-        state_mutex.synchronize { reading[:count] = @state[:count] + step }
+        @state_mutex.lock
+        reading[:count] = @state[:count] + step
+        @state_mutex.unlock
+
         reading[:change] = step
         reading[:angle]  = reading[:count] * degrees_per_count % 360
 
@@ -115,10 +118,11 @@ module Denko
       # After callbacks, set state to the hash from before, except change.
       #
       def update_state(reading)
-        state_mutex.synchronize do
-          @state[:count] = reading[:count]
-          @state[:angle] = reading[:angle]
-        end
+        @state_mutex.lock
+        @state[:count] = reading[:count]
+        @state[:angle] = reading[:angle]
+        @state_mutex.unlock
+        @state
       end
     end
   end

data/lib/denko/digital_io.rb

@@ -1,10 +1,28 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+DIGITAL_IO_FILES = [
+  [:Input,          "input"],
+  [:Output,         "output"],
+  [:Button,         "button"],
+  [:Relay,          "relay"],
+  [:RotaryEncoder,  "rotary_encoder"],
+  [:PCF8574,        "pcf8574"],
+]
+
+# On mruby, define this early since bit-bang I2C, SPI and 1-Wire depend on it.
+DIGITAL_IO_EARLY_FILES = [
+  [:CBitBang, "c_bit_bang"],
+]
+
 module Denko
   module DigitalIO
-    autoload :Input,          "#{__dir__}/digital_io/input"
-    autoload :Output,         "#{__dir__}/digital_io/output"
-    autoload :Button,         "#{__dir__}/digital_io/button"
-    autoload :Relay,          "#{__dir__}/digital_io/relay"
-    autoload :RotaryEncoder,  "#{__dir__}/digital_io/rotary_encoder"
-    autoload :CBitBang,       "#{__dir__}/digital_io/c_bit_bang"
+    (DIGITAL_IO_EARLY_FILES + DIGITAL_IO_FILES).each do |file|
+      file_path = "#{__dir__}/digital_io/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end