denko 0.13.0

data/lib/denko/board/one_wire.rb

@@ -0,0 +1,34 @@
+module Denko
+  class Board
+    def one_wire_reset(pin, value=0)
+      write Message.encode  command: 41,
+                            pin: pin,
+                            value: value
+    end
+
+    def one_wire_search(pin, branch_mask)
+      write Message.encode  command: 42,
+                            pin: pin,
+                            aux_message: pack(:uint64, branch_mask, max: 8)
+    end
+
+    def one_wire_write(pin, parasite_power, *data)
+      bytes  = pack :uint8, data, min: 1, max: 127 # Should be 128 with 0 = 1.
+
+      # Set high bit of length if the bus must drive high after write.
+      length = bytes.length
+      length = length | 0b10000000 if parasite_power
+
+      write Message.encode  command: 43,
+                            pin: pin,
+                            value: length,
+                            aux_message: bytes
+    end
+
+    def one_wire_read(pin, num_bytes)
+      write Message.encode  command: 44,
+                            pin: pin,
+                            value: num_bytes
+    end
+  end
+end

data/lib/denko/board/pulse.rb

@@ -0,0 +1,26 @@
+module Denko
+  class Board
+    # CMD = 9
+    def pulse_read(pin, reset: false, reset_time: 0, pulse_limit: 100, timeout: 200)
+      # Validation
+      raise ArgumentError, "error in reset: #{reset}. Should be either #{high} or #{low}"         if reset && ![high, low].include?(reset)
+      raise ArgumentError, "errror in reset_time: #{reset_time}. Should be 0..65535 microseconds" if (reset_time < 0) || (reset_time > 0xFFFF)
+      raise ArgumentError, "errror in pulse_limit: #{pulse_limit}. Should be 0..255 pulses"       if (pulse_limit < 0) || (pulse_limit > 0xFF)
+      raise ArgumentError, "errror in timeout: #{timeout}. Should be 0..65535 milliseconds"       if (timeout < 0) || (timeout > 0xFFFF)
+      
+      # Bit 0 of settings mask controls whether to hold high/low for reset.
+      settings = reset ? 1 : 0
+
+      # Bit 1 of settings mask controls whether to hold high (1) or to hold low (0).
+      settings = settings | 0b10 if (reset && reset != low)
+
+      # Pack and send.
+      aux = pack :uint16, [reset_time, timeout]
+      aux << pack(:uint8, pulse_limit)
+      write Message.encode  command: 9,
+                            pin: pin,
+                            value: settings,
+                            aux_message: aux
+    end
+  end
+end

data/lib/denko/board/servo.rb

@@ -0,0 +1,22 @@
+module Denko
+  class Board
+    # CMD = 10
+    def servo_toggle(pin, value=:off, options={})
+      options[:min] ||= 544
+      options[:max] ||= 2400
+      aux = pack :uint16, [options[:min], options[:max]]
+
+      write Message.encode  command: 10,
+                            pin: pin,
+                            value: (value == :off) ? 0 : 1,
+                            aux_message: aux
+    end
+
+    # CMD = 11
+    def servo_write(pin, value=0)
+      write Message.encode  command: 11,
+                            pin: pin,
+                            aux_message: pack(:uint16, value)
+    end
+  end
+end

data/lib/denko/board/spi.rb

@@ -0,0 +1,65 @@
+module Denko
+  class Board
+    def spi_header_generic(write, read, mode, bit_order)
+      # Defaults.
+      mode      ||= 0
+      bit_order ||= :msbfrst
+
+      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
+
+      # Lowest 2 bits of settings control the SPI 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
+
+      # 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)
+      # 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)
+
+      # 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)
+      raise ArgumentError, "no bytes given to read or write" if (read == 0) && (write.empty?)
+
+      header = spi_header(write, read, frequency, mode, bit_order)
+
+      self.write Message.encode command: 26,
+                                pin: select_pin,
+                                aux_message: header + pack(:uint8, write)
+    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)
+
+      header = spi_header([], read, frequency, mode, bit_order)
+      
+      self.write Message.encode command: 27,
+                                pin: select_pin,
+                                aux_message: header
+    end
+
+    # CMD = 28
+    def spi_stop(select_pin)
+      self.write Message.encode command: 28, pin: select_pin
+    end
+  end
+end

data/lib/denko/board/spi_bit_bang.rb

@@ -0,0 +1,41 @@
+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)
+
+      # Set the other to disabled if only one given.
+      input  ||= 255
+      ouptut ||= 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.
+      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?)
+
+      header = spi_bb_header(clock, input, output, write, read, mode, bit_order)
+
+      self.write Message.encode command: 21,
+                                pin: select_pin,
+                                aux_message: header + pack(:uint8, write)
+    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)
+
+      header = spi_bb_header(clock, input, nil, [], read, mode, bit_order)
+
+      self.write Message.encode command: 22,
+                                pin: select_pin,
+                                aux_message: header
+    end
+  end
+end

data/lib/denko/board/tone.rb

@@ -0,0 +1,23 @@
+module Denko
+  class Board
+    # CMD = 17
+    def tone(pin, frequency, duration=nil)
+      raise ArgumentError, "Tone cannot generate frequencies lower than 31Hz"     if frequency < 31
+      raise ArgumentError, "Tone duration cannot be more than 65535 milliseconds" if (duration && (duration > 0xFFFF))
+
+      # Pack the frequency and optional duration as binary.
+      aux = pack(:uint16, frequency)
+      aux << pack(:uint16, duration) if duration
+
+      write Message.encode command: 17,
+                                pin: pin,
+                                value: duration ? 1 : 0,
+                                aux_message: aux
+    end
+
+    # CMD = 18
+    def no_tone(pin)
+      write Message.encode command: 18, pin: pin
+    end
+  end
+end

data/lib/denko/board/uart.rb

@@ -0,0 +1,42 @@
+module Denko
+  class Board
+    UART_BAUD_RATES = [
+      300, 600, 750, 1200, 2400, 4800, 9600, 19200, 31250, 38400, 57600, 74880, 115200, 230400
+    ]
+
+    # CMD = 14
+    def uart_start(index, baud, listening=true)
+      raise ArgumentError, "given UART: #{index} out of range. Only 1..3 supported" if (index < 1 || index > 3)
+      unless UART_BAUD_RATES.include?(baud)
+        raise ArgumentError, "given baud rate: #{baud} not supported. Must be in #{UART_BAUD_RATES.inspect}"
+      end
+
+      config  = index | 0b01000000
+      config |= 0b10000000 if listening
+
+      self.write Message.encode command:     14,
+                                pin:         config,
+                                aux_message: pack(:uint32, baud)
+    end
+
+    # CMD = 14
+    def uart_stop(index)
+      raise ArgumentError, "given UART: #{index} out of range. Only 1..3 supported" if (index < 1 || index > 3)
+      self.write Message.encode(command: 14, pin: index)
+    end
+
+    # CMD = 15
+    def uart_write(index, data)
+      raise ArgumentError, "given UART: #{index} out of range. Only 1..3 supported" if (index < 1 || index > 3)
+
+      if data.class == Array
+        data = pack(:uint8, data)
+      elsif data.class == String
+      else
+        raise ArgumentError, "data to write to UART should be Array of bytes or String. Given: #{data.inspect}"
+      end
+
+      self.write Message.encode(command: 15, pin: index, value: data.length, aux_message: data)
+    end
+  end
+end

data/lib/denko/board/uart_bit_bang.rb

@@ -0,0 +1,33 @@
+module Denko
+  class Board
+    # CMD = 12
+    def uart_bb_start(tx, rx, baud, listening=true)
+      config  = 0b01000000
+      config |= 0b10000000 if listening
+
+      self.write Message.encode command:      12,
+                                pin:          tx,
+                                value:        rx,
+                                aux_message:  pack(:uint32, baud) + pack(:uint8, config)
+    end
+
+    # CMD = 12
+    def uart_bb_stop
+      config = 0b00000000
+      self.write Message.encode command:      12,
+                                aux_message:  pack(:uint32, [0]) + pack(:uint8, config)
+    end
+
+    # CMD = 13
+    def uart_bb_write(data)
+      if data.class == Array
+        data = pack(:uint8, data)
+      elsif data.class == String
+      else
+        raise ArgumentError, "data to write to UART should be Array of bytes or String. Given: #{data.inspect}"
+      end
+
+      self.write Message.encode(command: 13, value: data.length, aux_message: data)
+    end
+  end
+end

data/lib/denko/board.rb

@@ -0,0 +1,104 @@
+# Require all files in board folder relative to this file.
+Dir["#{Denko.root}/lib/denko/board/*.rb"].each {|file| require file }
+
+module Denko
+  class Board
+    attr_reader :board_name, :version, :aux_limit, :eeprom_length
+    attr_reader :low, :high, :analog_write_high, :analog_read_high
+
+    def initialize(io, options={})
+      # Connect the IO, and get the ACK.
+      @io = io
+      ack = io.handshake
+      @name, @version, @aux_limit, @eeprom_length = ack.split(",")
+
+      # Parse map, version and eeprom_legnth.
+      @name          = nil if @name.empty?
+      @version       = nil if @version.empty?
+      @eeprom_length = @eeprom_length.to_i
+
+      # Leave room for null termination of aux messages.
+      @aux_limit = @aux_limit.to_i - 1
+
+      # Load the board map.
+      @map = load_map(@name)
+
+      # Allow the IO to call #update on the board when messages received.
+      io.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 @io.writing?
+      write "\n91\n"
+      sleep 0.001 while @io.writing?
+    end
+          
+    def analog_write_resolution=(value)
+      set_analog_write_resolution(value)
+      @write_bits = value
+      @analog_write_high = (2 ** @write_bits) - 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
+    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)
+      @io.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.
+    # 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.
+    #
+    def write_and_halt(msg)
+      @io.write(msg, true)
+    end
+
+    #
+    # Use standard Subcomponents behavior.
+    #
+    include Behaviors::Subcomponents
+
+    def update(line)
+      pin, message = line.split(":", 2)
+      pin = pin.to_i
+      if single_pin_components[pin]
+        single_pin_components[pin].update(message)
+      end
+    end
+
+    #
+    # Component generating convenience methods. TODO: add more!
+    #
+    def eeprom
+      @eeprom ||= EEPROM::BuiltIn.new(board: self)
+    end
+  end
+end

data/lib/denko/connection/base.rb

@@ -0,0 +1,75 @@
+require 'observer'
+require 'timeout'
+
+module Denko
+  module Connection
+    class SerialConnectError < StandardError; end
+    class RxFlushTimeout     < StandardError; end
+
+    class Base
+      include Observable
+      include Handshake
+      # We need the methods in FlowControl to wrap subclass methods too.
+      def self.inherited(subclass)
+        subclass.send(:prepend, FlowControl)
+      end
+
+      def stop
+        stop_read
+        stop_write
+      end
+
+    private
+    
+      def parse(line)
+        changed && notify_observers(line) if line
+      end
+
+      def io
+        @io ||= connect
+      end
+
+      def io_reset
+        flush_read
+        stop_read
+        start_read
+        stop_write
+        start_write
+      end
+
+      def flush_read
+        Timeout.timeout(5) { _read until _read == nil }
+      rescue Timeout::Error
+        raise RxFlushTimeout, "Cannot read from device, or device not running denko"
+      end
+
+      def start_read
+        @read_thread ||= Thread.new do
+          loop { parse(read) }
+        end
+      end
+
+      def stop_read
+        Thread.kill(@read_thread) if @read_thread
+        @read_thread = nil
+      end
+      
+      def start_write
+        @write_thread ||= Thread.new do
+          # Tell the board to reset if our script is interrupted.
+          trap("INT") do
+            _write "\n91\n"
+            raise Interrupt
+          end
+          
+          loop { write_from_buffer }
+        end
+      end
+      
+      def stop_write
+        Thread.kill(@write_thread) if @write_thread
+        @write_thread = nil
+      end
+    end
+  end
+end

data/lib/denko/connection/board_uart.rb

@@ -0,0 +1,36 @@
+module Denko
+  module Connection
+    class BoardUART < Base
+      BAUD = 115200
+
+      def initialize(uart, options={})
+        @uart = uart
+        @uart.start(options[:baud] || BAUD)
+      end
+
+      def baud
+        @uart.baud
+      end
+
+      def flush_read
+        @uart.flush
+      end
+
+      def to_s
+        "#{@uart} @ #{@uart.baud} baud"
+      end
+
+      def _write(message)
+        io.write(message)
+      end
+
+      def _read
+        io.gets
+      end
+
+      def connect
+        @uart
+      end
+    end
+  end
+end

data/lib/denko/connection/flow_control.rb

@@ -0,0 +1,153 @@
+module Denko
+  module Connection
+    module FlowControl
+      BOARD_BUFFER = 63
+      SLEEP_TIME = 0.001
+
+      def initialize(*args)
+        super(*args)
+        reset_flow_control
+        tx_resume
+      end
+
+      def write(message, tx_halt_after=nil)
+        @write_buffer_mutex.synchronize do
+          @write_buffer << message
+
+          # Optionally halt transmission after this message.
+          # See comments on Board#write_and_halt for more info.
+          @tx_halt_points << @write_buffer.length if tx_halt_after
+        end
+      end
+      
+      def writing?
+        @write_buffer_mutex.synchronize { !@write_buffer.empty? }
+      end
+
+    private
+
+      def reset_flow_control
+        @tx_ready_mutex ||= Mutex.new
+        @transit_mutex  ||= Mutex.new
+        @transit_mutex.synchronize { @transit_bytes = 0 }
+
+        @write_buffer_mutex ||= Mutex.new
+        @write_buffer_mutex.synchronize do
+          @write_buffer = ""
+          @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.
+          if @tx_halt_points.empty?
+            limit = @write_buffer.length
+          # Don't send beyond the first halt point if one exists.
+          else
+            limit = @tx_halt_points[0]
+          end
+          # Try to reserve limit bytes on the remote read buffer.
+          bytes = reserve_bytes(limit)
+
+          if bytes > 0
+            # Take fragment of bytes length off the write buffer.
+            fragment = @write_buffer[0..(bytes-1)]
+            @write_buffer = @write_buffer[bytes..-1]
+
+            # Update the halt points to reflect bytes removed.
+            @tx_halt_points.map! { |length| length - bytes }
+
+            # If the first halt point was reached, delete it, and halt after writing fragment.
+            if @tx_halt_points[0] == 0
+              @tx_halt_points.shift
+              halt_after_fragment = true
+            end
+          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.
+          @tx_ready_mutex.synchronize do
+            if @tx_ready
+              _write fragment
+              @tx_ready = false if halt_after_fragment
+              return
+            end
+          end
+          # Else wait outside the @tx_ready_mutex. Allows read thread to update @tx_ready.
+          wait
+        end
+      end
+
+      # Keep transit mutex as short as possible, by only reserving bytes, and writing outside.
+      def reserve_bytes(length)
+        @transit_mutex.synchronize do
+          available = BOARD_BUFFER - @transit_bytes
+          reserved = (length > available) ? available : length
+          @transit_bytes += reserved
+          reserved
+        end
+      end
+
+      def read
+        line = _read
+        
+        if line
+          case line[0..2]
+          # Board read (freed) this many bytes from its input buffer.
+          when "Rx:"
+            remove_transit_bytes(line.split(/:/)[1].to_i)
+            line = nil
+          # Board says to resume transmission.
+          when "Rdy"
+            tx_resume
+            line = nil
+          # Board says to halt transmission.
+          when "Hlt"
+            tx_halt
+            line = nil
+          # Print debug lines.
+          when "DBG"
+            puts line.inspect
+            line = nil
+          end
+        else
+          wait
+        end
+
+        return line
+      end
+
+      def wait
+        sleep SLEEP_TIME
+      end
+
+      def tx_halt
+        @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 }
+      end
+    end
+  end
+end