denko 0.13.0

data/lib/denko/connection/handshake.rb

@@ -0,0 +1,60 @@
+module Denko
+  module Connection
+    class HandshakeError < StandardError; end
+
+    class HandshakeAttempt
+      attr_reader :acknowledged, :result
+      def initialize
+        @acknowledged = false
+        @result = nil
+      end
+
+      def update(line)
+        if line.match(/\AACK:/)
+          @result = line.split(":", 2)[1]
+          @acknowledged = true
+        end
+      end
+    end
+
+    module Handshake
+      HANDSHAKE_TRIES = 3
+      HANDSHAKE_TIMEOUT = 2
+
+      def handshake
+        io_reset
+        HANDSHAKE_TRIES.times do |retries|
+          begin
+            print "Sending handshake to: #{self.to_s}... "
+            self.add_observer(attempt = HandshakeAttempt.new)
+            write Message.encode(command: 90)
+
+            Timeout.timeout(HANDSHAKE_TIMEOUT) do
+              loop do
+                sleep 0.001
+                if attempt.acknowledged
+                  puts "Acknowledged. Hardware ready...\n\n"
+                  
+                  # Stop the handshake attempt from observing.
+                  self.delete_observer(attempt)
+                  
+                  # We reset the board, so reset the transit mutex.
+                  @transit_mutex.synchronize { @transit_bytes = 0 }
+                  
+                  # Return the data part of the ACK line.
+                  return attempt.result
+                end
+              end
+            end
+          rescue Timeout::Error
+            self.delete_observer(attempt)
+            print "No response, "
+            puts (retries + 1 < HANDSHAKE_TRIES ? "retrying..." : "exiting...")
+            next
+          end
+        end
+        raise HandshakeError, "Connected to wrong device, or device not running denko"
+      end
+    end
+  end
+end

data/lib/denko/connection/serial.rb

@@ -0,0 +1,90 @@
+require 'rubyserial'
+
+module Denko
+  module Connection
+    class Serial < Base
+      BAUD = 115200
+
+      def initialize(options={})
+        @device = options[:device]
+        @baud = options[:baud] || BAUD
+        @rx_buffer = ""
+        @rx_line = ""
+        @rx_escaped = false
+      end
+
+      def to_s
+        "#{@device} @ #{@baud} baud"
+      end
+
+      def _write(message)
+        io.write(message)
+      end
+
+      def _read
+        # A native USB serial packet can be up to 64 bytes.
+        @rx_buffer << io.read(64) if @rx_buffer.empty?
+
+        while @rx_buffer.length > 0
+          # Take a single character off the RX buffer.
+          char = @rx_buffer[0]
+          @rx_buffer = @rx_buffer[1..-1]
+
+          if @rx_escaped
+            @rx_line << char
+            @rx_escaped = false
+          else
+            if (char == "\n")
+              line = @rx_line
+              @rx_line = ""
+              return line
+            elsif (char == "\\")
+              @rx_escaped = true
+            else
+              @rx_line << char
+              @rx_escaped = false
+            end
+          end
+        end
+
+        # Return nil if line wasn't returned and entire buffer parsed.
+        return nil
+      end
+
+    private
+
+      def connect
+        tty_devices.each do |device|
+          begin
+            @device = device
+            print "Trying serial device: #{self.to_s}... "
+            connection = ::Serial.new(@device, @baud)
+            puts "Connected"
+            return connection
+          rescue RubySerial::Error => error
+            handle_error(error); next
+          end
+        end
+        raise SerialConnectError, "Could not connect to a serial device."
+      end
+
+      def handle_error(error)
+        if error.message == "EBUSY"
+          puts "Device Busy! (EBUSY)"
+        else
+          puts "RubySerial Error (#{error.message})"
+        end
+      end
+
+      def tty_devices
+        return [@device] if @device
+        return (1..256).map { |n| "COM#{n}" } if on_windows?
+        `ls /dev`.split("\n").grep(/usb|ACM/i).map{ |d| "/dev/#{d}" }
+      end
+
+      def on_windows?
+        RUBY_PLATFORM.match(/mswin|mingw/i)
+      end
+    end
+  end
+end

data/lib/denko/connection/tcp.rb

@@ -0,0 +1,44 @@
+require 'socket'
+
+module Denko
+  module Connection
+    class TCPConnectError < StandardError; end
+
+    class TCP < Base
+      def initialize(host="127.0.0.1", port=3466)
+        @host = host
+        @port = port
+      end
+
+      def to_s
+        "#{@host}:#{@port}"
+      end
+
+    private
+
+      def connect
+        print "Connecting to TCP at: #{self.to_s}... "
+        connection = Timeout::timeout(10) do
+          TCPSocket.open(@host, @port)
+        end
+        puts "Connected"
+        connection
+      rescue => error
+        raise TCPConnectError, error.message
+      end
+
+      def _write(message)
+        loop do
+          if IO.select(nil, [io], nil, 0)
+            io.syswrite(message)
+            break
+          end
+        end
+      end
+
+      def _read
+        IO.select([io], nil, nil, 0) && io.gets.gsub(/\n\z/, "")
+      end
+    end
+  end
+end

data/lib/denko/connection.rb

@@ -0,0 +1,10 @@
+module Denko
+  module Connection
+    autoload :FlowControl,  "#{__dir__}/connection/flow_control"
+    autoload :Handshake,    "#{__dir__}/connection/handshake"
+    autoload :Base,         "#{__dir__}/connection/base"
+    autoload :Serial,       "#{__dir__}/connection/serial"
+    autoload :TCP,          "#{__dir__}/connection/tcp"
+    autoload :BoardUART,    "#{__dir__}/connection/board_uart"
+  end
+end

data/lib/denko/digital_io/button.rb

@@ -0,0 +1,8 @@
+module Denko
+  module DigitalIO
+    class Button < Input
+      alias :down :on_low
+      alias :up   :on_high
+    end
+  end
+end

data/lib/denko/digital_io/input.rb

@@ -0,0 +1,44 @@
+module Denko
+  module DigitalIO
+    class Input
+      include Behaviors::InputPin
+      include Behaviors::Reader
+      include Behaviors::Poller
+      include Behaviors::Listener
+
+      def after_initialize(options={})
+        super(options)
+        @divider = 4
+        _listen
+      end
+
+      def _read
+        board.digital_read(pin)
+      end
+
+      def _listen(divider=nil)
+        @divider = divider || @divider
+        board.digital_listen(pin, @divider)
+      end
+
+      def on_high(&block)
+        add_callback(:high) do |data|
+          block.call(data) if data.to_i == board.high
+        end
+      end
+
+      def on_low(&block)
+        add_callback(:low) do |data|
+          block.call(data) if data.to_i == board.low
+        end
+      end
+      
+      def pre_callback_filter(value)
+        value.to_i
+      end
+
+      def high?; state == board.high end
+      def low?;  state == board.low  end
+    end
+  end
+end

data/lib/denko/digital_io/output.rb

@@ -0,0 +1,47 @@
+module Denko
+  module DigitalIO
+    class Output
+      include Behaviors::OutputPin
+      include Behaviors::Callbacks
+      include Behaviors::Threaded
+      interrupt_with :digital_write
+
+      def after_initialize(options={})
+        super(options)
+        board.digital_read(pin)
+      end
+
+      def pre_callback_filter(board_state)
+        board_state.to_i
+      end
+
+      def digital_write(value)
+        board.digital_write(pin, value)
+        self.state = value
+      end
+      
+      alias :write :digital_write
+
+      def low
+        digital_write(board.low)
+      end
+
+      def high
+        digital_write(board.high)
+      end
+
+      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
+  end
+end

data/lib/denko/digital_io/relay.rb

@@ -0,0 +1,6 @@
+module Denko
+  module DigitalIO
+    class Relay < Output
+    end
+  end
+end

data/lib/denko/digital_io/rotary_encoder.rb

@@ -0,0 +1,107 @@
+module Denko
+  module DigitalIO
+    class RotaryEncoder
+      include Behaviors::MultiPin
+      include Behaviors::Callbacks
+
+      def initialize_pins(options={})
+        proxy_pin :clock, DigitalIO::Input
+        proxy_pin :data,  DigitalIO::Input
+      end
+
+      def after_initialize(options={})
+        super(options)
+        self.steps_per_revolution = options[:steps_per_revolution] || 30
+        @reverse = false
+
+        # Avoid repeated memory allocation.
+        self.state = { steps: 0, angle: 0 }
+        @reading   = { steps: 0, angle: 0, change: 0}
+        
+        # DigitalInputs listen with default divider automatically. Override here.
+        @divider = options[:divider] || 1
+        clock.listen(@divider)
+        data.listen(@divider)
+        
+        observe_pins
+        reset
+      end
+      
+      attr_reader :reversed
+
+      def reverse
+        @reversed = !@reversed
+      end
+
+      def steps_per_revolution
+        (360 / @degrees_per_step).to_i
+      end
+      
+      def steps_per_revolution=(step_count)
+        @degrees_per_step = 360.to_f / step_count
+      end
+      
+      def angle
+        state[:angle]
+      end
+
+      def steps
+        state[:steps]
+      end
+      
+      def reset
+        self.state = {steps: 0, angle: 0}
+      end
+      
+      private
+
+      def observe_pins
+        #
+        # This is a quirk of listeners reading in numerical order.
+        # When observing the pins, attach a callback to the higher numbered pin (trailing),
+        # then read state of the lower numbered (leading). If not, direction will be reversed.
+        #
+        if clock.pin > data.pin
+          trailing = clock
+          leading = data
+        else
+          trailing = data
+          leading = clock
+        end
+        
+        trailing.add_callback do |trailing_state|
+          change = (trailing_state == leading.state) ? 1 : -1
+          change = -change if trailing == clock
+          self.update(change)
+        end
+      end
+      
+      #
+      # Take data (+/- 1 step change) and calculate new state.
+      # Return a hash with the new :steps and :angle. Pass through raw
+      # value in :change, so callbacks can use any of these.
+      #
+      def pre_callback_filter(step)
+        step = -step if reversed
+
+        @reading[:change] = step
+        @state_mutex.synchronize do
+          @reading[:steps] = @state[:steps] + step
+        end      
+        @reading[:angle] = @reading[:steps] * @degrees_per_step % 360
+        
+        @reading
+      end
+
+      #
+      # After callbacks, set state to the hash from before, except change.
+      #
+      def update_state(reading)
+        @state_mutex.synchronize do
+          @state[:steps]  = reading[:steps]
+          @state[:angle]  = reading[:angle]
+        end
+      end
+    end
+  end
+end

data/lib/denko/digital_io.rb

@@ -0,0 +1,9 @@
+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"
+  end
+end