phidgets-ffi 0.0.5 → 0.1.0

data/lib/phidgets-ffi/led.rb

@@ -0,0 +1,112 @@
+module Phidgets
+
+  # This class represents a PhidgetLED.
+  class LED
+ 
+    Klass = Phidgets::FFI::CPhidgetLED
+    include Phidgets::Common
+    
+	# Collection of LEDs
+	# @return [LEDOuputs] 
+    attr_reader :leds
+	
+	attr_reader :attributes
+		
+	# The attributes of a PhidgetLED
+    def attributes
+      super.merge({
+        :leds => leds.size,
+      })
+    end
+
+	# @return [Phidgets::FFI::LEDCurrentLimit] returns the board current limit for all LEDs, or raises an error. Not supported on all PhidgetLEDs.
+	def current_limit
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getCurrentLimit(@handle, ptr)
+      Phidgets::FFI::LEDCurrentLimit[ptr.get_int(0)]
+    end
+
+	# Sets the board current limit for all LEDs, or raises an error. Not supported on all PhidgetLEDs.
+	# @param [Phidgets::FFI::LEDCurrentLimit] new_current_limit new current limit
+	# @return [Phidgets::FFI::LEDCurrentLimit] returns the board current limit, or raises an error.
+    def current_limit=(new_current_limit)
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.setCurrentLimit(@handle, Phidgets::FFI::LEDCurrentLimit[new_current_limit])
+      new_current_limit
+    end
+
+	# @return [Phidgets::FFI::LEDVoltage] returns the voltage level for all LEDs, or raises an error. Not supported on all PhidgetLEDs.
+	def voltage
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getVoltage(@handle, ptr)
+      Phidgets::FFI::LEDVoltage[ptr.get_int(0)]
+    end
+
+	# Sets the voltage level for all LEDs, or raises an error. Not supported on all PhidgetLEDs.
+	# @param [Phidgets::FFI::LEDVoltage] new_voltage new voltage
+	# @return [Phidgets::FFI::LEDVoltage] returns the voltage level, or raises an error.
+    def voltage=(new_voltage)
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.setVoltage(@handle, Phidgets::FFI::LEDVoltage[new_voltage])
+      new_voltage
+    end
+	
+  # This class represents an led for a PhidgetLED. All the properties of an led are stored and modified in this class.
+  class LEDOuputs
+    Klass = Phidgets::FFI::CPhidgetLED
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+
+	public
+	# Displays data for an led.
+    def inspect
+      "#<#{self.class} @index=#{index}, @brightness=#{brightness}>"
+	end
+
+	# @return [Integer] returns the index of the servo motor, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Integer] returns the brightness level of an LED, or raises an error.
+    def brightness
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getDiscreteLED(@handle, @index, ptr)
+      ptr.get_int(0)
+    end
+
+	# Sets the brightness level of an LED, or raises an error. Brightness levels range from 0-100
+	# @param [Integer] new_brightness new brightness
+	# @return [Integer] returns the brightness of an LED, or raises an error.
+    def brightness=(new_brightness)
+      Klass.setDiscreteLED(@handle, @index, new_brightness.to_i)
+      new_brightness.to_i
+    end
+	
+  end #LEDOutputs
+  
+	private
+    
+	def load_device_attributes
+	  load_leds
+	end
+
+    def load_leds
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getLEDCount(@handle, ptr)
+      @leds = []
+      ptr.get_int(0).times do |i|
+        @leds << LEDOuputs.new(@handle, i)
+      end
+
+    end
+	
+	def remove_specific_event_handlers
+	 
+	end
+  end
+
+end

data/lib/phidgets-ffi/log.rb

@@ -2,26 +2,38 @@ module Phidgets
   class Log
     Klass = Phidgets::FFI::Log
 
+	# Enables logging, or raises an error.
+	# @param [Phidgets::FFI::LogLevel] level The highest level of logging to output. All lower levels will also be output.
+	# @param [String] output_file File to output log to. This should be a full pathname, not a relative pathname. Optional. If no output file is specified, the output will print to console.
+	# @return [Boolean] returns true, or raises an error.
     def self.enable(loglevel=:warning, filename=nil)
       Klass.enableLogging(loglevel, filename.to_s)
       true
     end
 
+	# Disables logging, or raises an error.
+	# @return [Boolean] returns true, or raises an error.
     def self.disable
       Klass.disableLogging
       true
     end
     
+	# Appends a message to the log, or raises an error.
+	# @param [Phidgets::FFI::LogLevel] level the level at which to log the message.
+	# @param [String] output_file File to output log to. This should be a full pathname, not a relative pathname. Optional. If no output file is specified, the output will print to console.
+	# @param [String] message the message
+	# @return [Boolean] returns true, or raises an error.
     def self.log(loglevel, identifier, message, *args)
       Klass.log(loglevel, identifier, message, *args)
     end
     
+	private
     def self.method_missing(method, *args, &block)
-      if Phidgets::FFI::LogLevel.symbols.include?(method)
+	  if Phidgets::FFI::LogLevel.symbols.include?(method)
         log(method, *args)
         true
       else
-        super(method, *args, &block)
+	    super(method, *args, &block)
       end
     end
   end

data/lib/phidgets-ffi/manager.rb

@@ -1,55 +1,105 @@
 module Phidgets
-  class Manager
+ 
+ # This class represents a PhidgetManager.
+ class Manager
     Klass = Phidgets::FFI::CPhidgetManager
     include Utility
 
-    def initialize(&block)
+   # Initializes a PhidgetManager. There are two methods that you can use to program the PhidgetManager.
+   # 
+   # @param [String] options Information required to connect to the WebService. This is optional. If no option is specified, it is assumed that the address is localhost and port is 5001
+   # @param [Proc] Block When the callback is executed, the device and object are yielded to this block.
+   #	
+   # @return [Object]
+   #
+   # <b>First Method:</b> You can program with a block. 
+   #  options = {:address => 'localhost', :port => 5001, :server_id => nil, :password => nil}
+   #  Phidgets::Manager.new(options) do |man| 
+   #    ...
+   #  end
+   #
+   # <b>Second Method:</b> You can program without a block
+   #  man = Phidgets::Manager.new
+	def initialize(options={}, &block)
+	  create
+      
+	  password = (options[:password].nil? ? nil : options[:password].to_s)
+	  if !options[:server_id].nil? or !options[:address].nil?
+		if !options[:server_id].nil?
+			open_remote(options, password)
+		else
+			open_remote_ip(options, password)
+		end
+		sleep 3
+	  else
+		open
+	  end
       if block_given?
-        create
-        open
         yield self
         close
-        delete
       end
     end
     
-    def create
+    private
+	def create
       ptr = ::FFI::MemoryPointer.new(:pointer, 1)
       Klass.create(ptr)        
       @handle = ptr.get_pointer(0)
       true
     end
 
-    def open
+    def open 
       Klass.open(@handle)
-      # There is no waiting for attachments in the manager, the check is instant so we sleep for a second to give it a chance to register things
+      
       sleep 1
       true
     end
     
-    def close
-      Klass.close(@handle)
+	def open_remote(options, password)
+      Klass.openRemote(@handle, options[:server_id].to_s, password)
+      sleep 2
       true
     end
-
-    def delete
-      Klass.delete(@handle)
+	
+	def open_remote_ip(options, password)
+      Klass.openRemoteIP(@handle, options[:address].to_s, options[:port].to_i, password)
+      sleep 2
       true
     end
+	
+    public
+	
+    # Closes and frees a PhidgetManager
+    # 
+    # @return [Boolean] returns true or raises an error
+	def close
+      remove_specific_event_handlers
+	  sleep 0.2
+	  Klass.close(@handle)
+      Klass.delete(@handle)
+	  true
+    end
 
-    def devices(timeout=5000)
-      devices_ptr, count = ::FFI::MemoryPointer.new(:pointer, 1), ::FFI::MemoryPointer.new(:int)
-      Klass.getAttachedDevices(@handle, devices_ptr, count)
-      devices = devices_ptr.get_array_of_pointer(0, count.get_int(0))
-      device_arr = devices.map do |device|
-        device = device.get_pointer(0)
-        Common.attributes(device)
-      end
-      Klass.freeAttachedDevicesArray(devices_ptr)
+	# @return [Array] returns a list of the handles of all currently attached Phidgets, or raises an error. You can use the handles with the Phidgets::Common class methods; See the example for more details.
+    def devices
+		devices_ptr, count = ::FFI::MemoryPointer.new(:pointer, 300), ::FFI::MemoryPointer.new(:int)
+        Klass.getAttachedDevices(@handle, devices_ptr, count)
+        
+        devices = devices_ptr.get_array_of_pointer(0, count.get_int(0))
+
+        device_array = []
+        count.get_int(0).times do |i|
+			device_array[i] = devices[0].get_pointer(i*Phidgets::FFI::FFI_POINTER_SIZE)
+			
+        end
+        
+        #Klass.freeAttachedDevicesArray(devices_ptr) #error
       
-      device_arr
+      device_array
+	  
     end
 
+	# @return [String] returns the server id of a remotely opened PhidgetManager, or raises an error. This will fail if the manager was opened locally.
     def server_id
       ptr = ::FFI::MemoryPointer.new(:string)
       Phidgets::FFI::Common.getServerID(@handle, ptr)
@@ -57,6 +107,7 @@ module Phidgets
       strPtr.null? ? nil : strPtr.read_string
     end
     
+	# @return [String] returns the address and port of a remotely opened PhidgetManager, or raises an error. This will fail if the manager was opened locally.
     def server_address
       str_ptr, int_ptr = ::FFI::MemoryPointer.new(:string), ::FFI::MemoryPointer.new(:int)
       Phidgets::FFI::Common.getServerID(@handle, str_ptr, int_ptr)
@@ -65,23 +116,60 @@ module Phidgets
       port = int_ptr.get_int(0)
       [address, port]
     end
-    
+	
+	# @return [String] returns the connected to server status, or raises an error    
+    def status
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getServerStatus(@handle, ptr)
+      Phidgets::FFI::ServerStatus[ptr.get_int(0)]
+    end
+
+    # Sets an attach handler callback function. This is called when a Phidget is plugged into the system.
+    #
+    # @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
+    #     manager.on_attach do |device_ptr, obj|
+    #       puts "Attaching #{Phidgets::Common.name(device_ptr)}"
+    #     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_attach(obj=nil, &block)
       @on_attach_obj = obj
       @on_attach = Proc.new { |handle, obj_ptr|
-        yield object_for(obj_ptr)
+	    yield handle, object_for(obj_ptr)
       }
       Klass.set_OnAttach_Handler(@handle, @on_attach, pointer_for(obj))
     end
 
+    # Sets a detach handler callback function. This is called when a Phidget is unplugged from the system.
+    #
+    # @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
+    #     manager.on_detach do |device_ptr, obj|
+    #       puts "Detaching #{Phidgets::Common.name(device_ptr)}"
+    #     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_detach(obj=nil, &block)
       @on_detach_obj = obj
       @on_detach = Proc.new { |handle, obj_ptr|
-        yield object_for(obj_ptr)
+        yield handle, object_for(obj_ptr)
       }
       Klass.set_OnDetach_Handler(@handle, @on_detach, pointer_for(obj))
     end
 
+    # Sets a server connect handler callback function. This is used for opening the PhidgetManager remotely, and is called when a connection to the server has been made.
+    #
+    # @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
+    #     manager.on_server_connect do |obj|
+    #        puts 'Connected'
+    #     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_server_connect(obj=nil, &block)
       @on_server_connect_obj = obj
       @on_server_connect = Proc.new { |handle, obj_ptr|
@@ -90,6 +178,16 @@ module Phidgets
       Klass.set_OnServerConnect_Handler(@handle, @on_server_connect, pointer_for(obj))
     end
 
+    # Sets a server disconnect handler callback function. This is used for opening the PhidgetManager remotely, and is called when a connection to the server has been lost
+    #
+    # @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
+    #     manager.on_server_disconnect do |obj|
+    #       puts 'Disconnected'
+    #     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_server_disconnect(obj=nil, &block)
       @on_server_disconnect_obj = obj
       @on_server_disconnect = Proc.new { |handle, obj_ptr|
@@ -98,6 +196,16 @@ module Phidgets
       Klass.set_OnServerDisconnect_Handler(@handle, @on_server_disconnect, pointer_for(obj))
     end
 
+    # Sets a error handler callback function. This is called when an asynchronous error occurs.
+    #
+    # @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
+    #     manager.on_error do |obj|
+    #       puts "Error (#{code}): #{reason}"
+    #     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_error(obj=nil, &block)
       @on_error_obj = obj
       @on_error = Proc.new { |handle, obj_ptr, code, description|
@@ -105,5 +213,14 @@ module Phidgets
       }
       Klass.set_OnError_Handler(@handle, @on_error, pointer_for(obj))
     end
+	
+	private
+	
+	def remove_specific_event_handlers
+		Klass.set_OnAttach_Handler(@handle, nil, nil)
+		Klass.set_OnDetach_Handler(@handle, nil, nil)
+		Klass.set_OnServerConnect_Handler(@handle, nil, nil)
+		Klass.set_OnServerDisconnect_Handler(@handle, nil, nil)
+	end
   end
 end

data/lib/phidgets-ffi/motor_control.rb

@@ -0,0 +1,497 @@
+module Phidgets
+
+  # This class represents a PhidgetMotorControl.
+  class MotorControl
+ 
+    Klass = Phidgets::FFI::CPhidgetMotorControl
+    include Phidgets::Common
+    
+	# Collection of motors
+	# @return [MotorControlMotors] 
+    attr_reader :motors
+
+	# Collection of encoders
+	# @return [MotorControlEncoders] 
+    attr_reader :encoders
+
+	# Collection of digital inputs
+	# @return [MotorControlDigitalInputs] 
+    attr_reader :inputs
+
+	# Collection of analog sensors
+	# @return [MotorControlAnalogSensors] 
+    attr_reader :sensors
+	
+	attr_reader :attributes
+		
+	# The attributes of a PhidgetMotorControl
+    def attributes
+      super.merge({
+		:motors => motors.size,
+		:encoders => encoders.size,
+		:inputs => inputs.size,
+		:sensors => sensors.size,
+		:ratiometric => ratiometric
+      })
+    end
+
+    # Sets a velocity change handler callback function. This is called when the velocity of a motor changes.
+    #
+    # @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
+    #     mc.on_velocity_change do |device, motor, velocity|
+    #       puts "Motor #{motor.index}'s velocity changed to #{velocity}"
+    #     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_velocity_change(obj=nil, &block)
+	
+      @on_velocity_change_obj = obj
+      @on_velocity_change = Proc.new { |device, obj_ptr, motor, velocity|
+	    yield self, @motors[motor], velocity, object_for(obj_ptr)
+
+	}
+      Klass.set_OnVelocityChange_Handler(@handle, @on_velocity_change, pointer_for(obj))
+    end
+
+    # Sets a current change handler callback function. This is called when the current consumed by a motor changes.
+    #
+    # @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
+    #     mc.on_current_change do |device, motor, current|
+    #       puts "Motor #{motor.index}'s current changed to #{current}"
+    #     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_current_change(obj=nil, &block)
+	
+      @on_current_change_obj = obj
+      @on_current_change = Proc.new { |device, obj_ptr, motor, current|
+	    yield self, @motors[motor], current, object_for(obj_ptr)
+
+	}
+      Klass.set_OnCurrentChange_Handler(@handle, @on_current_change, pointer_for(obj))
+    end
+	
+    # Sets a current update handler callback function. This is called when the current consumed by a motor changes.
+    #
+    # @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
+    #     mc.on_current_update do |device, motor, current|
+    #       puts "Motor #{motor.index}'s current is #{current}"
+    #     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_current_update(obj=nil, &block)
+	
+      @on_current_update_obj = obj
+      @on_current_update = Proc.new { |device, obj_ptr, motor, current|
+	    yield self, @motors[motor], current, object_for(obj_ptr)
+
+	}
+      Klass.set_OnCurrentChange_Handler(@handle, @on_current_update, pointer_for(obj))
+    end
+	
+    # Sets an input change handler callback function. This is called when a digital input on the PhidgetMotorControl 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
+    #     mc.on_input_change do |device, input, state, obj|
+    #       puts "Digital Input  #{input.index}, changed to #{state}"
+    #     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_input_change(obj=nil, &block)
+      @on_input_change_obj = obj
+      @on_input_change = Proc.new { |device, obj_ptr, index, state|
+        yield self, @inputs[index], (state == 0 ? false : true), object_for(obj_ptr)
+      }
+      Klass.set_OnInputChange_Handler(@handle, @on_input_change, pointer_for(obj))
+    end
+	
+    # Sets a Back EMF update handler callback function. This is called at a steady rate of 16ms, when BackEMF sensing is enabled.
+    #
+    # @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
+    #     mc.on_back_emf_update do |device, motor, voltage|
+    #       puts "Motor #{motor.index}'s back EMF is #{voltage}"
+    #     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_back_emf_update(obj=nil, &block)
+      @on_back_emf_update_obj = obj
+      @on_back_emf_update = Proc.new { |device, obj_ptr, motor, voltage|
+        yield self, @motors[motor], voltage, object_for(obj_ptr)
+      }
+      Klass.set_OnBackEMFUpdate_Handler(@handle, @on_back_emf_update, pointer_for(obj))
+    end
+	
+    # Sets a position change handler callback function. This event provides data about how many ticks have occured, and how much time has passed since the last position change event, but does not contain an absolute position. This be be obtained from {Phidgets::MotorControl::MotorControlEncoders#position}
+    #
+    # @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
+    #     mc.on_position_change do |device, encoder, time, position|
+    #       puts "Encoder #{encoder.index}'s position changed to #{position} in #{time}"
+    #     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, encoder, time, position|
+	    yield self, @encoders[encoder], time, position, object_for(obj_ptr)
+
+	}
+      Klass.set_OnEncoderPositionChange_Handler(@handle, @on_position_change, pointer_for(obj))
+    end
+
+    # Sets a position update handler callback function. This event provides data about how many ticks have occured since the last update event. It is called at a steady rate of 8ms.
+    #
+    # @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
+    #     mc.on_position_update do |device, encoder, position|
+    #       puts "Encoder #{encoder.index}'s position is #{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_update(obj=nil, &block)
+	
+      @on_position_update_obj = obj
+      @on_position_update = Proc.new { |device, obj_ptr, encoder, position|
+	    yield self, @encoders[encoder], position, object_for(obj_ptr)
+
+	}
+      Klass.set_OnEncoderPositionUpdate_Handler(@handle, @on_position_update, pointer_for(obj))
+    end	
+
+    # Sets a sensor update handler callback function. This is called at a steady rate of 8ms.
+    #
+    # @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
+    #     mc.on_sensor_update do |device, sensor, value|
+    #       puts "Analog Sensor #{sensor.index}'s value is #{value}"
+    #     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_sensor_update(obj=nil, &block)
+      @on_sensor_update_obj = obj
+      @on_sensor_update = Proc.new { |device, obj_ptr, index, value|
+        yield self, @sensors[index], value, object_for(obj_ptr)
+      }
+      Klass.set_OnSensorUpdate_Handler(@handle, @on_sensor_update, pointer_for(obj))
+    end
+	
+	# Returns the ratiometric state of the board
+    #
+    # @return [Boolean] returns the ratiometric state or raises an error
+    def ratiometric
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getRatiometric(@handle, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+    alias_method :ratiometric?, :ratiometric
+
+    # Sets the ratiometric state of the board.
+    # @param [Boolean] new_state new ratiometric state
+    # @return [Boolean] returns the ratiometric state or raises an error
+    def ratiometric=(new_state)
+      tmp = new_state ? 1 : 0
+      Klass.setRatiometric(@handle, tmp)
+      new_state
+    end
+	
+  # This class represents a motor for a PhidgetMotorControl. All the properties of a motor are stored and modified in this class.
+  class MotorControlMotors
+    Klass = Phidgets::FFI::CPhidgetMotorControl
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+
+	public
+	# Displays data for the motor.
+    def inspect
+      "#<#{self.class} @index=#{index}, @acceleration=#{acceleration}, @acceleration_min=#{acceleration_min}, @acceleration_max=#{acceleration_max}, @velocity=#{velocity}>"
+	end
+
+	# @return [Integer] returns the index of the  motor, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Float] returns the acceleration of a motor, or raises an error.
+    def acceleration
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getAcceleration(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# Sets the acceleration of a motor, or raises an error.
+	# @param [Integer] new_acceleration new acceleration
+	# @return [Float] returns acceleration of a motor, or raises an error.    
+	def acceleration=(new_acceleration)
+      Klass.setAcceleration(@handle, @index, new_acceleration.to_f)
+	  new_acceleration
+    end	  
+
+	# @return [Float] returns the largest acceleration value that the motor will accept, or raises an error.
+    def acceleration_max
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getAccelerationMax(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Float] returns the smallest acceleration value that the motor will accept, or raises an error.
+    def acceleration_min
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getAccelerationMin(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Float] returns the current consumption of a motor, in Amps, or raises an error.
+    def current
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getCurrent(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+	
+	# Sets the back EMF sensing state of a motor, or raises an error.
+	# @param [Boolean] new_back_emf_sensing new back EMf sensing state
+	# @return [Boolean] sets the back EMF sensing state of a motor, or raises an error.
+	def back_emf_sensing=(new_back_emf_sensing)
+      tmp = new_back_emf_sensing ? 1 : 0
+      Klass.setBackEMFSensingState(@handle, @index, tmp)
+      new_back_emf_sensing
+    end
+
+	# @return [Boolean] returns the back EMF sensing state of a motor, or raises an error.
+    def back_emf_sensing
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getBackEMFSensingState(@handle, @index, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+	
+	# @return [Float] returns the back EMF value of a motor, in volts, or raises an error.
+    def back_emf
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getBackEMF(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Float] returns the velocity of a motor, or raises an error.
+    def velocity
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getVelocity(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# Sets the velocity of a motor, or raises an error.
+	# @param [Integer] new_velocity new velocity
+	# @return [Float] returns the velocity of a motor, or raises an error.    
+	def velocity=(new_velocity)
+      Klass.setVelocity(@handle, @index, new_velocity.to_f)
+	  new_velocity
+    end	 	
+	
+	# @return [Float] returns the braking value of a motor, or raises an error.
+    def braking
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getBraking(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# Sets the braking value of a motor, or raises an error. The value can be between 0-100%
+	# @param [Integer] new_braking new braking
+	# @return [Float] returns the braking value of a motor, or raises an error.    
+	def braking=(new_braking)
+      Klass.setBraking(@handle, @index, new_braking.to_f)
+	  new_braking
+    end	 	
+	
+  end #MotorControlMotors
+
+ # This class represents an analog sensor for a PhidgetMotorControl. All the properties of an analog sensor are stored and modified in this class.
+  class MotorControlAnalogSensors
+    Klass = Phidgets::FFI::CPhidgetMotorControl
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+
+	public
+	
+	# Displays data for the analog sensor
+    def inspect
+      "#<#{self.class} @value=#{value}, @raw_value=#{raw_value}>"
+    end
+
+	# @return [Integer] returns index of the analog input, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Integer] returns value of the analog input, or raises an error.
+    def value
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getSensorValue(@handle, @index, ptr)
+      ptr.get_int(0)
+    end
+    alias_method :to_i, :value
+
+	# @return [Integer] returns raw value of the analog input, or raises an error.
+    def raw_value
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getSensorRawValue(@handle, @index, ptr)
+      ptr.get_int(0)
+    end
+	
+  end #MotorControlAnalogSensors
+
+ # This class represents a digital input for a PhidgetMotorControl. All the properties of an digital input are stored and modified in this class.
+  class MotorControlDigitalInputs
+    Klass = Phidgets::FFI::CPhidgetMotorControl
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+
+	public
+	
+	# Displays data for the digital input
+    def inspect
+      "#<#{self.class} @index=#{index}, @state=#{state}>"
+    end
+
+	# @return [Integer] returns index of the digital input, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Boolean] returns state of the digital input, or raises an error.
+    def state
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getInputState(@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 #MotorControlDigitalInputs
+
+ # This class represents an encoder for a PhidgetMotorControl. All the properties of an encoder are stored and modified in this class.
+  class MotorControlEncoders
+    Klass = Phidgets::FFI::CPhidgetMotorControl
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+
+	public
+	
+	# Displays data for the encoder
+    def inspect
+      "#<#{self.class} @index=#{index}, @position=#{position}>"
+    end
+
+	# @return [Integer] returns index of the digital input, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Integer] returns the position of an encoder, or raises an error.
+    def position
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getEncoderPosition(@handle, @index, ptr)
+      ptr.get_int(0)
+    end
+	
+	# Sets the position of an encoder, or raises an error.
+	# @param [Integer] new_position new position
+	# @return [Integer] returns the position of an encoder, or raises an error.
+    def position=(new_position)
+      Klass.setEncoderPosition(@handle, @index, new_position.to_i)
+      new_position
+    end	
+	
+  end #MotorControlEncoders
+
+	private
+    
+	def load_device_attributes
+		load_analog_sensors
+		load_inputs
+		load_encoders
+		load_motors
+	end
+
+    def load_analog_sensors
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getSensorCount(@handle, ptr)
+      @sensors = []
+      ptr.get_int(0).times do |i|
+        @sensors << MotorControlAnalogSensors.new(@handle, i)
+      end
+    end
+
+    def load_inputs
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getInputCount(@handle, ptr)
+      @inputs = []
+      ptr.get_int(0).times do |i|
+        @inputs << MotorControlDigitalInputs.new(@handle, i)
+      end
+    end
+
+    def load_encoders
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getEncoderCount(@handle, ptr)
+      @encoders = []
+      ptr.get_int(0).times do |i|
+        @encoders << MotorControlEncoders.new(@handle, i)
+      end
+    end
+
+    def load_motors
+	  ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getMotorCount(@handle, ptr)
+      @motors = []
+      ptr.get_int(0).times do |i|
+        @motors << MotorControlMotors.new(@handle, i)
+      end
+    end
+
+	def remove_specific_event_handlers
+	   Klass.set_OnVelocityChange_Handler(@handle, nil, nil)
+	   Klass.set_OnCurrentChange_Handler(@handle, nil, nil)
+	   Klass.set_OnInputChange_Handler(@handle, nil, nil)
+	   Klass.set_OnEncoderPositionChange_Handler(@handle, nil, nil)
+	   Klass.set_OnEncoderPositionUpdate_Handler(@handle, nil, nil)
+	   Klass.set_OnBackEMFUpdate_Handler(@handle, nil, nil)	 
+	   Klass.set_OnSensorUpdate_Handler(@handle, nil, nil)
+	   Klass.set_OnCurrentUpdate_Handler(@handle, nil, nil)		   
+	end
+  end
+
+end