phidgets-ffi 0.0.5 → 0.1.0

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

@@ -0,0 +1,56 @@
+module Phidgets
+  module FFI
+    
+	attach_function :CPhidgetStepper_create, [:phid], :int 
+	attach_function :CPhidgetStepper_getInputCount, [:phid, :pointer], :int
+    attach_function :CPhidgetStepper_getInputState, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_getMotorCount, [:phid, :pointer], :int
+    attach_function :CPhidgetStepper_getAcceleration, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_setAcceleration, [:phid, :int, :double], :int 
+	attach_function :CPhidgetStepper_getAccelerationMax, [:phid, :int, :pointer], :int 
+	attach_function :CPhidgetStepper_getAccelerationMin, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_getVelocityLimit, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_setVelocityLimit, [:phid, :int, :double], :int 	
+	attach_function :CPhidgetStepper_getVelocity, [:phid, :int, :pointer], :int 
+	attach_function :CPhidgetStepper_getVelocityMax, [:phid, :int, :pointer], :int 
+	attach_function :CPhidgetStepper_getVelocityMin, [:phid, :int, :pointer], :int 
+	attach_function :CPhidgetStepper_getTargetPosition, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_setTargetPosition, [:phid, :int, :long_long], :int
+	attach_function :CPhidgetStepper_getCurrentPosition, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_setCurrentPosition, [:phid, :int, :long_long], :int	
+    attach_function :CPhidgetStepper_getPositionMax, [:phid, :int, :long_long], :int	
+    attach_function :CPhidgetStepper_getPositionMin, [:phid, :int, :long_long], :int		
+	attach_function :CPhidgetStepper_getCurrentLimit, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_setCurrentLimit, [:phid, :int, :double], :int 	
+    attach_function :CPhidgetStepper_getCurrent, [:phid, :int, :pointer], :int 	
+	attach_function :CPhidgetStepper_getCurrentMax, [:phid, :int, :pointer], :int 	
+	attach_function :CPhidgetStepper_getCurrentMin, [:phid, :int, :pointer], :int 	
+	attach_function :CPhidgetStepper_getEngaged, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetStepper_setEngaged, [:phid, :int, :int], :int 	
+	attach_function :CPhidgetStepper_getStopped, [:phid, :int, :pointer], :int 
+
+    callback :CPhidgetStepper_set_OnInputChange_Callback, [:phid, :user_ptr, :int, :int], :int
+    attach_function :CPhidgetStepper_set_OnInputChange_Handler, [:phid, :CPhidgetStepper_set_OnInputChange_Callback, :user_ptr], :int
+
+    callback :CPhidgetStepper_set_OnVelocityChange_Callback, [:phid, :user_ptr, :int, :double], :int
+    attach_function :CPhidgetStepper_set_OnVelocityChange_Handler, [:phid, :CPhidgetStepper_set_OnVelocityChange_Callback, :user_ptr], :int
+
+    callback :CPhidgetStepper_set_OnPositionChange_Callback, [:phid, :user_ptr, :int, :long_long], :int
+    attach_function :CPhidgetStepper_set_OnPositionChange_Handler, [:phid, :CPhidgetStepper_set_OnPositionChange_Callback, :user_ptr], :int
+
+    callback :CPhidgetStepper_set_OnCurrentChange_Callback, [:phid, :user_ptr, :int, :double], :int
+    attach_function :CPhidgetStepper_set_OnCurrentChange_Handler, [:phid, :CPhidgetStepper_set_OnCurrentChange_Callback, :user_ptr], :int
+	
+    module CPhidgetStepper
+      def self.method_missing(method, *args, &block)
+        if ::Phidgets::FFI.respond_to?("CPhidgetStepper_#{method}".to_sym)
+          if (rs = ::Phidgets::FFI.send("CPhidgetStepper_#{method}".to_sym, *args, &block)) != 0
+            raise Phidgets::Error.exception_for(rs), Phidgets::FFI.error_description(rs)
+          end
+        else
+          super(method, *args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Phidgets
+  module FFI
+
+   TemperatureSensorThermocoupleTypes = enum(
+      :thermocouple_type_k_type, 1,
+      :thermocouple_type_j_type,
+      :thermocouple_type_e_type,
+	  :thermocouple_type_t_type
+    )
+
+	attach_function :CPhidgetTemperatureSensor_create, [:phid], :int
+    attach_function :CPhidgetTemperatureSensor_getTemperatureInputCount, [:phid, :pointer], :int 
+    attach_function :CPhidgetTemperatureSensor_getTemperature, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetTemperatureSensor_getTemperatureMax, [:phid, :int, :pointer], :int 	
+	attach_function :CPhidgetTemperatureSensor_getTemperatureMin, [:phid, :int, :pointer], :int 	
+    attach_function :CPhidgetTemperatureSensor_getTemperatureChangeTrigger, [:phid, :int, :pointer], :int 
+	attach_function :CPhidgetTemperatureSensor_setTemperatureChangeTrigger, [:phid, :int, :double], :int 
+	attach_function :CPhidgetTemperatureSensor_getPotential, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetTemperatureSensor_getPotentialMax, [:phid, :int, :pointer], :int 
+    attach_function :CPhidgetTemperatureSensor_getPotentialMin, [:phid, :int, :pointer], :int 
+	attach_function :CPhidgetTemperatureSensor_getAmbientTemperature, [:phid, :pointer], :int 
+	attach_function :CPhidgetTemperatureSensor_getAmbientTemperatureMax, [:phid, :pointer], :int 
+	attach_function :CPhidgetTemperatureSensor_getAmbientTemperatureMin, [:phid, :pointer], :int 
+	attach_function :CPhidgetTemperatureSensor_getThermocoupleType, [:phid, :int, :pointer], :int     
+	attach_function :CPhidgetTemperatureSensor_setThermocoupleType, [:phid, :int, TemperatureSensorThermocoupleTypes], :int 
+ 
+	callback :CPhidgetTemperatureSensor_set_OnTemperatureChange_Callback, [:phid, :user_ptr, :int, :double], :int
+    attach_function :CPhidgetTemperatureSensor_set_OnTemperatureChange_Handler, [:phid, :CPhidgetTemperatureSensor_set_OnTemperatureChange_Callback, :user_ptr], :int 
+	
+module CPhidgetTemperatureSensor
+      def self.method_missing(method, *args, &block)
+        if ::Phidgets::FFI.respond_to?("CPhidgetTemperatureSensor_#{method}".to_sym)
+          if (rs = ::Phidgets::FFI.send("CPhidgetTemperatureSensor_#{method}".to_sym, *args, &block)) != 0
+            raise Phidgets::Error.exception_for(rs), Phidgets::FFI.error_description(rs)
+          end
+        else
+          super(method, *args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Phidgets
+  module FFI
+
+   TextLCDScreenSizes = enum(
+      :screen_size_none, 1,
+	  :screen_size_1x8,
+      :screen_size_2x8,
+      :screen_size_1x16,
+	  :screen_size_2x16,
+	  :screen_size_4x16,
+	  :screen_size_2x20,
+	  :screen_size_4x20,
+	  :screen_size_2x24,
+	  :screen_size_1x40,
+	  :screen_size_2x40,
+	  :screen_size_4x40,
+	  :screen_size_unknown
+    )
+
+	attach_function :CPhidgetTextLCD_create, [:phid], :int
+    attach_function :CPhidgetTextLCD_getRowCount, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_getColumnCount, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_getBacklight, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setBacklight, [:phid, :int], :int 
+	attach_function :CPhidgetTextLCD_getBrightness, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setBrightness, [:phid, :int], :int 
+	attach_function :CPhidgetTextLCD_getContrast, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setContrast, [:phid, :int], :int 
+	attach_function :CPhidgetTextLCD_getCursorOn, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setCursorOn, [:phid, :int], :int 
+	attach_function :CPhidgetTextLCD_getCursorBlink, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setCursorBlink, [:phid, :int], :int 
+	attach_function :CPhidgetTextLCD_setCustomCharacter, [:phid, :int, :int, :int], :int 
+	attach_function :CPhidgetTextLCD_setDisplayCharacter, [:phid, :int, :int, :uchar], :int 	
+	attach_function :CPhidgetTextLCD_setDisplayString, [:phid, :int, :pointer], :int
+    attach_function :CPhidgetTextLCD_getScreenCount, [:phid, :pointer], :int 
+	attach_function :CPhidgetTextLCD_getScreen, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setScreen, [:phid, :int], :int 
+    attach_function :CPhidgetTextLCD_getScreenSize, [:phid, :pointer], :int 
+    attach_function :CPhidgetTextLCD_setScreenSize, [:phid, TextLCDScreenSizes], :int 
+	attach_function :CPhidgetTextLCD_initialize, [:phid], :int 
+		
+module CPhidgetTextLCD
+      def self.method_missing(method, *args, &block)
+        if ::Phidgets::FFI.respond_to?("CPhidgetTextLCD_#{method}".to_sym)
+          if (rs = ::Phidgets::FFI.send("CPhidgetTextLCD_#{method}".to_sym, *args, &block)) != 0
+            raise Phidgets::Error.exception_for(rs), Phidgets::FFI.error_description(rs)
+          end
+        else
+          super(method, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/phidgets-ffi/frequency_counter.rb

@@ -0,0 +1,148 @@
+module Phidgets
+
+  # This class represents a PhidgetFrequencyCounter.
+  class FrequencyCounter
+ 
+    Klass = Phidgets::FFI::CPhidgetFrequencyCounter
+    include Phidgets::Common
+    
+	# Collection of frequency counter inputs
+	# @return [FrequencyCounterInputs] 
+    attr_reader :inputs
+	
+	attr_reader :attributes
+    
+	# The attributes of a PhidgetFrequencyCounter
+	def attributes
+      super.merge({
+        :inputs => inputs.size,
+      })
+    end
+
+    # Sets an count handler callback function. This is called when ticks are counted on an frequency counter input, or when the timeout expires
+    #
+    # @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
+    #     fc.on_count do |device, input, time, count, obj|
+    #       puts "Channel  #{input.index}:  #{count} pulses in #{time} microseconds"
+    #     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_count(obj=nil, &block)
+      @on_count_obj = obj
+      @on_count = Proc.new { |device, obj_ptr, index, time, counts|
+	    yield self, @inputs[index], time, counts, object_for(obj_ptr)
+	}
+      Klass.set_OnCount_Handler(@handle, @on_count, pointer_for(obj))
+    end
+
+ 
+  # This class represents a frequency counter input for a PhidgetFrequencyCounter. All the properties of a frequency counter input are stored and modified in this class.
+  class FrequencyCounterInputs
+    Klass = Phidgets::FFI::CPhidgetFrequencyCounter
+
+	private
+    def initialize(handle, index)
+      @handle, @index = handle, index.to_i
+    end
+	
+	public
+	
+	# @return [Integer] returns index of the frequency counter input, or raises an error.
+	def index 
+		@index
+	end
+	
+	# @return [Boolean] returns the enabled state of a frequency counter input, or raises an error.
+    def enabled
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getEnabled(@handle, @index, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+
+	# Sets the enabled state of a frequency counter input, or raises an error.
+	# @param [Boolean] new_state new state
+	# @return [Boolean] returns enabled state of a frequency counter input, or raises an error.
+    def enabled=(new_state)
+      tmp = new_state ? 1 : 0
+      Klass.setEnabled(@handle, @index, tmp)
+      new_state
+    end
+	
+	# @return [Phidgets::FFI::FrequencyCounterFilterTypes] returns the filter type of the frequency counter input, or raises an error.
+	def filter_type
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getFilter(@handle, @index, ptr)
+      Phidgets::FFI::FrequencyCounterFilterTypes[ptr.get_int(0)]
+    end
+
+	# Sets the filter type of the frequency counter input, or raises an error. 
+	# @param [Phidgets::FFI::FrequencyCounterFilterTypes] new_filter new filter
+	# @return [Phidgets::FFI::FrequencyCounterFilterTypes] returns the filter type of the frequency counter input, or raises an error.
+    def filter_type=(new_filter)
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.setFilter(@handle, @index, Phidgets::FFI::FrequencyCounterFilterTypes[new_filter])
+      new_filter
+    end
+	
+	# @return [Integer] returns the measured frequency of the frequency counter input, in Hz, or raises an error.
+    def frequency
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getFrequency(@handle, @index, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Integer] returns the timeout for the frequency counter input, in microseconds, or raises an error.
+    def timeout
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getTimeout(@handle, @index, ptr)
+      ptr.get_int(0)
+    end
+
+	# Sets the timeout for the frequency counter input, in microseconds, or raises an error.
+	# @param [Integer] new_timeout new timeout
+	# @return [Integer] returns timeout of the frequency counter input, or raises an error.
+    def timeout=(new_timeout)
+      Klass.setTimeout(@handle, @index, new_timeout.to_i)
+      new_timeout.to_i
+    end
+
+	# @return [Integer] returns the number of ticks counted since last reset, or raises an error.
+    def total_count
+      ptr = ::FFI::MemoryPointer.new(:long)
+      Klass.getTotalCount(@handle, @index, ptr)
+      ptr.get_long(0)
+    end
+
+	# @return [Integer] returns the total time since last reset, in microseconds, or raises an error.
+    def total_time
+      ptr = ::FFI::MemoryPointer.new(:long_long)
+      Klass.getTotalTime(@handle, @index, ptr)
+      ptr.get_long_long(0)
+    end
+	
+  end #FrequencyCounterInputs
+    
+	private
+    
+	def load_device_attributes
+		load_inputs
+	end
+	
+    def load_inputs
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getFrequencyInputCount(@handle, ptr)
+
+      @inputs = []
+      ptr.get_int(0).times do |i|
+        @inputs << FrequencyCounterInputs.new(@handle, i)
+      end
+    end
+	
+	def remove_specific_event_handlers
+	   Klass.set_OnCount_Handler(@handle, nil, nil)
+	end
+  end
+   
+end

data/lib/phidgets-ffi/gps.rb

@@ -0,0 +1,181 @@
+module Phidgets
+
+  # This class represents a PhidgetGPS.
+  class GPS
+ 
+    Klass = Phidgets::FFI::CPhidgetGPS
+    include Phidgets::Common
+    
+	# This represents the GPS date structure, in UTC
+	#
+	# Examples:
+	#
+	#  puts gps.date[:year]
+	#  puts gps.date[:month]
+	#  puts gps.date[:date]
+	class GPS_date < ::FFI::Struct
+
+		# Day
+		# @return [Integer] returns the day
+		attr_reader :day
+
+		# Month
+		# @return [Integer] returns the month
+		attr_reader :month
+
+		# Milliseconds
+		# @return [Integer] returns the milliseconds
+		attr_reader :year
+		
+		layout :day, :short,
+		   :month, :short,
+		   :year, :short 
+	end
+	
+
+	# This represents the GPS time structure, in UTC
+	#
+	# Examples:
+	#
+	#  puts gps.time[:hours]
+	#  puts gps.time[:minutes]
+	#  puts gps.time[:seconds]
+	#  puts gps.time[:milliseconds]
+	class GPS_time < ::FFI::Struct
+		
+		# Milliseconds
+		# @return [Integer] returns the milliseconds
+		attr_reader :milliseconds
+		
+		# Seconds
+		# @return [Integer] returns the seconds
+		attr_reader :seconds
+		
+		# Minutes
+		# @return [Integer] returns the minutes
+		attr_reader :minutes
+		
+		# Hours
+		# @return [Integer] returns the hours
+		attr_reader :hours
+		
+		layout :milliseconds, :short,
+		   :seconds, :short,
+		   :minutes, :short, 
+		   :hours, :short
+	end
+	
+	attr_reader :attributes
+		
+	# The attributes of a PhidgetGPS
+    def attributes
+      super.merge({
+
+      })
+    end
+
+    # Sets an position fix status change handler callback function. This is called when the position fix status 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
+    #     gps.on_position_fix_status_change do |device, fix_status, obj|
+    #       puts "Position fix status changed to: #{fix_status}"
+    #     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_fix_status_change(obj=nil, &block)
+	  @on_position_fix_status_change_obj = obj
+      @on_position_fix_status_change = Proc.new { |device, obj_ptr, fix_status|
+          yield self, (fix_status == 0 ? false : true), object_for(obj_ptr)
+      }
+      Klass.set_OnPositionFixStatusChange_Handler(@handle, @on_position_fix_status_change, pointer_for(obj))
+    end
+
+    # Sets position change handler callback function. This is called when the latitude, longitude, or altitude 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
+    #     gps.on_position_change do |device, lat, long, alt, obj|
+    #       puts "Latitude: #{lat} degrees, longitude: #{long} degrees, altitude: #{alt} m"
+    #     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, lat, long, alt|
+        yield self, lat, long, alt, object_for(obj_ptr)
+      }
+      Klass.set_OnPositionChange_Handler(@handle, @on_position_change, pointer_for(obj))
+    end
+
+	# @return [Float] returns the latitude in degrees, or raises an error.
+    def latitude
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getLatitude(@handle, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Float] returns the longitude in degrees or raises an error.
+    def longitude
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getLongitude(@handle, ptr)
+      ptr.get_double(0)
+    end
+	
+	# @return [Float] returns the altitude in meters, or raises an error.
+    def altitude
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getAltitude(@handle, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Float] returns the heading in degrees or raises an error.
+    def heading
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getHeading(@handle, ptr)
+      ptr.get_double(0)
+    end
+
+	# @return [Float] returns the velocity in km/h, in or raises an error.
+    def velocity
+      ptr = ::FFI::MemoryPointer.new(:double)
+      Klass.getVelocity(@handle, ptr)
+      ptr.get_double(0)
+    end	
+	
+	# @return [GPS_date] returns the date in UTC, in or raises an error.
+	def date
+		ptr = ::FFI::MemoryPointer.new 6 #2 bytes for each short
+		Klass.getDate(@handle, ptr)
+		obj = GPS_date.new(ptr)
+	end
+	
+	# @return [GPS_time] returns the time in UTC, in or raises an error.
+	def time
+		ptr = ::FFI::MemoryPointer.new 8 #2 bytes for each short
+		Klass.getTime(@handle, ptr)
+		obj = GPS_time.new(ptr)
+	end
+		
+	# @return [Boolean] returns state of the digital input, or raises an error.
+    def position_fix_status
+      ptr = ::FFI::MemoryPointer.new(:int)
+      Klass.getPositionFixStatus(@handle, ptr)
+      (ptr.get_int(0) == 0) ? false : true
+    end
+	
+	private
+    
+	def load_device_attributes
+
+	end
+
+	def remove_specific_event_handlers
+	   Klass.set_OnPositionChange_Handler(@handle, nil, nil)
+	   Klass.set_OnPositionFixStatusChange_Handler(@handle, nil, nil)
+	end
+  end
+
+end