phidgets-ffi 0.0.5 → 0.1.0

data/lib/phidgets-ffi/phidgets-ffi.rb

@@ -1,6 +1,19 @@
 module Phidgets
   module FFI
+  
     extend ::FFI::Library
-    ffi_lib '/Library/Frameworks/Phidget21.framework/Versions/Current/Phidget21'
+
+  	if Config::CONFIG['target_os'] =~ /darwin/ #Mac OS X
+      ffi_lib '/Library/Frameworks/Phidget21.framework/Versions/Current/Phidget21'
+    else # Linux
+      ffi_lib '/usr/lib/libphidget21.so' 
+    end
+
   end
-end
+end
+
+
+
+
+
+

data/lib/phidgets-ffi/rfid.rb

@@ -0,0 +1,220 @@
+module Phidgets
+
+  # This class represents a CPhidgetRFID.
+  class RFID
+ 
+    Klass = Phidgets::FFI::CPhidgetRFID
+    include Phidgets::Common
+    
+	# Collection of digital outputs
+	# @return [RFIDOutputs] 
+	attr_reader :outputs
+	
+	attr_reader :attributes
+    
+	# The attributes of a PhidgetRFID
+	def attributes
+      super.merge({
+        :outputs => outputs.size,
+		:antenna => antenna,
+		:led => led,
+      })
+    end
+	
+    # Sets an output change handler callback function. This is called when a digital output on the PhidgetRFID board has changed.
+    #
+    # @param [String] obj Object to pass to the callback function. This is optional.
+    # @param [Proc] Block When the callback is executed, the device and object are yielded to this block.
+    # @example
+    #     rfid.on_output_change do |device, output, state, obj|
+    #       print "Digital Output  #{output.index}, changed to #{state}\n"
+    #     end
+    # As this runs in it's own thread, be sure that all errors are properly handled or the thread will halt and not fire any more.
+    # @return [Boolean] returns true or raises an error
+    def on_output_change(obj=nil, &block)
+      @on_output_change_obj = obj
+      @on_output_change = Proc.new { |device, obj_ptr, index, state|
+        yield self, @outputs[index], (state == 0 ? false : true), object_for(obj_ptr)
+      }
+      Klass.set_OnOutputChange_Handler(@handle, @on_output_change, pointer_for(obj))
+    end
+	
+    # Sets a tag handler callback function. This is called when a new tag is seen by the reader. The event is only fired one time for a new tag, so the tag has to be removed and then replaced before another tag gained event will fire.
+    #
+    # @param [String] obj Object to pass to the callback function. This is optional.
+    # @param [Proc] Block When the callback is executed, the device and object are yielded to this block.
+    # @example
+    #     rfid.on_tag do |device, tag, obj|
+    #       puts "Tag #{tag} detected"
+    #     end
+    # As this runs in it's own thread, be sure that all errors are properly handled or the thread will halt and not fire any more.
+    # @return [Boolean] returns true or raises an error
+    def on_tag(obj=nil, &block)
+	  @on_tag_obj = obj
+      @on_tag = Proc.new { |device, obj_ptr, tag|
+		yield self, convert_int_to_hex(tag), object_for(obj_ptr)
+	}
+      Klass.set_OnTag_Handler(@handle, @on_tag, pointer_for(obj))
+    end
+	
+    # Sets a tag lost handler callback function. This is called when a tag is removed from the reader
+    #
+    # @param [String] obj Object to pass to the callback function. This is optional.
+    # @param [Proc] Block When the callback is executed, the device and object are yielded to this block.
+    # @example
+    #     rfid.on_tag_lost do |device, tag, obj|
+    #       puts "Tag #{tag} removed"
+    #     end
+    # As this runs in it's own thread, be sure that all errors are properly handled or the thread will halt and not fire any more.
+    # @return [Boolean] returns true or raises an error
+    def on_tag_lost(obj=nil, &block)
+	  @on_tag_lost_obj = obj
+      @on_tag_lost = Proc.new { |device, obj_ptr, tag|
+	    yield self, convert_int_to_hex(tag), object_for(obj_ptr)
+	}
+      Klass.set_OnTagLost_Handler(@handle, @on_tag_lost, pointer_for(obj))
+    end
+
+    # Returns the antenna state of the Phidget.
+    #
+    # @return [Boolean] returns the ratiometric state or raises an error
+    def antenna
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getAntennaOn(@handle, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+
+    # Sets the antenna state of the Phidget. True turns the antenna on, false turns it off. The antenna if by default turned off, and needs to be explicitely activated before tags can be read. Control over the antenna allows multiple readers to be used in close proximity, as multiple readers will interfere with each other if their antenna's are activated simultaneously.
+    # @param [Boolean] new_state new antenna state
+    # @return [Boolean] returns the antenna state, or raises an error
+    def antenna=(new_state)
+      tmp = new_state ? 1 : 0
+      Klass.setAntennaOn(@handle, tmp)
+      new_state
+    end
+	
+    # Returns the LED state.
+    #
+    # @return [Boolean] returns the LED state or raises an error
+    def led
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getLEDOn(@handle, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+
+    # Sets the LED. True turns the LED on, false turns it off. The LED is by default turned off.
+    # @param [Boolean] new_state new LED state
+    # @return [Boolean] returns the LED state or raises an error
+    def led=(new_state)
+      tmp = new_state ? 1 : 0
+      Klass.setLEDOn(@handle, tmp)
+      new_state
+    end
+	
+    # Returns the last tag read by the reader. This may or may not still be on the reader - use {Phidgets::RFID#tag_present} to find out.
+    #
+    # @return [String] returns the last tag or raises an error
+    def last_tag
+	  tag_size = 5
+	  tag_ffi = ::FFI::MemoryPointer.new(:uchar, tag_size)
+      Klass.getLastTag(@handle, tag_ffi)
+
+      convert_int_to_hex(tag_ffi)	  
+	end
+	
+	# Returns the value indicating whether or not a tag is on the reader.
+    #
+    # @return [Boolean] returns a value indicating whether or not a tag is on the reader, or raises an error
+    def tag_present
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getTagStatus(@handle, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+	
+  # This class represents an digital output for a PhidgetRFID All the properties of an digital output are stored and modified in this class.
+  class RFIDOutputs
+    Klass = Phidgets::FFI::CPhidgetRFID
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+
+	public
+	
+	# Displays data for the digital output
+    def inspect
+      "#<#{self.class} @index=#{index}, @state=#{state}>"
+    end
+	
+    # @return [Integer] returns index of the digital output, or raises an error.
+	def index 
+		@index
+	end
+	
+	# Sets the state of the digital output, or raises an error.
+	# @param [Boolean] new_state new state
+	# @return [Boolean] sets the state of the digital output, or raises an error.
+	def state=(new_state)
+      tmp = new_state ? 1 : 0
+      Klass.setOutputState(@handle, @index, tmp)
+      new_state
+    end
+
+	# @return [Boolean] returns state of the digital output, or raises an error.
+    def state
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getOutputState(@handle, @index, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+
+	# @return [Boolean] returns true if the state is true.
+    def on
+      state == true
+    end
+	alias_method :on?, :on
+    
+	# @return [Boolean] returns true if the state is off.
+    def off
+      !on
+    end
+    alias_method :off?, :off
+  end
+    
+	private
+    
+	def load_device_attributes
+		load_outputs
+	end
+
+    def load_outputs
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getOutputCount(@handle, ptr)
+
+      @outputs = []
+      ptr.get_int(0).times do |i|
+        @outputs << RFIDOutputs.new(@handle, i)
+      end
+    end
+	
+	def convert_int_to_hex(int_tag)
+		tag_string = []
+		5.times { |i|
+			if int_tag[i].get_uchar(0).to_s(16).size == 1  #ruby removes leading 0, so we will put the 0 back in.
+				tag_string[i] = "0#{int_tag[i].get_uchar(0).to_s(16)}"
+			else
+				tag_string[i] = int_tag[i].get_uchar(0).to_s(16)
+			end
+		}
+		tag_string
+	end
+	
+	def remove_specific_event_handlers
+	   Klass.set_OnOutputChange_Handler(@handle, nil, nil)
+	   Klass.set_OnTag_Handler(@handle, nil, nil)
+	   Klass.set_OnTagLost_Handler(@handle, nil, nil)
+	end
+	
+  end
+   
+end

data/lib/phidgets-ffi/servo.rb

@@ -1,112 +1,154 @@
 module Phidgets
-  class ServoController
 
+  # This class represents a PhidgetServo.
+  class Servo
+ 
     Klass = Phidgets::FFI::CPhidgetServo
     include Phidgets::Common
     
+	# Collection of servo motors
+	# @return [ServoServos] 
     attr_reader :servos
-
-    def initialize(serial_number=-1, &block)
-      create
-      open(serial_number)
-      wait_for_attachment
-      load_servos
-      if block_given?
-        yield self
-        close
-        delete
-      end
-    end
-    
+	
+	attr_reader :attributes
+		
+	# The attributes of a PhidgetServo
     def attributes
       super.merge({
         :servos => servos.size,
       })
     end
 
-    def on_change(obj=nil, &block)
-      @on_change_obj = obj
-      @on_change = Proc.new { |device, obj_ptr, index, position|
-        yield @servos[index], position, object_for(obj_ptr)
+    # Sets a position change handler callback function. This is called when a the servo position has changed.
+    #
+    # @param [String] obj Object to pass to the callback function. This is optional.
+    # @param [Proc] Block When the callback is executed, the device and object are yielded to this block.
+    # @example
+    #     servo.on_position_change do |motor, position, obj|
+    #       puts "Moving servo #{motor.index} to #{position}"
+    #     end
+    # As this runs in it's own thread, be sure that all errors are properly handled or the thread will halt and not fire any more.
+    # @return [Boolean] returns true or raises an error
+      def on_position_change(obj=nil, &block)
+      @on_position_change_obj = obj
+      @on_position_change = Proc.new { |device, obj_ptr, index, position|
+        yield self, @servos[index], position, object_for(obj_ptr)
       }
-      Klass.set_OnPositionChange_Handler(@handle, @on_change, pointer_for(obj))
+      Klass.set_OnPositionChange_Handler(@handle, @on_position_change, pointer_for(obj))
     end
-
-    private
-    
-    def load_servos
-      ptr = ::FFI::MemoryPointer.new(:int)
-      Klass.getMotorCount(@handle, ptr)
-
-      @servos = []
-      ptr.get_int(0).times do |i|
-        @servos << Servo.new(@handle, i)
-      end
-    end
-  end
-  
-  class Servo
+	
+  # This class represents a servo motor for a PhidgetServo. All the properties of an servo motor are stored and modified in this class.
+  class ServoServos
     Klass = Phidgets::FFI::CPhidgetServo
 
-    attr_reader :index
-    
+	private
     def initialize(handle, index)
       @handle, @index = handle, index.to_i
     end
-    
+
+	public
+	# Displays data for the servo motor.
+    def inspect
+      "#<#{self.class} @index=#{index}, @engaged=#{engaged}, @position_min=#{position_min}, @position_max=#{position_max}, @type=#{type}>"
+	end
+
+	# @return [Integer] returns the index of the servo motor, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Boolean] returns the engaged state of a servo motor, or raises an error.
     def engaged
-      ptr = ::FFI::MemoryPointer.new(:int, 1)
+      ptr = ::FFI::MemoryPointer.new(:int)
       Klass.getEngaged(@handle, @index, ptr)
       (ptr.get_int(0) == 0) ? false : true
     end
-    alias_method :engaged?, :engaged
-    
-    def engaged=(val)
-      tmp = val ? 1 : 0
-      Klass.setEngaged(@handle, @index, tmp)
 
-      val
+	# Sets the engaged state of a servo motor, or raises an error.
+	# @param [Boolean] new_state new state
+	# @return [Boolean] returns engaged state of a servo motor, or raises an error.
+    def engaged=(new_state)
+      tmp = new_state ? 1 : 0
+      Klass.setEngaged(@handle, @index, tmp)
+      new_state
     end
-    
-    def max
-      ptr = ::FFI::MemoryPointer.new(:double, 1)
-      Klass.getPositionMax(@handle, @index, ptr)
+	
+	# @return [Float] returns the largest position value that the servo motor will accept, or raises an error.
+    def position_min
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getPositionMin(@handle, @index, ptr)
       ptr.get_double(0)
     end
-    
-    def min
-      ptr = ::FFI::MemoryPointer.new(:double, 1)
-      Klass.getPositionMin(@handle, @index, ptr)
+
+	# @return [Float] returns the largest position value that the servo motor will accept, or raises an error.
+    def position_max
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getPositionMax(@handle, @index, ptr)
       ptr.get_double(0)
     end
-    
+	
+	# @return [Float] returns the position of the servo motor, or raises an error.
     def position
-      ptr = ::FFI::MemoryPointer.new(:double, 1)
+      ptr = ::FFI::MemoryPointer.new(:double)
       Klass.getPosition(@handle, @index, ptr)
       ptr.get_double(0)
     end
-
+	
+	# Sets the position of the servo motor, or raises an error.
+	# @param [Float] new_position new position
+	# @return [Float] returns the position of the servo motor, or raises an error.
     def position=(new_position)
       Klass.setPosition(@handle, @index, new_position.to_f)
       new_position
     end
-    
-    def type
+	
+	# @return [Phidgets::FFI::ServoType] returns the servo type of the servo motor, or raises an error.
+	def type
       ptr = ::FFI::MemoryPointer.new(:int)
       Klass.getServoType(@handle, @index, ptr)
-      
       Phidgets::FFI::ServoType[ptr.get_int(0)]
     end
 
+	# Sets the servo type of the servo motor, or raises an error. This determines how degrees are calculated from PCM pulses, and sets min and max angles.
+	# @param [Phidgets::FFI::ServoType] new_type new type
+	# @return [Phidgets::FFI:ServoType] returns the servo type of the servo motor, or raises an error.
     def type=(servo_type=:default)
       ptr = ::FFI::MemoryPointer.new(:int)
       Klass.setServoType(@handle, @index, Phidgets::FFI::ServoType[servo_type])
       servo_type
     end
-    
-    def set_parameters(min_pcm, max_pcm, degrees)
+
+	# Sets custom servo parameters for using a servo not in the predefined list. Pulse widths are specified in microseconds.
+	# @param [Float] new_minimum_pulse_width new minimum pulse width
+	# @param [Float] new_maximum_pulse_width new maximum pulse width
+	# @param [Float] new_degrees new degrees
+	# @return [Boolean] returns true if the servo parameters are successfully set, or raises an error.
+    def set_servo_parameters(min_pcm, max_pcm, degrees)
       Klass.setServoParameters(@handle, @index, min_pcm.to_f, max_pcm.to_f, degrees.to_f)
       true
     end
+	
+  end #ServoServos
+  
+	private
+    
+	def load_device_attributes
+	  load_servos
+	end
+
+    def load_servos
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getMotorCount(@handle, ptr)
+      @servos = []
+      ptr.get_int(0).times do |i|
+        @servos << ServoServos.new(@handle, i)
+      end
+
+    end
+	
+	def remove_specific_event_handlers
+	   Klass.set_OnPositionChange_Handler(@handle, nil, nil)
+	end
   end
-end
+
+end