denko 0.13.6 → 0.14.0

data/lib/denko/board/i2c_bit_bang.rb

@@ -0,0 +1,49 @@
+module Denko
+  class Board
+    # CMD = 30
+    def i2c_bb_search(scl, sda)
+      write Message.encode command: 30,
+                           pin:     scl,
+                           value:   sda
+    end
+
+    # CMD = 31
+    def i2c_bb_write(scl, sda, address, bytes, repeated_start=false)
+      bytes = [bytes] unless bytes.class == Array
+            
+      # Use top bit of address to select stop condition (1), or repated start (0).
+      send_stop = repeated_start ? 0 : 1
+      
+      write Message.encode  command:     31,
+                            pin:         scl,
+                            value:       sda,
+                            aux_message: pack(:uint8, 0x00) + 
+                                         pack(:uint8, address | (send_stop << 7)) +
+                                         pack(:uint8, bytes.length) +
+                                         pack(:uint8, bytes)
+    end
+
+    # CMD = 32
+    def i2c_bb_read(scl, sda, address, register, read_length, repeated_start=false)
+      # Use top bit of address to select stop condition (1), or repated start (0).
+      send_stop = repeated_start ? 0 : 1
+
+      # A register address starting register address can be given (up to 4 bytes)
+      if register
+        register = [register].flatten
+        raise ArgumentError, 'maximum 4 byte register address for I2C read' if register.length > 4
+        register_packed = pack(:uint8, [register.length] + register)
+      else
+        register_packed = pack(:uint8, [0])
+      end
+
+      write Message.encode  command:      32,
+                            pin:          scl,
+                            value:        sda,
+                            aux_message:  pack(:uint8, 0x00) + 
+                                          pack(:uint8, address | (send_stop << 7)) +
+                                          pack(:uint8, read_length) +
+                                          register_packed
+    end
+  end
+end

data/lib/denko/board/infrared.rb

@@ -2,17 +2,17 @@ module Denko
   class Board
     def infrared_emit(pin, frequency, pulses)
       #
-      # Limit to 255 marks/spaces (not pairs) for now.
+      # Limit to 255 marks/spaces (not pairs).
       #
-      # Length must be 1-byte long, not literally 1
+      # Make length uint16 as well, for aligned memory access on ESP8266.
       # Pulses max is 2x255 bytes long since each is 2 bytes.
-      length = pack :uint8,  pulses.length,  max: 1
+      length = pack :uint16, pulses.length,  max: 2
       bytes  = pack :uint16, pulses, min: 1, max: 510
 
       write Message.encode command: 16,
-                          pin: pin,
-                          value: frequency,
-                          aux_message: length + bytes
+                           pin: pin,
+                           value: frequency,
+                           aux_message: length + bytes
     end
   end
 end

data/lib/denko/board/led_array.rb

@@ -1,15 +1,16 @@
 module Denko
   class Board
     def show_ws2812(pin, pixel_buffer)
-      # Settings are blank for now.
-      settings = pack :uint8, [0, 0, 0, 0]
-      
-      packed_pixels = pack :uint8, pixel_buffer
+      # ALWAYS have first 4 bytes set to 0. ESP32 crashes without this!
+      # Last 4 bytes will be settings, but not yet. Just 24-bit 800 kHz for now.
+      settings    = pack :uint8, [0, 0, 0, 0, 0, 0, 0, 0]
+
+      pixel_bytes = pack :uint8, pixel_buffer
       
       write_and_halt Message.encode command: 19,
                                     pin: pin,
                                     value: pixel_buffer.length,
-                                    aux_message: settings + packed_pixels
+                                    aux_message: settings + pixel_bytes
     end
   end
 end

data/lib/denko/board/spi.rb

@@ -1,6 +1,6 @@
 module Denko
   class Board
-    def spi_header_generic(write, read, mode, bit_order)
+    def spi_header_generic(select_pin, write, read, mode, bit_order)
       # Defaults.
       mode      ||= 0
       bit_order ||= :msbfrst
@@ -14,32 +14,36 @@ module Denko
         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 = 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
 
-    def spi_header(write, read, frequency, mode, bit_order)
+    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
 
-      # Get the generic part of the SPI header. 
-      header = spi_header_generic(write, read, mode, bit_order)
+      # Get the generic part of the SPI header.
+      header = spi_header_generic(select_pin, write, read, mode, bit_order)
 
       # Generic header + packed frequency = hardware SPI header.
       header + pack(:uint32, frequency)
     end
 
     # CMD = 26
-    def spi_transfer(select_pin, write: [], read: 0, frequency: nil, mode: nil, bit_order: nil)
+    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)
 
-      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)
+    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)
+      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,16 +1,16 @@
 module Denko
   class Board
-    def spi_bb_header(clock, input, output, write, read, mode, bit_order)
+    def spi_bb_header(clock, input, output, select_pin, 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)
+      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)
+      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])
@@ -19,8 +19,9 @@ module Denko
     # 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)
 
-      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,
@@ -30,8 +31,9 @@ module Denko
     # 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)
+      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,21 +3,21 @@ 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 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?
@@ -35,62 +35,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 +92,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)

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
@@ -45,13 +45,12 @@ module Denko
           @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/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,10 +4,11 @@ module Denko
       include Behaviors::OutputPin
       include Behaviors::Callbacks
       include Behaviors::Threaded
+      include Behaviors::Lifecycle
+
       interrupt_with :digital_write
 
-      def after_initialize(options={})
-        super(options)
+      after_initialize do
         board.digital_read(pin)
       end
 
@@ -19,7 +20,7 @@ module Denko
         @board.digital_write(@pin, value)
         self.state = value
       end
-      
+
       alias :write :digital_write
 
       def low
@@ -33,13 +34,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/relay.rb

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