dino 0.10.0 → 0.11.2

data/lib/dino/components/base_component.rb

@@ -1,12 +1,13 @@
 module Dino
   module Components
     class BaseComponent
-      attr_reader :pin, :board
+      attr_reader :board, :pin, :pullup
       alias :pins :pin
 
       def initialize(options={})
-        self.pin = options[:pin] || options[:pins]
         self.board = options[:board]
+        self.pin = options[:pin] || options[:pins]
+        self.pullup = options[:pullup]
 
         raise 'board and pin or pins are required for a component' if self.board.nil? || self.pin.nil?
         after_initialize(options)
@@ -23,19 +24,19 @@ module Dino
 
       protected
 
-      attr_writer :pin, :board
+      attr_writer :board, :pin, :pullup
       alias :pins= :pin=
 
-      def digital_write(value, pin = self.pin)
+      def digital_write(pin=self.pin, value)
         self.board.digital_write(pin, value)
       end
 
-      def analog_write(value, pin = self.pin)
+      def analog_write(pin=self.pin, value)
         self.board.analog_write(pin, value)
       end
 
-      def set_pin_mode(mode, pin = self.pin)
-        self.board.set_pin_mode(pin, mode)
+      def set_pin_mode(pin=self.pin, mode)
+        self.board.set_pin_mode(pin, mode, pullup)
       end
     end
   end

data/lib/dino/components/rgb_led.rb

@@ -8,27 +8,29 @@ module Dino
         raise 'missing pins[:blue] pin' unless self.pins[:blue]
 
         pins.each do |color, pin|
-          set_pin_mode(:out, pin)
-          analog_write(Board::LOW, pin)
+          set_pin_mode(pin, :out)
+          analog_write(pin, Board::LOW)
         end
       end
 
-      def blue
-        analog_write(Board::LOW, pins[:red])
-        analog_write(Board::LOW, pins[:green])
-        analog_write(Board::HIGH, pins[:blue])
-      end
-
-      def red
-        analog_write(Board::HIGH, pins[:red])
-        analog_write(Board::LOW, pins[:green])
-        analog_write(Board::LOW, pins[:blue])
-      end
+      # Format: [R, G, B]
+      COLORS = {
+        red:     [255, 000, 000],
+        green:   [000, 255, 000],
+        blue:    [000, 000, 255],
+        cyan:    [000, 255, 255],
+        yellow:  [255, 255, 000],
+        magenta: [255, 000, 255],
+        white:   [255, 255, 255],
+        off:     [000, 000, 000]
+      }
 
-      def green
-        analog_write(Board::LOW, pins[:red])
-        analog_write(Board::HIGH, pins[:green])
-        analog_write(Board::LOW, pins[:blue])
+      COLORS.each_key do |color|
+        define_method(color) do
+          analog_write(pins[:red], COLORS[color][0])
+          analog_write(pins[:green], COLORS[color][1])
+          analog_write(pins[:blue], COLORS[color][2])
+        end 
       end
 
       def blinky

data/lib/dino/components/sensor.rb

@@ -7,8 +7,8 @@ module Dino
         @board.start_read
       end
 
-      def when_data_received(callback)
-        @data_callbacks << callback
+      def when_data_received(&block)
+        @data_callbacks << block
       end
 
       def update(data)

data/lib/dino/components/servo.rb

@@ -5,14 +5,17 @@ module Dino
 
       def after_initialize(options={})
         set_pin_mode(:out)
-        self.position = 0
+        board.servo_toggle(pin, 1)
+        self.position = options[:position] || 0
       end
 
-      def position=(new_position)
-        @position = new_position % 180
-        analog_write(@position)
+      def position=(value)
+        board.servo_write(pin, @position = angle(value))
+      end
+
+      def angle(value)
+        value == 180 ? value : value % 180
       end
     end
   end
 end
-

data/lib/dino/components/stepper.rb

@@ -6,21 +6,21 @@ module Dino
         raise 'missing pins[:step] pin' unless self.pins[:step]
         raise 'missing pins[:direction] pin' unless self.pins[:direction]
 
-        set_pin_mode(:out, pins[:step])
-        set_pin_mode(:out, pins[:direction])
-        digital_write(Board::LOW, pins[:step])
+        set_pin_mode(pins[:step], :out)
+        set_pin_mode(pins[:direction], :out)
+        digital_write(pins[:step], Board::LOW)
       end
 
       def step_cc
-        digital_write(Board::HIGH, self.pins[:direction])
-        digital_write(Board::HIGH, self.pins[:step])
-        digital_write(Board::LOW, self.pins[:step])
+        digital_write(self.pins[:direction], Board::HIGH)
+        digital_write(self.pins[:step],      Board::HIGH)
+        digital_write(self.pins[:step],      Board::LOW)
       end
 
       def step_cw
-        digital_write(Board::LOW, self.pins[:direction])
-        digital_write(Board::HIGH, self.pins[:step])
-        digital_write(Board::LOW, self.pins[:step])
+        digital_write(self.pins[:direction], Board::LOW)
+        digital_write(self.pins[:step],      Board::HIGH)
+        digital_write(self.pins[:step],      Board::LOW)
       end
     end
   end

data/lib/dino/tx_rx.rb

@@ -1,10 +1,11 @@
 module Dino
   module TxRx
-    require 'dino/tx_rx/usb_serial'
-    require 'dino/tx_rx/telnet'
+    require 'dino/tx_rx/base'
+    require 'dino/tx_rx/serial'
+    require 'dino/tx_rx/tcp'
 
-    def self.new
-      self::USBSerial.new
+    def self.new(options={})
+      self::Serial.new(options)
     end
   end
 end

data/lib/dino/tx_rx/base.rb

@@ -0,0 +1,64 @@
+require 'observer'
+require 'timeout'
+
+module Dino
+  module TxRx
+    class Base
+      include Observable
+
+      def read
+        @thread ||= Thread.new do
+          loop do
+            line = gets
+            if line && line.match(/\A\d+:/)
+              pin, message = line.chop.split(/:/)
+              pin && message && changed && notify_observers(pin, message)
+            end
+          end
+        end
+      end
+
+      def close_read
+        return nil if @thread.nil?
+        Thread.kill(@thread)
+        @thread = nil
+      end
+
+      def write(message)
+        loop do
+          if IO.select(nil, [io], nil)
+            io.syswrite(message)
+            break
+          end
+        end
+      end
+
+      def handshake
+        flush_read
+        100.times do
+          begin
+            write("!9000000.")
+            Timeout::timeout(0.1) do
+              line = gets.to_s
+              if line.match /ACK:/
+                flush_read
+                return line.chop.split(/:/)[1].to_i
+              end
+            end
+          rescue
+            nil
+          end
+        end
+       raise BoardNotFound
+      end
+
+      def flush_read
+        gets until gets == nil
+      end
+
+      def gets
+        IO.select([io], nil, nil, 0.005) && io.gets
+      end
+    end
+  end
+end

data/lib/dino/tx_rx/serial.rb

@@ -0,0 +1,44 @@
+require 'serialport'
+
+module Dino
+  module TxRx
+    class Serial < Base
+      BAUD = 115200
+
+      def initialize(options={})
+        @device = options[:device]
+        @baud = options[:baud] || BAUD
+        @first_write = true
+      end
+
+      def io
+        @io ||= connect
+      end
+
+      def handshake
+        if on_windows?
+          io; sleep 3
+        end
+        
+        super
+      end
+
+      private
+
+      def connect
+        tty_devices.each { |device| return SerialPort.new(device, @baud) rescue nil }
+        raise BoardNotFound
+      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/dino/tx_rx/tcp.rb

@@ -0,0 +1,23 @@
+require 'socket'
+
+module Dino
+  module TxRx
+    class TCP < Base
+      def initialize(host, port=3466)
+        @host, @port = host, port
+      end
+
+      def io
+        @io ||= connect
+      end
+
+    private
+
+      def connect
+        Timeout::timeout(10) { TCPSocket.open(@host, @port) }
+      rescue
+        raise BoardNotFound
+      end
+    end
+  end
+end

data/lib/dino/version.rb

@@ -1,3 +1,3 @@
 module Dino
-  VERSION = "0.10.0"
+  VERSION = "0.11.2"
 end

data/spec/lib/board_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Dino
   describe Dino::Board do
     def io_mock(methods = {})
-      @io ||= mock(:io, {write: nil, add_observer: nil}.merge(methods))
+      @io ||= mock(:io, {write: nil, add_observer: nil, flush_read: nil, handshake: "14"}.merge(methods))
     end
 
     subject { Board.new(io_mock) }
@@ -20,14 +20,8 @@ module Dino
         subject.send(:initialize, io_mock)
       end
 
-      it 'should start the heart beat' do
-        io_mock.should_receive(:write).with('!0212000.')
-        subject.add_digital_hardware(mock(:part, pin: 12))
-        sleep 0.01
-      end
-
-      it 'should send clearing bytes to the io' do
-        io_mock.should_receive(:write).with("00000000")
+      it 'should initiate the handshake' do
+        io_mock.should_receive(:handshake)
         subject
       end
     end
@@ -47,9 +41,9 @@ module Dino
 
       context 'when the given pin connects to an digital hardware part' do
         it 'should call update with the message on the part' do
-          part = mock(:part, pin: 5)
+          part = mock(:part, pin: 5, pullup: nil)
           subject.add_digital_hardware(part)
-          other_part = mock(:part, pin: 11)
+          other_part = mock(:part, pin: 11, pullup: nil)
           subject.add_digital_hardware(other_part)
 
           part.should_receive(:update).with('wake up!')
@@ -82,21 +76,23 @@ module Dino
 
     describe '#add_digital_hardware' do
       it 'should add digital hardware to the board' do
-        subject.add_digital_hardware(mock1 = mock(:part1, pin: 12))
-        subject.add_digital_hardware(mock2 = mock(:part2, pin: 14))
+        subject.add_digital_hardware(mock1 = mock(:part1, pin: 12, pullup: nil))
+        subject.add_digital_hardware(mock2 = mock(:part2, pin: 14, pullup: nil))
         subject.digital_hardware.should =~ [mock1, mock2]
       end
 
-      it 'should set the mode for the given pin to "in"' do
+      it 'should set the mode for the given pin to "in" and add a digital listener' do
         subject
-        subject.should_receive(:write).with("0012000")
-        subject.add_digital_hardware(mock1 = mock(:part1, pin: 12))
+        subject.should_receive(:write).with("0012001")
+        subject.should_receive(:write).with("0112000")
+        subject.should_receive(:write).with("0512000")
+        subject.add_digital_hardware(mock1 = mock(:part1, pin: 12, pullup: nil))
       end
     end
 
     describe '#remove_digital_hardware' do
       it 'should remove the given part from the hardware of the board' do
-        mock = mock(:part1, pin: 12)
+        mock = mock(:part1, pin: 12, pullup: nil)
         subject.add_digital_hardware(mock)
         subject.remove_digital_hardware(mock)
         subject.digital_hardware.should == []
@@ -105,21 +101,23 @@ module Dino
 
     describe '#add_analog_hardware' do
       it 'should add analog hardware to the board' do
-        subject.add_analog_hardware(mock1 = mock(:part1, pin: 12))
-        subject.add_analog_hardware(mock2 = mock(:part2, pin: 14))
+        subject.add_analog_hardware(mock1 = mock(:part1, pin: 12, pullup: nil))
+        subject.add_analog_hardware(mock2 = mock(:part2, pin: 14, pullup: nil))
         subject.analog_hardware.should =~ [mock1, mock2]
       end
 
-      it 'should set the mode for the given pin to "in"' do
+      it 'should set the mode for the given pin to "in" and add an analog listener' do
         subject
-        subject.should_receive(:write).with("0012000")
-        subject.add_analog_hardware(mock1 = mock(:part1, pin: 12))
+        subject.should_receive(:write).with("0012001")
+        subject.should_receive(:write).with("0112000")
+        subject.should_receive(:write).with("0612000")
+        subject.add_analog_hardware(mock1 = mock(:part1, pin: 12, pullup: nil))
       end
     end
 
     describe '#remove_analog_hardware' do
       it 'should remove the given part from the hardware of the board' do
-        mock = mock(:part1, pin: 12)
+        mock = mock(:part1, pin: 12, pullup: nil)
         subject.add_analog_hardware(mock)
         subject.remove_analog_hardware(mock)
         subject.analog_hardware.should == []
@@ -167,7 +165,7 @@ module Dino
     end
 
     describe '#digital_read' do
-      it 'should tell the board to start reading from the given pin' do
+      it 'should tell the board to read once from the given pin' do
         io_mock.should_receive(:write).with('!0213000.')
         subject.digital_read(13)
       end
@@ -181,33 +179,49 @@ module Dino
     end
 
     describe '#analog_read' do
-      it 'should tell the board to start reading from the given pin' do
+      it 'should tell the board to read once from the given pin' do
         io_mock.should_receive(:write).with('!0413000.')
         subject.analog_read(13)
       end
     end
 
+    describe '#digital_listen' do
+      it 'should tell the board to continuously read from the given pin' do
+        io_mock.should_receive(:write).with('!0513000.')
+        subject.digital_listen(13)
+      end
+    end
+
+    describe '#analog_listen' do
+      it 'should tell the board to continuously read from the given pin' do
+        io_mock.should_receive(:write).with('!0613000.')
+        subject.analog_listen(13)
+      end
+    end
+
+    describe '#stop_listener' do
+      it 'should tell the board to stop sending values for the given pin' do
+        io_mock.should_receive(:write).with('!0713000.')
+        subject.stop_listener(13)
+      end
+    end
+
     describe '#set_pin_mode' do
-      it 'should send a value of 1 if the pin mode is set to out' do
-        io_mock.should_receive(:write).with('!0013001.')
+      it 'should send a value of 0 if the pin mode is set to out' do
+        io_mock.should_receive(:write).with('!0013000.')
         subject.set_pin_mode(13, :out)
       end
 
-      it 'should send a value of 0 if the pin mode is set to in' do
-        io_mock.should_receive(:write).with('!0013000.')
+      it 'should send a value of 1 if the pin mode is set to in' do
+        io_mock.should_receive(:write).with('!0013001.')
         subject.set_pin_mode(13, :in)
       end
     end
 
-    describe '#set_debug' do
-      it 'should set the boards debug on when passed on' do
-        io_mock.should_receive(:write).with('!9900001.')
-        subject.set_debug(:on)
-      end
-
-      it 'should set the boards debug off when passed off' do
-        io_mock.should_receive(:write).with('!9900000.')
-        subject.set_debug(:off)
+    describe '#handshake' do
+      it 'should tell the board to reset to defaults' do
+        io_mock.should_receive(:handshake)
+        subject.handshake
       end
     end
 
@@ -221,7 +235,7 @@ module Dino
       end
 
       it 'should raise if a number larger than two digits are given' do
-        expect { subject.normalize_pin(1000) }.to raise_exception 'pins can only be two digits'
+        expect { subject.normalize_pin(1000) }.to raise_exception 'pin number must be in 0-99'
       end
     end