dino 0.8

data/lib/dino/components/button.rb

@@ -0,0 +1,53 @@
+module Dino
+  module Components
+    class Button < BaseComponent
+      UP = "01"
+      DOWN = "00"
+
+      def initialize(options={})
+        super(options)
+
+        @down_callbacks, @up_callbacks, @state = [], [], UP
+
+        self.board.add_digital_hardware(self)
+        self.board.start_read
+      end
+
+      def down(callback)
+        @down_callbacks << callback
+      end
+
+      def up(callback)
+        @up_callbacks << callback
+      end
+
+      def update(data)
+        return if data == @state
+        @state = data
+
+        case data
+          when UP
+            button_up
+          when DOWN
+            button_down
+          else
+            return
+        end
+      end
+
+      private
+
+      def button_up
+        @up_callbacks.each do |callback|
+          callback.call
+        end
+      end
+
+      def button_down
+        @down_callbacks.each do |callback|
+          callback.call
+        end
+      end
+    end
+  end
+end

data/lib/dino/components/ir_receiver.rb

@@ -0,0 +1,33 @@
+module Dino
+  module Components
+    class IrReceiver < BaseComponent
+      STABLE = "01"
+
+      def initialize(options={})
+        super(options)
+
+        @flash_callbacks = []
+
+        self.board.add_digital_hardware(self)
+        self.board.start_read
+      end
+
+      def flash(callback)
+        @flash_callbacks << callback
+      end
+
+      def update(data)
+        return if data == STABLE
+        light_flashed
+      end
+
+      private
+
+      def light_flashed
+        @flash_callbacks.each do |callback|
+          callback.call
+        end
+      end
+    end
+  end
+end

data/lib/dino/components/led.rb

@@ -0,0 +1,20 @@
+module Dino
+  module Components
+    class Led < BaseComponent
+      def initialize(options={})
+        super(options)
+
+        set_pin_mode(:out)
+        digital_write(Board::LOW)
+      end
+
+      def on
+        digital_write(Board::HIGH)
+      end
+
+      def off
+        digital_write(Board::LOW)
+      end
+    end
+  end
+end

data/lib/dino/components/rgb_led.rb

@@ -0,0 +1,44 @@
+module Dino
+  module Components
+    class RgbLed < BaseComponent
+      # options = {board: my_board, pins: {red: red_pin, green: green_pin, blue: blue_pin}
+      def initialize(options={})
+        super(options)
+
+        raise 'missing pins[:red] pin' unless self.pins[:red]
+        raise 'missing pins[:green] pin' unless self.pins[:green]
+        raise 'missing pins[:blue] pin' unless self.pins[:blue]
+
+        pins.each do |color, pin|
+          set_pin_mode(:out, pin)
+          analog_write(Board::LOW, pin)
+        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
+
+      def green
+        analog_write(Board::LOW, pins[:red])
+        analog_write(Board::HIGH, pins[:green])
+        analog_write(Board::LOW, pins[:blue])
+      end
+
+      def blinky
+        [:red, :green, :blue].cycle do |color|
+          self.send(color)
+          sleep(0.01)
+        end
+      end
+    end
+  end
+end

data/lib/dino/components/sensor.rb

@@ -0,0 +1,23 @@
+module Dino
+  module Components
+    class Sensor < BaseComponent
+      def initialize(options={})
+        super(options)
+
+        @data_callbacks = []
+        @board.add_analog_hardware(self)
+        @board.start_read
+      end
+
+      def when_data_received(callback)
+        @data_callbacks << callback
+      end
+
+      def update(data)
+        @data_callbacks.each do |callback|
+          callback.call(data)
+        end
+      end
+    end
+  end
+end

data/lib/dino/components/servo.rb

@@ -0,0 +1,20 @@
+module Dino
+  module Components
+    class Servo < BaseComponent
+      attr_reader :position
+
+      def initialize(options)
+        super(options)
+
+        set_pin_mode(:out)
+        self.position = 0
+      end
+
+      def position=(new_position)
+        @position = new_position % 180
+        analog_write(@position)
+      end
+    end
+  end
+end
+

data/lib/dino/components/stepper.rb

@@ -0,0 +1,29 @@
+module Dino
+  module Components
+    class Stepper < BaseComponent
+
+      def initialize(options={})
+        super(options)
+
+        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])
+      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])
+      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])
+      end
+    end
+  end
+end

data/lib/dino/tx_rx.rb

@@ -0,0 +1,58 @@
+require 'serialport'
+require 'observer'
+
+module Dino
+  class TxRx
+    include Observable
+
+    BAUD = 115200
+
+    def initialize
+      @first_write = true
+    end
+
+    def io
+      @io ||= tty_devices.map do |device|
+        next if device.match /^cu/
+        begin
+          SerialPort.new("/dev/#{device}", BAUD)
+        rescue
+          nil
+        end
+      end.compact.first
+    end
+
+    def io=(device)
+      @io = SerialPort.new(device, BAUD)
+    end
+
+    def read
+      @thread ||= Thread.new do
+        loop do
+          if IO.select([io], nil, nil, 0.005)
+            pin, message = *io.gets.chop.split(/::/)
+            pin && message && changed && notify_observers(pin, message)
+          end
+          sleep 0.004
+        end
+      end
+    end
+
+    def close_read
+      return nil if @thread.nil?
+      Thread.kill(@thread)
+      @thread = nil
+    end
+
+    def write(message)
+      IO.select(nil, [io], nil)
+      io.puts(message)
+    end
+
+    private
+
+    def tty_devices
+      `ls /dev | grep usb`.split(/\n/)
+    end
+  end
+end

data/lib/dino/version.rb

@@ -0,0 +1,3 @@
+module Dino
+  VERSION = "0.8"
+end

data/spec/lib/board_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+module Dino
+  describe Dino::Board do
+    def io_mock(methods = {})
+      @io ||= mock(:io, {write: nil, add_observer: nil}.merge(methods))
+    end
+
+    subject { Board.new(io_mock) }
+
+    describe '#initialize' do
+      it 'should take an io class' do
+        expect {
+          Board.new(io_mock)
+        }.to_not raise_exception
+      end
+
+      it 'should observe the io' do
+        io_mock.should_receive(:add_observer).with(subject)
+        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")
+        subject
+      end
+    end
+
+    describe '#update' do
+      context 'when the given pin connects to an analog hardware part' do
+        it 'should call update with the message on the part' do
+          part = mock(:part, pin: 7)
+          subject.add_analog_hardware(part)
+          other_part = mock(:part, pin: 9)
+          subject.add_analog_hardware(other_part)
+
+          part.should_receive(:update).with('wake up!')
+          subject.update(7, 'wake up!')
+        end
+      end
+
+      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)
+          subject.add_digital_hardware(part)
+          other_part = mock(:part, pin: 11)
+          subject.add_digital_hardware(other_part)
+
+          part.should_receive(:update).with('wake up!')
+          other_part.should_not_receive(:update).with('wake up!')
+
+          subject.update(5, 'wake up!')
+        end
+      end
+
+      context 'when the given pin is not connected' do
+        it 'should not do anything' do
+          expect {
+            subject.update(5, 'wake up!')
+          }.to_not raise_exception
+        end
+      end
+    end
+
+    describe '#digital_hardware' do
+      it 'should initialize as empty' do
+        subject.digital_hardware.should == []
+      end
+    end
+
+    describe '#analog_hardware' do
+      it 'should initialize as empty' do
+        subject.analog_hardware.should == []
+      end
+    end
+
+    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.digital_hardware.should =~ [mock1, mock2]
+      end
+
+      it 'should set the mode for the given pin to "in"' do
+        subject
+        subject.should_receive(:write).with("0012000")
+        subject.add_digital_hardware(mock1 = mock(:part1, pin: 12))
+      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)
+        subject.add_digital_hardware(mock)
+        subject.remove_digital_hardware(mock)
+        subject.digital_hardware.should == []
+      end
+    end
+
+    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.analog_hardware.should =~ [mock1, mock2]
+      end
+
+      it 'should set the mode for the given pin to "in"' do
+        subject
+        subject.should_receive(:write).with("0012000")
+        subject.add_analog_hardware(mock1 = mock(:part1, pin: 12))
+      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)
+        subject.add_analog_hardware(mock)
+        subject.remove_analog_hardware(mock)
+        subject.analog_hardware.should == []
+      end
+    end
+
+    describe '#start_read' do
+      it 'should tell the io to read' do
+        io_mock.should_receive(:read)
+        Board.new(io_mock).start_read
+      end
+    end
+
+    describe '#stop_read' do
+      it 'should tell the io to read' do
+        io_mock.should_receive(:close_read)
+        Board.new(io_mock).stop_read
+      end
+    end
+
+    describe '#write' do
+      it 'should return true if the write succeeds' do
+        @io = nil
+        board = Board.new(io_mock(write: true))
+        board.write('message').should == true
+      end
+
+      it 'should wrap the message in a ! and a . by default' do
+        io_mock.should_receive(:write).with('!hello.')
+        subject.write('hello')
+      end
+
+      it 'should not wrap the message if no_wrap is set to true' do
+        board = Board.new(io_mock)
+        io_mock.should_receive(:write).with('hello')
+        board.write('hello', no_wrap: true)
+      end
+    end
+
+    describe '#digital_write' do
+      it 'should append a append a write to the pin and value' do
+        io_mock.should_receive(:write).with('!0101003.')
+        subject.digital_write(01, 003)
+      end
+    end
+
+    describe '#digital_read' do
+      it 'should tell the board to start reading from the given pin' do
+        io_mock.should_receive(:write).with('!0213000.')
+        subject.digital_read(13)
+      end
+    end
+
+    describe '#analog_write' do
+      it 'should append a append a write to the pin and value' do
+        io_mock.should_receive(:write).with('!0301003.')
+        subject.analog_write(01, 003)
+      end
+    end
+
+    describe '#analog_read' do
+      it 'should tell the board to start reading from the given pin' do
+        io_mock.should_receive(:write).with('!0413000.')
+        subject.analog_read(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.')
+        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.')
+        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)
+      end
+    end
+
+    describe '#normalize_pin' do
+      it 'should normalize numbers so they are two digits' do
+        subject.normalize_pin(1).should == '01'
+      end
+
+      it 'should not normalize numbers that are already two digits' do
+        subject.normalize_pin(10).should == '10'
+      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'
+      end
+    end
+
+    describe '#normalize_value' do
+      it 'should normalize numbers so they are three digits' do
+        subject.normalize_value(1).should == '001'
+      end
+
+      it 'should not normalize numbers that are already three digits' do
+        subject.normalize_value(10).should == '010'
+      end
+
+      it 'should raise if a number larger than three digits are given' do
+        expect { subject.normalize_value(1000) }.to raise_exception 'values are limited to three digits'
+      end
+    end
+  end
+end