rufirmata 0.0.1

data/lib/rufirmata/arduino.rb

@@ -0,0 +1,6 @@
+class Arduino < Rufirmata::Board
+  def initialize(serial_port_id)
+    super(serial_port_id, :board_type=>:arduino)
+    start_listening
+  end
+end

data/lib/rufirmata/board.rb

@@ -0,0 +1,177 @@
+module Rufirmata
+
+  class Board
+    include Observables::Base
+
+    attr_reader :serial_port, :name, :analog, :digital, :digital_ports, :board_type,
+    :taken,:firmata_version,:firmware, :listening
+
+    def initialize(serial_port, options={})
+      options[:serial_port] = serial_port
+      @serial_port ||= Rufirmata.create_serial_port(options)
+      @name = options[:name] || serial_port
+      @board_type =
+        case options[:board_type]
+        when Hash : options[:board_type]
+        when Symbol : Rufirmata::BOARD_TYPES[options[:board_type]]
+        else Rufirmata::BOARD_TYPES[:arduino]
+        end
+      @taken = { :analog => { }, :digital =>{ } }
+      @listening = false
+      initialize_layout
+    end
+
+    def to_s
+      "Board #{name} on #{serial_port}"
+    end
+
+    def write_command(*commands)
+      message = commands.shift.chr
+      commands.each { |command| message += command.chr }
+      @serial_port.write(message)
+    end
+
+    def write(data)
+      @serial_port.write(data)
+    end
+
+    #    Sends a SysEx msg.
+    #    :arg sysex_cmd: A sysex command byteggg
+    #    :arg data: A list of data values
+    def send_sysex(sysex_cmd, data=[])
+      write_command Rufirmata::START_SYSEX
+      write_command sysex_cmd
+      data.each do |b|
+        begin
+          byte = b.chr
+        rescue
+          byte = (b >> 7).chr
+        end#TODO send multiple bytes
+        write(byte)
+      end
+      write_command Rufirmata::END_SYSEX
+    end
+
+    def close
+      @listening = false
+      @serial_port.close()
+    end
+    alias stop close
+
+    def start_listening
+      @listening = true
+      @listener = Thread.new do
+        while @listening
+          iterate
+          sleep 0.001
+        end
+      end
+
+    end
+
+    # Reads and handles data from the microcontroller over the serial port.
+    #This method should be called in a main loop, or in an
+    #:class:`Iterator` instance to keep this boards pin values up to date
+    def iterate
+      data = @serial_port.getc
+      return unless data
+
+      received_data = []
+
+      if data < Rufirmata::START_SYSEX
+        command = data & 0xF0
+        handler = find_handler(command)
+        return unless handler
+        received_data << (data & 0x0F)
+        while received_data.length < method(handler).arity
+          received_data << @serial_port.getc
+        end
+
+      elsif data == Rufirmata::START_SYSEX
+
+        data = @serial_port.getc
+        handler = find_handler(data)
+        return unless handler
+        data = @serial_port.getc
+        while data != Rufirmata::END_SYSEX
+          received_data << data
+          data = @serial_port.getc
+        end
+
+      else
+        handler = find_handler(data)
+        return unless handler
+        while received_data.length < method(handler).arity
+          received_data << @serial_port.getc
+        end
+      end
+
+      send(handler,*received_data) if handler
+
+    end
+
+    private
+
+    def find_handler(command)
+      case command
+      when Rufirmata::ANALOG_MESSAGE  : :handle_analog_message
+      when Rufirmata::DIGITAL_MESSAGE : :handle_digital_message
+      when Rufirmata::REPORT_VERSION  : :handle_report_version
+      when Rufirmata::REPORT_FIRMWARE : :handle_report_firmware
+      else return
+      end
+    end
+
+    def handle_analog_message(pin_number, lsb, msb)
+      value = (((msb << 7) + lsb).to_f / 1023).prec(4)
+      self.analog[pin_number].value = value if self.analog[pin_number].reporting
+    end
+
+    #Digital messages always go by the whole port. This means we have a
+    # bitmask wich we update the port.
+    def handle_digital_message(port_number, lsb, msb)
+      mask = (msb << 7) + lsb
+      self.digital_ports[port_number].update(mask)
+    end
+
+    def handle_report_version(major, minor)
+      @firmata_version = [major,minor]
+    end
+
+    def handle_report_firmware(*data)
+      major = data.shift
+      minor = data.shift
+      @firmata_version = [major,minor]
+      # TODO this is more complicated, values is send as 7 bit bytes
+      @firmware = data.map{|byte|byte.chr}.join('')
+    end
+
+    def initialize_layout
+      @analog, @digital, @digital_ports  = [], [], []
+
+      @board_type[:analog_pins].each do |pin|
+        @analog << Rufirmata::Pin.new(self, pin, Rufirmata::ANALOG)
+      end
+
+      digital_pins = @board_type[:digital_pins]
+
+      if @board_type[:use_ports]
+        (0...digital_pins.length/7).each  { |port| @digital_ports << Port.new(self, port)}
+      else
+        (0..digital_pins).each do |pin|
+          @digital << Rufirmata::Pin.new(self, pin, Rufirmata::DIGITAL)
+        end
+      end
+
+      (@digital + @analog).each do |pin|
+        pin.set_observer do |sender, type, args|
+          notifier.publish type, args.merge(:pin=>sender)
+        end
+      end
+
+    end #init layout
+
+
+  end #board
+
+end #rufirmata

data/lib/rufirmata/extensions.rb

@@ -0,0 +1,5 @@
+class Float
+  def prec(x)
+    sprintf("%.0" + x.to_i.to_s + "f", self).to_f
+  end
+end

data/lib/rufirmata/pin.rb

@@ -0,0 +1,123 @@
+module Rufirmata
+  #A Pin representation
+  class Pin
+    include Observables::Base
+
+    attr_reader :board, :pin_number, :pin_type, :mode, :port, :pwm, :reporting, :value
+
+    def initialize(board,pin_number,pin_type,port = nil)
+      @board = board
+      @port = port
+      @pin_number = pin_number
+      @pin_type = pin_type
+      @reporting = false
+      @value = nil
+      @pwm = false
+      @mode = Rufirmata::INPUT
+      if pin_type == Rufirmata::DIGITAL
+        @pwm = board.board_type[:pwm_pins].include?(pin_number)
+        @mode = board.board_type[:disabled_pins].include?(pin_number) ?
+        Rufirmata::UNAVAILABLE : Rufirmata::OUTPUT
+      end
+    end
+
+    def to_s
+      type = self.pin_type == Rufirmata::ANALOG ? "Analog" : "Digital"
+      "#{type} pin #{pin_number}"
+    end
+
+
+    # Set the mode of operation for the pin
+    # Can be one of the pin modes: INPUT, OUTPUT, ANALOG or PWM
+    def mode=(mode)
+      #Can be Rufirmata::INPUT, OUTPUT, ANALOG, PWM or UNAVAILABLE
+      return if @mode == mode #Nothing is changing, so nothing to do
+
+      raise "#{to_s} does not have PWM capabilities" if mode == Rufirmata::PWM and !pwm
+      raise "#{to_s} cannot be used through Firmata" if @mode == Rufirmata::UNAVAILABLE
+
+      changing :pin_mode_changed, :changes=>{ :from=>@mode, :to=>mode } do
+        @mode = mode
+        unless mode == Rufirmata::UNAVAILABLE
+          board.write_command(Rufirmata::SET_PIN_MODE, pin_number, mode)
+          enable_reporting if mode == Rufirmata::INPUT
+        end
+      end
+
+    end
+
+    def reporting=(reporting)
+      return if @reporting == reporting
+      changing :reporting_changed, :changes=>{ :from=>@reporting, :to=>reporting } do
+        @reporting = reporting
+      end
+    end
+
+    def value=(new_value)
+      return if @value == new_value
+      changing :value_changed, :changes=>{  :from=>@value, :to=>new_value } do
+        @value = new_value
+      end
+    end
+
+    #Set an input pin to report values
+    def enable_reporting
+      raise "#{to_s} is not an input and therefore cannot report" unless mode == Rufirmata::INPUT
+      if pin_type == Rufirmata::ANALOG
+        self.reporting = true
+        board.write_command(Rufirmata::REPORT_ANALOG + pin_number, 1)
+      elsif port
+        port.enable_reporting
+      end
+    end
+
+    # Disable the reporting of an input pin
+    def disable_reporting
+      if pin_type == Rufirmata::ANALOG
+        @reporting = false
+        board.write_command(Rufirmata::REPORT_ANALOG + pin_number, 0)
+      elsif port
+        port.disable_reporting
+      end
+    end
+
+    #Returns the output value of the pin. This value is updated by the
+    #boards `Board.iterate` method. Value is always in the range 0.0 - 1.0
+    def read
+      raise "Cannot read pin #{to_s} because it is marked as UNAVAILABLE" if mode == Rufirmata::UNAVAILABLE
+      value
+    end
+
+    #Output a voltage from the pin
+    #
+    #   :arg value: Uses value as a boolean if the pin is in output mode, or
+    #       expects a float from 0 to 1 if the pin is in PWM mode.
+    def write(new_value)
+      raise "#{to_s} cannot be used through Firmata" if mode == Rufirmata::UNAVAILABLE
+      raise "#{to_s} is set up as an INPUT and therefore cannot be written to" if mode == Rufirmata::INPUT
+      if (new_value != value)
+        @value = new_value
+        if mode == Rufirmata::OUTPUT
+          port ? port.write() :
+            board.write_command(Rufirmata::DIGITAL_MESSAGE, pin_number, value)
+        elsif mode == Rufirmata::PWM
+          val = (@value * 255).to_i
+          board.write_command(Rufirmata::ANALOG_MESSAGE + pin_number, val % 128, val >> 7)
+        end
+      end
+    end #write
+
+    def send_sysex(sysex_cmd, data=[])
+      #Sends a SysEx message.
+      # :arg sysex_cmd: A sysex command byte
+      # :arg data: A list of data values
+      board.write_command(Rufirmata::START_SYSEX)
+      board.write_command(systex_cmd)
+      data.each do |byte|
+        byte = begin; byte.chr; rescue RangeError; (byte >> 7).chr; end
+        board.write(byte)
+      end
+      board.write_command(Rufirmata::END_SYSEX)
+    end
+  end
+end

data/lib/rufirmata/port.rb

@@ -0,0 +1,62 @@
+module Rufirmata
+  #An 8-bit port on the board
+  class Port
+
+    attr_reader :board, :port_number, :pins
+    attr_accessor :reporting
+
+    def initialize(board, port_number)
+      @board = board
+      @port_number = port_number
+      @reporting = false
+      @pins = []
+      (0..7).each do |pin|
+        pin_num = pin + port_number * 8
+        pins << (pin = Rufirmata::Pin.new(board, pin_num, Rufirmata::DIGITAL, self))
+        board.digital << pin
+      end
+    end
+
+    def to_s; "Digital Port #{port_number}"; end
+
+    #Enable reporting of values for the whole port
+    def enable_reporting
+      @reporting = true
+      board.write_command(Rufirmata::REPORT_DIGITAL + port_number, 1)
+      pins.each {|pin|pin.reporting = true}
+    end
+
+    #Disable reporting of values for the whole port
+    def disable_reporting
+      @reporting = false
+      board.write_command(Rufirmata::REPORT_DIGITAL + port_number, 0)
+    end
+
+    #Set the output pins of the port to the correct state
+    def write
+      mask = 0
+      pins.each do |pin|
+        if (pin.mode == Rufirmata::OUTPUT)
+          if (pin.value == 1)
+            pin_nr = pin.pin_number - port_number * 8
+            mask |= 1 << pin_nr
+          end
+        end
+      end
+      board.write_command(Rufirmata::DIGITAL_MESSAGE + port_number, mask % 128, mask >> 7)
+    end
+
+    #Update the values for the pins marked as input with the mask
+    def update(mask)
+      if reporting
+        pins.each do |pin|
+          if pin.mode == Rufirmata::INPUT
+            pin_nr = pin.pin_number - port_number * 8
+            pin.value = (mask & (1 << pin_nr)) > 1
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/rufirmata/version.rb

@@ -0,0 +1,3 @@
+module Rufirmata
+  VERSION = "0.0.1"
+end

data/lib/rufirmata.rb

@@ -0,0 +1,99 @@
+require 'rubygems'
+require 'serialport'
+require 'observables'
+
+base_dir = File.dirname(__FILE__)
+[
+ 'version',
+ 'extensions',
+ 'pin',
+ 'port',
+ 'board',
+ 'arduino'
+].each {|req| require File.join(base_dir,'rufirmata',req)}
+
+module Rufirmata
+   # Message command bytes - straight from Firmata.h
+  DIGITAL_MESSAGE = 0x90      # send data for a digital pin
+  ANALOG_MESSAGE = 0xE0       # send data for an analog pin (or PWM)
+  DIGITAL_PULSE = 0x91        # SysEx command to send a digital pulse
+
+  # PULSE_MESSAGE = 0xA0      # proposed pulseIn/Out msg (SysEx)
+  # SHIFTOUT_MESSAGE = 0xB0   # proposed shiftOut msg (SysEx)
+  REPORT_ANALOG = 0xC0        # enable analog input by pin #
+  REPORT_DIGITAL = 0xD0       # enable digital input by port pair
+  START_SYSEX = 0xF0          # start a MIDI SysEx msg
+  SET_PIN_MODE = 0xF4         # set a pin to INPUT/OUTPUT/PWM/etc
+  END_SYSEX = 0xF7            # end a MIDI SysEx msg
+  REPORT_VERSION = 0xF9       # report firmware version
+  SYSTEM_RESET = 0xFF         # reset from MIDI
+  QUERY_FIRMWARE = 0x79       # query the firmware name
+
+  # extended command set using sysex (0-127/0x00-0x7F)
+  # 0x00-0x0F reserved for user-defined commands */
+  SERVO_CONFIG = 0x70         # set max angle, minPulse, maxPulse, freq
+  STRING_DATA = 0x71          # a string message with 14-bits per char
+  SHIFT_DATA = 0x75           # a bitstream to/from a shift register
+  I2C_REQUEST = 0x76          # send an I2C read/write request
+  I2C_REPLY = 0x77            # a reply to an I2C read request
+  I2C_CONFIG = 0x78           # config I2C settings such as delay times and power pins
+  REPORT_FIRMWARE = 0x79      # report name and version of the firmware
+  SAMPLING_INTERVAL = 0x7A    # set the poll rate of the main loop
+  SYSEX_NON_REALTIME = 0x7E   # MIDI Reserved for non-realtime messages
+  SYSEX_REALTIME = 0x7F       # MIDI Reserved for realtime messages
+
+
+  # Pin modes.
+  # except from UNAVAILABLE taken from Firmata.h
+  UNAVAILABLE = -1
+  INPUT = 0          # as defined in wiring.h
+  OUTPUT = 1         # as defined in wiring.h
+  ANALOG = 2         # analog pin in analogInput mode
+  PWM = 3            # digital pin in PWM output mode
+
+  # Pin types
+  DIGITAL = OUTPUT   # same as OUTPUT below
+  # ANALOG is already defined above
+
+  BOARD_TYPES = {
+    :arduino => {
+      :digital_pins => (0..13).to_a,
+      :analog_pins => (0..5).to_a,
+      :pwm_pins => [3, 5, 6, 9, 10, 11],
+      :use_ports => true,
+      :disabled_pins => [0, 1, 14, 15] #Rx, Tx, Crystal
+    },
+    :arduino_mega => {
+      :digital_pins => (0..53).to_a,
+      :analog_pins => (0..15).to_a,
+      :pwm_pints => (2..14).to_a,
+      :use_ports => true,
+      :disabled_pins => [0, 1, 14, 15] #Rx, Tx, Crystal
+    }
+  }
+
+  class << self
+    attr_reader :serial_ports
+
+    def create_serial_port(options={})
+      @serial_ports ||= {}
+      options = {
+        :serial_port => "/dev/ttyUSB0",
+        :baud_rate => 57600,
+        :parity => SerialPort::NONE,
+        :data_bits => 8,
+        :stop_bits => 1
+      }.merge(options)
+
+      sp = options[:serial_port]
+      @serial_ports[options] =
+        SerialPort.new(sp,
+                       options[:baud_rate],
+                       options[:data_bits],
+                       options[:stop_bits],
+                       options[:parity])
+    end
+
+  end
+
+end

data/spec/board_spec.rb

@@ -0,0 +1,228 @@
+require "spec_helper"
+
+describe Rufirmata::Board do
+  before(:each) do
+    Rufirmata.stub(:create_serial_port) {  FakeSerial.new }
+    @board = Rufirmata::Board.new("/dev/ttyUSB0")
+  end
+
+  describe "handlers" do
+    it "should return nil for a failed analog read" do
+      @board.analog[3].reporting = true
+      @board.analog[3].read.should be_nil
+    end
+
+    # This sould set it correctly. 1023 (127, 7 in to 7 bit bytes) is the
+    # max value an analog pin will send and it should result in a value 1
+    it "should handle an analog message" do
+      @board.analog[3].reporting = true
+      @board.send(:handle_analog_message,3,127,7)
+      @board.analog[3].read.should == 1.0
+    end
+
+    # A digital message sets the value for a whole port. We will set pin
+    # 5 (That is on port 0) to 1 to test if this is working.
+    it "should handle a digital message" do
+      @board.digital_ports[0].reporting = true
+      @board.digital[5].mode = Rufirmata::INPUT
+      mask = 0
+      mask |= 1 << 5  # set the bit for pin 5 to to 1
+      @board.digital[5].read.should be_nil
+      @board.send(:handle_digital_message, 0, mask % 128, mask >> 7)
+      @board.digital[5].read.should be_true
+    end
+
+    it "should handle report version" do
+      @board.firmata_version.should be_nil
+      @board.send(:handle_report_version,2,1)
+      @board.firmata_version.should == [2,1]
+    end
+
+    it "should handle report firmware" do
+      @board.firmware.should be_nil
+      data  = [2,1]
+      "Firmware_name".each_byte { |b|data << b}
+      @board.send(:handle_report_firmware,*data)
+      @board.firmware.should == 'Firmware_name'
+      @board.firmata_version.should == [2,1]
+    end
+
+    # type                command  channel    first byte            second byte
+    # ---------------------------------------------------------------------------
+    # analog I/O message    0xE0   pin #      LSB(bits 0-6)         MSB(bits 7-13)
+    describe "incoming analog message" do
+      it "should ignore incoming data when reporting=false" do
+        @board.serial_port.write_as_chars Rufirmata::ANALOG_MESSAGE + 4, 127, 7
+        @board.iterate()
+        @board.analog[4].read.should be_nil
+      end
+
+      it "should set incoming data on the pin value when reporting=true" do
+        @board.analog[4].enable_reporting
+        @board.serial_port.clear
+        @board.serial_port.write_as_chars Rufirmata::ANALOG_MESSAGE + 4, 127, 7
+        @board.iterate
+        @board.analog[4].read.should == 1.0
+      end
+    end
+
+    # type                command  channel    first byte            second byte
+    # ---------------------------------------------------------------------------
+    # digital I/O message   0x90   port       LSB(bits 0-6)         MSB(bits 7-13)
+    describe "incoming digital message" do
+      it "should set incoming digital data for input pins" do
+        @board.digital[9].mode = Rufirmata::INPUT
+        @board.serial_port.clear
+        mask = 0; mask |= 1 << (9 - 8) #set the bit for pin 9 to 1
+        @board.digital[9].read.should be_nil
+        @board.serial_port.write_as_chars Rufirmata::DIGITAL_MESSAGE + 1, mask % 128, mask >> 7
+        @board.iterate
+        @board.digital[9].read.should be_true
+      end
+    end
+
+    # version report format
+    # -------------------------------------------------
+    # 0  version report header (0xF9) (MIDI Undefined)
+    # 1  major version (0-127)
+    # 2  minor version (0-127)
+    describe "incoming report version" do
+      it "should set the firmata version" do
+        @board.serial_port.write_as_chars Rufirmata::REPORT_VERSION, 2, 1
+        @board.iterate
+        @board.firmata_version.should == [2,1]
+      end
+    end
+
+    # Receive Firmware Name and Version (after query)
+    # 0  START_SYSEX (0xF0)
+    # 1  queryFirmware (0x79)
+    # 2  major version (0-127)
+    # 3  minor version (0-127)
+    # 4  first 7-bits of firmware name
+    # 5  second 7-bits of firmware name
+    # x  ...for as many bytes as it needs)
+    # 6  END_SYSEX (0xF7)
+    describe "incoming report firmware" do
+      before(:each) do
+        @board.serial_port.write_as_chars Rufirmata::START_SYSEX, Rufirmata::REPORT_FIRMWARE, 2, 1
+        @board.serial_port.write 'Firmware_name'.split(//)
+        @board.serial_port.write_as_chars Rufirmata::END_SYSEX
+        @board.iterate
+      end
+      it "should have set the appropriate firmware name" do
+        @board.firmware.should == 'Firmware_name'
+      end
+      it "should have set the firmata version" do
+        @board.firmata_version.should == [2,1]
+      end
+    end
+
+    # type                command  channel    first byte            second byte
+    # ---------------------------------------------------------------------------
+    # report analog pin     0xC0   pin #      disable/enable(0/1)   - n/a -
+    describe "report analog" do
+      it "should write an enable reporting command to the serial port" do
+        @board.analog[1].enable_reporting
+        @board.serial_port.should have_received_bytes( 0xC0 + 1, 1 )
+        @board.analog[1].reporting.should be_true
+      end
+      it "should write a disable reporting command to the serial port" do
+        @board.analog[1].reporting = true
+        @board.analog[1].disable_reporting
+        @board.serial_port.should have_received_bytes( 0xC0 + 1, 0 )
+        @board.analog[1].reporting.should be_false
+      end
+    end
+
+    # type                command  channel    first byte            second byte
+    # ---------------------------------------------------------------------------
+    # report digital port   0xD0   port       disable/enable(0/1)   - n/a -
+    describe "report digital" do
+      before(:each){ @board.digital[8].mode = Rufirmata::INPUT; @board.serial_port.clear }
+      # This should enable reporting of whole port 1
+      it "should write an enable reporting command for the port" do
+        @board.digital[8].enable_reporting
+        @board.serial_port.should have_received_bytes( 0xD0 + 1, 1 )
+        @board.digital[8].reporting.should be_true
+      end
+
+      it "should write a disable reporting command for the port" do
+        @board.digital[8].reporting = true
+        @board.digital[8].disable_reporting
+        @board.serial_port.should have_received_bytes( 0xD0 + 1, 0 )
+      end
+    end
+
+    # Generic Sysex Message
+    # 0     START_SYSEX (0xF0)
+    # 1     sysex command (0x00-0x7F)
+    # x     between 0 and MAX_DATA_BYTES 7-bit bytes of arbitrary data
+    # last  END_SYSEX (0xF7)
+    describe "SYSEX" do
+      it "should send a sysex message" do
+        @board.send_sysex 0x79, [1,2,3]
+        @board.serial_port.should have_received_bytes 0xF0, 0x79, 1, 2, 3, 0xF7
+      end
+
+      it "should receive a sysex message" do
+        @board.serial_port.write [0xF0, 0x79, 2, 1, 'a'[0], 'b'[0], 'c'[0], 0xF7].map{ |b|b.chr}
+        while @board.serial_port.length > 0
+          @board.iterate
+        end
+        @board.firmata_version.should == [2,1]
+        @board.firmware.should == 'abc'
+      end
+    end
+
+    describe "sending extraneous data" do
+      it "should be ignored" do
+        @board.analog[4].enable_reporting
+        @board.serial_port.clear
+        #Garbage
+        @board.serial_port.write_as_chars( *(0..10).to_a )
+        #Set analog port 4 to 1
+        @board.serial_port.write_as_chars Rufirmata::ANALOG_MESSAGE + 4, 127, 7
+        #More garbage
+        @board.serial_port.write_as_chars( *(0..10).to_a )
+        while @board.serial_port.length > 0
+          @board.iterate
+        end
+        @board.analog[4].read.should == 1.0
+      end
+    end
+
+    describe "notifications" do
+      before :each do
+        @changes = []
+        @board.subscribe do |type,args|
+          @changes << [type,args]
+        end
+      end
+
+
+      describe "when a pin is changed" do
+        before(:each){@board.analog[0].value = 1.1}
+
+        it "should issue before and after change notifications" do
+          @changes.length.should == 2
+          @changes[0][0].should == :before_value_changed
+          @changes[1][0].should == :after_value_changed
+        end
+
+        it "should pass the pin in the event args" do
+          @changes[0][1][:pin].should == @board.analog[0]
+        end
+
+        it "should provide the previous and new values of the pin" do
+          @changes.each do |c|
+            c[1][:changes].should == { :from=>nil, :to=>1.1}
+          end
+        end
+
+      end
+    end
+  end
+
+end
+

data/spec/pin_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Rufirmata::Pin do
+  before(:each) do
+    Rufirmata.stub(:create_serial_port) {  FakeSerial.new }
+    @board = Rufirmata::Board.new("/dev/ttyUSB0")
+  end
+
+  describe "notifications" do
+    before :each do
+      @changes = []
+      @pin = Rufirmata::Pin.new(@board, 2, Rufirmata::DIGITAL)
+      @pin.subscribe do |type, args|
+        @changes << [type, args]
+      end
+    end
+
+    describe "#mode" do
+      before(:each) { @pin.mode = Rufirmata::INPUT }
+
+      it "should issue a change notice before and after the change" do
+        @changes.count.should == 2
+        @changes[0][0].should == :before_pin_mode_changed
+        @changes[1][0].should == :after_pin_mode_changed
+      end
+
+      it "should notify changes to the pin mode" do
+        @changes.each do |c|
+          c[1].changes[:from].should == Rufirmata::OUTPUT
+          c[1].changes[:to].should == Rufirmata::INPUT
+        end
+      end
+
+      it "should not issue a notification if nothing changed" do
+        @changes.clear
+        @pin.mode = Rufirmata::INPUT
+        @changes.length.should == 0
+      end
+
+    end
+
+    describe "#reporting" do
+      before(:each){  @pin.reporting = true }
+
+      it "should issue a change before and after reporting changed" do
+        @changes.length.should == 2
+        @changes[0][0].should == :before_reporting_changed
+        @changes[1][0].should == :after_reporting_changed
+      end
+
+      it "should notify changes to reporting" do
+        @changes.each do |c|
+          c[1].changes[:from].should == false
+          c[1].changes[:to].should == true
+        end
+      end
+
+      it "should not issue a change when not changed" do
+        @changes.clear
+        @pin.reporting = true
+        @changes.length.should == 0
+      end
+    end
+
+    describe "#reporting" do
+      before(:each){  @pin.value = 1 }
+
+      it "should issue a change before and after value changed" do
+        @changes.length.should == 2
+        @changes[0][0].should == :before_value_changed
+        @changes[1][0].should == :after_value_changed
+      end
+
+      it "should notify changes to value" do
+        @changes.each do |c|
+          c[1].changes[:from].should == nil
+          c[1].changes[:to].should == 1
+        end
+      end
+
+      it "should not issue a change when not changed" do
+        @changes.clear
+        @pin.value = 1
+        @changes.length.should == 0
+      end
+    end
+
+  end
+end

data/spec/rufirmata_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe Rufirmata do
+  it "should exist" do
+    Rufirmata::VERSION.should_not be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rufirmata'
+require 'rspec'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/stubs/**/*.rb"].each {|f| require f}
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :have_received_bytes do |*expected|
+  match do |actual|
+    res = actual.read()
+    serial_msg = res
+    until res.nil? or res.empty?
+      res = actual.read()
+      serial_msg += res
+    end
+    expected = expected.map{|b|b.chr}.join('')
+    actual.instance_eval "def last_received; '#{serial_msg.inspect}'; end"
+    expected == serial_msg
+  end
+  failure_message_for_should do |actual|
+    "expected to receive #{expected.inspect} but received #{actual.last_received}"
+  end
+end
+
+Rspec.configure do |config|
+  # == Mock Framework
+
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  config.before(:each) do
+
+  end
+
+end

data/spec/stubs/fake_serial.rb

@@ -0,0 +1,50 @@
+
+ #   A Mock object for ruby's Serial. Functions as a fifo-stack. Push to
+ #   it with ``write``, read from it with ``read``.
+ #
+ #   >>> s = Serial.new('someport', 4800)
+ #   >>> s.read()
+ #   ''
+ #   >>> s.write(chr(100))
+ #   >>> s.write('blaat')
+ #   >>> s.write(100000)
+ #   >>> s.read(2)
+ #   ['d', 'blaat']
+ #   >>> s.read()
+ #   100000
+ #   >>> s.read()
+ #   ''
+ #   >>> s.read(2)
+ #   ['', '']
+ #   >>> s.close()
+class FakeSerial < Array
+
+  def getc
+    read[0]
+  end
+
+  def read(count=1)
+    if count > 1
+      val = []
+      [i..count].each do |i|
+          val << (shift || '')
+      end
+    else
+      val = (shift || '')
+    end
+    val
+  end
+
+  def write(value)
+    (self << value).flatten!
+  end
+
+  def write_as_chars(*vals)
+    write vals.map{ |v| v.chr }
+  end
+
+  def close
+    clear()
+  end
+
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: rufirmata
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nathan Stults
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-27 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-serialport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: observables
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fuubar
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: A Ruby port of pyFirmata, software for interfacing with firmata-enabled microcontrollers
+email: hereiam@sonic.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rufirmata.rb
+- lib/rufirmata/extensions.rb
+- lib/rufirmata/pin.rb
+- lib/rufirmata/arduino.rb
+- lib/rufirmata/board.rb
+- lib/rufirmata/port.rb
+- lib/rufirmata/version.rb
+- spec/stubs/fake_serial.rb
+- spec/spec_helper.rb
+- spec/board_spec.rb
+- spec/pin_spec.rb
+- spec/rufirmata_spec.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/PlasticLizard/rufirmata
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A ruby firmata client for interfacing with microcontollers running firmata compatible firmware
+test_files: []
+