smalrubot 0.0.1

data/sketch/sr/sr.ino

@@ -0,0 +1,18 @@
+#include "Smalrubot.h"
+#include <Servo.h>
+Smalrubot smalrubot;
+
+// Smalrubot.h doesn't handle TXRX. Setup a function to tell it to write to Serial.
+void writeResponse(char *response) { Serial.println(response); }
+void (*writeCallback)(char *str) = writeResponse;
+
+void setup() {
+  Serial.begin(115200);
+  smalrubot.setupWrite(writeCallback);
+}
+
+void loop() {
+  while(Serial.available() > 0) smalrubot.parse(Serial.read());
+  Serial.flush();
+}
+

data/smalrubot.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'smalrubot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "smalrubot"
+  spec.version       = Smalrubot::VERSION
+  spec.authors       = ["Kouji Takao"]
+  spec.email         = ["kouji.takao@gmail.com"]
+  spec.summary       = %q{A library and an Arduino sketch for Smalruby.}
+  spec.description   = %q{The smalrubot is a library and an Arduino sketch for Smalruby.}
+  spec.homepage      = "https://github.com/smalruby/smalrubot"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rubyserial'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/spec/lib/board_not_found_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Smalrubot
+  describe BoardNotFound do
+    it { should be }
+    it { should be_a Exception }
+  end
+end

data/spec/lib/board_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module Smalrubot
+  describe Smalrubot::Board do
+    def io_mock(methods = {})
+      @io ||= double(:io, {write: nil, flush_read: nil, handshake: "14"}.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 initiate the handshake' do
+        io_mock.should_receive(:handshake)
+        subject
+      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 read once from the given pin' do
+        io_mock.should_receive(:write).with('!0213000.')
+        io_mock.should_receive(:read).with(1).and_return(['13', Smalrubot::Board::HIGH.to_s])
+        expect(subject.digital_read(13)).to eq(Smalrubot::Board::HIGH)
+      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 read once from the given pin' do
+        io_mock.should_receive(:write).with('!0413000.')
+        io_mock.should_receive(:read).with(1).once.and_return(['13', '256'])
+        expect(subject.analog_read(13)).to eq(256)
+      end
+    end
+
+    describe '#set_pin_mode' do
+      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 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 '#handshake' do
+      it 'should tell the board to reset to defaults' do
+        io_mock.should_receive(:handshake)
+        subject.handshake
+      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 'pin number must be in 0-99'
+      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

data/spec/lib/components/base_component_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Smalrubot
+  module Components
+
+    describe BaseComponent do
+
+      it 'should initialize with board and pin' do
+        pin = "a pin"
+        board = "a board"
+        component = BaseComponent.new(pin: pin, board: board)
+
+        component.pin.should == pin
+        component.board.should == board
+      end
+
+      it 'should assign pins' do
+        pins = {red: 'red', green: 'green', blue: 'blue'}
+        board = "a board"
+        component = BaseComponent.new(pins: pins, board: board)
+
+        component.pins.should == pins
+      end
+
+      it 'should require a pin or pins' do
+        expect {
+          BaseComponent.new(board: 'some board')
+        }.to raise_exception
+      end
+
+      it 'should require a board' do
+        expect {
+          BaseComponent.new(pin: 'some pin')
+        }.to raise_exception
+      end
+
+      context "when subclassed #after_initialize should be executed" do
+
+        class SpecComponent < BaseComponent
+
+          def sucessfully_initialized? ; @success ; end
+
+          def options ; @options ; end
+
+          def after_initialize(options={})
+            @success = true
+            @options = options
+          end
+        end
+
+        let(:options) { { pin: pin, board: board } }
+        let(:pin) { "a pin" }
+        let(:board) { "a board" }
+
+        it "should call #after_initialize with options" do
+          component = SpecComponent.new(options)
+          component.should be_sucessfully_initialized
+          component.options.should eq options
+        end
+
+      end
+
+    end
+  end
+end
+

data/spec/lib/components/led_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Smalrubot
+  module Components
+    describe Led do
+      let(:board) { double(:board, digital_write: true, set_pin_mode: true) }
+
+      describe '#initialize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            Led.new(board: board)
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Led.new(pins: {})
+          }.to raise_exception
+        end
+
+        it 'should set the pin to out' do
+          board.should_receive(:set_pin_mode).with(13, :out, nil)
+          Led.new(pin: 13, board: board)
+        end
+
+        it 'should set the pin to low' do
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          Led.new(pin: 13, board: board)
+        end
+      end
+
+      describe '#on' do
+        it 'should send a high to the board with the pin' do
+          @led = Led.new(pin: 13, board: board)
+          board.should_receive(:digital_write).with(13, Board::HIGH)
+          @led.on
+        end
+      end
+
+      describe '#off' do
+        it 'should send a high to the board with the pin' do
+          @led = Led.new(pin: 13, board: board)
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          @led.off
+        end
+      end
+    end
+  end
+end

data/spec/lib/components/servo_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Smalrubot
+  module Components
+    describe Servo do
+      let(:board) { double(:board, analog_write: true, set_pin_mode: true, servo_toggle: true, servo_write: true) }
+
+      describe '#initialize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            Servo.new(board: board)
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Servo.new(pin: 13)
+          }.to raise_exception
+        end
+
+        it 'should set the pins to out' do
+          board.should_receive(:set_pin_mode).with(13, :out, nil)
+          Servo.new(pin: 13, board: board)
+        end
+
+        it 'should set the inital position to 0' do
+          servo =  Servo.new(pin: 13, board: board)
+          servo.instance_variable_get(:@position).should == 0
+        end
+      end
+
+      describe '#position' do
+        let(:servo) {servo =  Servo.new(pin: 13, board: board)}
+
+        it 'should set the position of the Servo' do
+          servo.position = 90
+          servo.instance_variable_get(:@position).should == 90
+        end
+
+        it 'should let you write up to 180' do
+          servo.position = 180
+          servo.instance_variable_get(:@position).should == 180
+        end
+
+        it 'should modulate when position > 180' do
+          servo.position = 190
+          servo.instance_variable_get(:@position).should == 10
+        end
+
+        it 'should write the new position to the board' do
+          board.should_receive(:servo_write).with(13, 10)
+          servo.position = 190
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/tx_rx/serial_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Smalrubot
+  describe TxRx::Serial do
+    it { should be }
+
+    describe '#initialize' do
+      it 'should set first_write to true' do
+        TxRx::Serial.new.instance_variable_get(:@first_write).should == true
+      end
+
+      it 'should set the device and buad if specified' do
+        txrx = TxRx::Serial.new({device: "/dev/ttyACM0", baud: 9600})
+        txrx.instance_variable_get(:@baud).should == 9600
+        txrx.instance_variable_get(:@device).should == "/dev/ttyACM0"
+      end
+    end
+
+    describe '#io' do
+      context "on windows" do
+        it 'should instantiate a new ::Serial for the first available tty device' do
+          original_platform = RUBY_PLATFORM
+          Constants.redefine(:RUBY_PLATFORM, "mswin", :on => Object)
+          subject.instance_variable_set('@tty_devices', ["COM1", "COM2", "COM3"])
+
+          # COM2 is chosen as available for this test.
+          ::Serial.should_receive(:new).with("COM1", TxRx::Serial::BAUD).and_raise
+          ::Serial.should_receive(:new).with("COM2", TxRx::Serial::BAUD).and_return(mock_serial = double)
+          ::Serial.should_not_receive(:new).with("COM3", TxRx::Serial::BAUD)
+
+          subject.io.should == mock_serial
+          Constants.redefine(:RUBY_PLATFORM, original_platform, :on => Object)
+        end
+      end
+
+      context "on unix" do
+        it 'should instantiate a new ::Serial for the first available tty device' do
+          subject.should_receive(:tty_devices).and_return(['/dev/ttyACM0', '/dev/tty.usbmodem1'])
+
+          # /dev/ttyACM0 is chosen as available for this test.
+          ::Serial.should_receive(:new).with('/dev/ttyACM0', TxRx::Serial::BAUD).and_return(mock_serial = double)
+          ::Serial.should_not_receive(:new).with('/dev/tty.usbmodem1', TxRx::Serial::BAUD)
+
+          subject.io.should == mock_serial
+        end
+      end
+
+      it 'should connect to the specified device at the specified baud rate' do
+        subject.should_receive(:tty_devices).and_return(["/dev/ttyACM0"])
+        ::Serial.should_receive(:new).with('/dev/ttyACM0', 9600).and_return(mock_serial = double)
+
+        subject.instance_variable_set(:@device, "/dev/ttyACM0")
+        subject.instance_variable_set(:@baud, 9600)
+
+        subject.io.should == mock_serial
+      end
+
+      it 'should use the existing io instance if set' do
+        subject.should_receive(:tty_devices).once.and_return(['/dev/tty.ACM0', '/dev/tty.usbmodem1'])
+        ::Serial.stub(:new).and_return(mock_serial = double)
+
+        3.times { subject.io }
+        subject.io.should == mock_serial
+      end
+
+      it 'should raise a BoardNotFound exception if there is no board connected' do
+        ::Serial.stub(:new).and_raise
+        expect { subject.io }.to raise_exception BoardNotFound
+      end
+    end
+
+    describe '#write' do
+      it 'should write to the device' do
+        subject.stub(:io).and_return(mock_serial = double)
+        msg = 'a message'
+        mock_serial.should_receive(:write).with(msg).and_return(msg.length)
+        subject.write('a message')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+
+require File.expand_path(File.join('../..', 'lib/smalrubot'), __FILE__)
+
+# Nice little helper module to redefine constants quietly.
+module Constants
+  def self.redefine(const, value, opts={})
+    opts = {:on => self.class}.merge(opts)
+    opts[:on].send(:remove_const, const) if self.class.const_defined?(const)
+    opts[:on].const_set(const, value)
+  end
+end