denko 0.13.6 → 0.15.0

data/lib/denko/board/spi.rb

@@ -1,45 +1,49 @@
 module Denko
   class Board
-    def spi_header_generic(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 7 of settings toggles MSBFIRST (1) or LSBFIRST (0) for both read and write.
-      settings = settings | 0b10000000 unless bit_order == :lsbfirst
+      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
 
-    def spi_header(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
+      # 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)
 
-      # Get the generic part of the SPI header. 
-      header = spi_header_generic(write, read, mode, bit_order)
+      # Generic portion (first 4 bytes), used by both hardware and bit bang SPI.
+      pack :uint8, [settings, read & 0xFF, write.length & 0xFF, shared_byte]
+    end
+
+    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(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?)
+    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(write, read, frequency, mode, bit_order)
+      header = spi_header(select_pin, write, read, frequency, mode, bit_order)
 
       self.write Message.encode command: 26,
                                 pin: select_pin,
@@ -47,11 +51,12 @@ module Denko
     end
 
     # CMD = 27
-    def spi_listen(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)
 
-      header = spi_header([], read, frequency, mode, bit_order)
-      
       self.write Message.encode command: 27,
                                 pin: select_pin,
                                 aux_message: header

data/lib/denko/board/spi_bit_bang.rb

@@ -1,26 +1,24 @@
 module Denko
   class Board
-    def spi_bb_header(clock, input, output, write, read, mode, bit_order)
-      # Validate clock and data pins
-      raise ArgumentError, "no clock pin given" unless clock
-      raise ArgumentError, "no input or output pin given. Require either or both" 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
-      ouptut ||= 255
+      output ||= 255
 
-      # Get the generic part of the SPI header. 
-      header = spi_header_generic(write, read, mode, bit_order)
-
-      # Generic header + packed pins + empty byte = bit bang SPI bheader.
+      # Generic header + packed pins + empty byte = bit bang SPI header.
+      header = spi_header_generic(select_pin, write, read, mode, bit_order)
       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?)
+    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, write, read, mode, bit_order)
+      header = spi_bb_header(clock, input, output, select_pin, write, read, mode, bit_order)
 
       self.write Message.encode command: 21,
                                 pin: select_pin,
@@ -28,10 +26,11 @@ 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, [], read, mode, bit_order)
+      header = spi_bb_header(clock, input, nil, select_pin, [], read, mode, bit_order)
 
       self.write Message.encode command: 22,
                                 pin: select_pin,

data/lib/denko/board.rb

@@ -3,28 +3,31 @@ Dir["#{Denko.root}/lib/denko/board/*.rb"].each { |file| require file }
 
 module Denko
   class Board
-    attr_reader :name, :version, :serial_buffer_size, :aux_limit, :eeprom_length
-    attr_reader :low, :high, :analog_write_high, :analog_read_high
+    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 initialize(transport, options={})
+    def platform
+      :arduino
+    end
+
+    def initialize(connection, options={})
       # Shake hands
-      @transport = transport
-      ack = transport.handshake
+      @connection = connection
+      ack = connection.handshake
 
       # Split handshake acknowledgement into separate values.
       @name, @version, @serial_buffer_size, @aux_limit, @eeprom_length, @i2c_limit = ack.split(",")
 
-      # Tell transport how much serial buffer the board has, for flow control.
+      # Tell connection how much serial buffer the board has, for flow control.
       @serial_buffer_size = @serial_buffer_size.to_i
       raise StandardError, "no serial buffer size given in handshake" if @serial_buffer_size < 1
-      @transport.remote_buffer_size = @serial_buffer_size
+      @connection.remote_buffer_size = @serial_buffer_size
 
       # Load board map by name.
       @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.
@@ -35,62 +38,54 @@ module Denko
       @version       = nil if @version.empty?
       @eeprom_length = @eeprom_length.to_i
 
-      # Transport calls #update on board when data is received.
-      transport.add_observer(self)
-      
+      # connection calls #update on board when data is received.
+      connection.add_observer(self)
+
       # Set digital and analog IO levels.
       @low  = 0
       @high = 1
       self.analog_write_resolution = options[:write_bits] || 8
       self.analog_read_resolution  = options[:read_bits]  || 10
     end
-    
+
     def finish_write
-      sleep 0.001 while @transport.writing?
+      sleep 0.001 while @connection.writing?
       write "\n91\n"
-      sleep 0.001 while @transport.writing?
+      sleep 0.001 while @connection.writing?
     end
-          
+
     def analog_write_resolution=(value)
       set_analog_write_resolution(value)
-      @write_bits = value
-      @analog_write_high = (2 ** @write_bits) - 1
+      @analog_write_resolution = value
+      @analog_write_high = (2 ** @analog_write_resolution) - 1
     end
-    
+
     def analog_read_resolution=(value)
       set_analog_read_resolution(value)
-      @read_bits = value
-      @analog_read_high = (2 ** @read_bits) - 1
-    end
-    
-    def analog_write_resolution
-      @write_bits
+      @analog_read_resolution = value
+      @analog_read_high = (2 ** @analog_read_resolution) - 1
     end
 
-    def analog_read_resolution
-      @read_bits
-    end
-    
     alias :pwm_high :analog_write_high
     alias :dac_high :analog_write_high
     alias :adc_high :analog_read_high
-    
+
     def write(msg)
-      @transport.write(msg)
+      @connection.write(msg)
     end
 
     #
     # Use Board#write_and_halt to call C++ board functions that disable interrupts
     # for a long time. "Long" being more than 1 serial character (~85us for 115200 baud).
     #
-    # The "halt" part tells the TxRx to halt transmission to the board after this message.
+    # The "halt" part tells the Connection to halt transmission to the board after this message.
     # Since it expects interrupts to be disabled, any data sent could be lost.
-    #  
+    #
     # When the board function has re-enabled interrupts, it should call sendReady(). That
-    # signal is read by the TxRx, telling it to resume transmisison.
+    # signal is read by the Connection, telling it to resume transmisison.
     #
     def write_and_halt(msg)
-      @transport.write(msg, true)
+      @connection.write(msg, true)
     end
 
     #
@@ -100,6 +95,16 @@ module Denko
 
     def update(line)
       pin, message = line.split(":", 2)
+
+      # Handle messages from hardware I2C buses.
+      match = pin.match /\AI2C(\d*)/
+      if match
+        dev_index = match[1].to_i
+        dev = hw_i2c_comps[dev_index]
+        dev.update(message) if dev
+        return
+      end
+
       pin = pin.to_i
       if single_pin_components[pin]
         single_pin_components[pin].update(message)
@@ -111,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/binary_echo.rb

@@ -0,0 +1,17 @@
+module Denko
+  module Connection
+    class BinaryEcho
+      include Behaviors::SinglePin
+      include Behaviors::Reader
+
+      def test_range(min:0, max:255)
+        bytes = (min..max).to_a
+        board.binary_echo(pin, bytes)
+      end
+
+      def test_array(arr)
+        board.binary_echo(pin, arr)
+      end
+    end
+  end
+end

data/lib/denko/connection/flow_control.rb

@@ -8,8 +8,8 @@ module Denko
         @transit_mutex.synchronize { @remote_buffer_size = size }
       end
 
-      def initialize(*args)
-        super(*args)
+      def initialize(*args, **kwargs)
+        super(*args, **kwargs)
         # Start with minimum known buffer size. Board will update after handshake.
         # WARNING: If not updated, and ack threshold on the board is > minimum,
         # FlowControl will stop sending data, and appear to hang. Fix this.
@@ -27,7 +27,7 @@ module Denko
           @tx_halt_points << @write_buffer.length if tx_halt_after
         end
       end
-      
+
       def writing?
         @write_buffer_mutex.synchronize { !@write_buffer.empty? }
       end
@@ -41,17 +41,16 @@ module Denko
 
         @write_buffer_mutex ||= Mutex.new
         @write_buffer_mutex.synchronize do
-          @write_buffer = ""
+          @write_buffer = String.new
           @tx_halt_points = []
         end
       end
-      
+
       def write_from_buffer
         fragment = nil
         halt_after_fragment = false
 
         @write_buffer_mutex.synchronize do
-          # Nothing to write.
           break if @write_buffer.empty?
 
           # Try to send the entire buffer unless a halt point is coming up.
@@ -80,12 +79,10 @@ module Denko
           end
         end
 
-        # If no fragment, wait.
         return wait unless fragment
 
-        # If fragment, write it.
         loop do
-          # Write and end loop if the board is ready.
+          # Write fragment if @tx_ready.
           @tx_ready_mutex.synchronize do
             if @tx_ready
               _write fragment
@@ -110,7 +107,7 @@ module Denko
 
       def read
         line = _read
-        
+
         if line
           case line[0..2]
           # Board read (freed) this many bytes from its input buffer.
@@ -142,19 +139,18 @@ module Denko
       end
 
       def tx_halt
-        @tx_ready_mutex.synchronize { @tx_ready = false } 
+        @tx_ready_mutex.synchronize { @tx_ready = false }
       end
 
       def tx_resume
         @tx_ready_mutex.synchronize { @tx_ready = true }
       end
 
-      def add_transit_bytes(value)
-        @transit_mutex.synchronize { @transit_bytes = @transit_bytes + value }
-      end
-
       def remove_transit_bytes(value)
-        @transit_mutex.synchronize { @transit_bytes = @transit_bytes - value }
+        @transit_mutex.synchronize do
+          @transit_bytes = @transit_bytes - value
+          @transit_bytes = 0 if @transit_bytes < 0
+        end
       end
     end
   end

data/lib/denko/connection/handshake.rb

@@ -22,7 +22,9 @@ module Denko
       HANDSHAKE_TIMEOUT = 2
 
       def handshake
+        _write Message.encode(command: 90)
         io_reset
+
         HANDSHAKE_TRIES.times do |retries|
           begin
             print "Sending handshake to: #{self.to_s}... "

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/button.rb

@@ -1,6 +1,10 @@
 module Denko
   module DigitalIO
     class Button < Input
+      before_initialize do
+        params[:divider] = 1
+      end
+
       alias :down :on_low
       alias :up   :on_high
     end

data/lib/denko/digital_io/c_bit_bang.rb

@@ -0,0 +1,15 @@
+module Denko
+  module DigitalIO
+    class CBitBang
+      include Behaviors::SinglePin
+      include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+
+      # This is purely to force initialize validation for any pins
+      # being used by C libraries that bit-bang.
+      before_initialize do
+        params[:mode] ||= :input
+      end
+    end
+  end
+end

data/lib/denko/digital_io/input.rb

@@ -5,11 +5,10 @@ module Denko
       include Behaviors::Reader
       include Behaviors::Poller
       include Behaviors::Listener
+      include Behaviors::Lifecycle
 
-      def after_initialize(options={})
-        super(options)
-        @divider = 4
-        _listen
+      after_initialize do
+        _listen(params[:divider] || 4)
       end
 
       def _read
@@ -32,7 +31,7 @@ module Denko
           block.call(data) if data.to_i == board.low
         end
       end
-      
+
       def pre_callback_filter(value)
         value.to_i
       end

data/lib/denko/digital_io/output.rb

@@ -4,22 +4,31 @@ module Denko
       include Behaviors::OutputPin
       include Behaviors::Callbacks
       include Behaviors::Threaded
+      include Behaviors::Lifecycle
+
       interrupt_with :digital_write
 
-      def after_initialize(options={})
-        super(options)
-        board.digital_read(pin)
+      after_initialize do
+        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
 
       def low
@@ -33,13 +42,13 @@ module Denko
       def toggle
         state == board.low ? high : low
       end
-      
+
       alias :off :low
       alias :on  :high
-      
+
       def high?; state == board.high end
       def low?;  state == board.low  end
-      
+
       alias :on?  :high?
       alias :off? :low?
     end

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/relay.rb

@@ -1,6 +1,8 @@
 module Denko
   module DigitalIO
     class Relay < Output
+      alias :open  :off
+      alias :close :on
     end
   end
 end