phidgets 0.1.3 → 1.0.0

data/lib/phidgets/accelerometer.rb

@@ -3,23 +3,19 @@
 module Phidgets
   class Accelerometer < Common
 
-    unless RUBY_VERSION < '1.9.0'
-
-      # call-seq:
-      #   setOnAccelerationChangeHandler(proc=nil, &block)
-      #
-      # Sets an acceleration change event handler. This is called when the acceleration changes by more then the change trigger.
-      #
-      def setOnAccelerationChangeHandler(cb_proc = nil, &cb_block)
-        @on_acceleration_change_thread.kill if defined? @on_acceleration_change_thread
-        callback = cb_proc || cb_block
-        @on_acceleration_change_thread = Thread.new {ext_setOnAccelerationChangeHandler(callback)}
-      end
-
-      alias :on_acceleration_change :setOnAccelerationChangeHandler
-
+    # call-seq:
+    #   setOnAccelerationChangeHandler(proc=nil, &block)
+    #
+    # Sets an acceleration change event handler. This is called when the acceleration changes by more then the change trigger.
+    #
+    def setOnAccelerationChangeHandler(cb_proc = nil, &cb_block)
+      @on_acceleration_change_thread.kill if defined? @on_acceleration_change_thread and @on_acceleration_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_acceleration_change_thread = Thread.new {ext_setOnAccelerationChangeHandler(callback)}
     end
 
+    alias :on_acceleration_change :setOnAccelerationChangeHandler
+
   end
 end
 

data/lib/phidgets/bldc_motor.rb

@@ -0,0 +1,45 @@
+
+
+module Phidgets
+  class BLDCMotor < Common
+
+    # call-seq:
+    #   setOnBrakingStrengthChangeHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the Stopped event occurs.
+    #
+    def setOnBrakingStrengthChangeHandler(cb_proc = nil, &cb_block)
+      @on_braking_strength_change_thread.kill if defined? @on_braking_strength_change_thread and @on_braking_strength_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_braking_strength_change_thread = Thread.new {ext_setOnBrakingStrengthChangeHandler(callback)}
+    end
+
+    # call-seq:
+    #   setOnPositionChangeHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the PositionChange event occurs.
+    #
+    def setOnPositionChangeHandler(cb_proc = nil, &cb_block)
+      @on_position_change_thread.kill if defined? @on_position_change_thread and @on_position_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_position_change_thread = Thread.new {ext_setOnPositionChangeHandler(callback)}
+    end
+
+    # call-seq:
+    #   setOnVelocityUpdateHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the VelocityChange event occurs.
+    #
+    def setOnVelocityUpdateHandler(cb_proc = nil, &cb_block)
+      @on_velocity_update_thread.kill if defined? @on_velocity_update_thread and @on_velocity_update_thread.alive?
+      callback = cb_proc || cb_block
+      @on_velocity_update_thread = Thread.new {ext_setOnVelocityUpdateHandler(callback)}
+    end
+
+    alias :on_braking_strength_change :setOnBrakingStrengthChangeHandler
+    alias :on_position_change :setOnPositionChangeHandler
+    alias :on_velocity_update :setOnVelocityUpdateHandler
+
+  end
+end
+

data/lib/phidgets/capacitive_touch.rb

@@ -0,0 +1,33 @@
+
+
+module Phidgets
+  class CapacitiveTouch < Common
+
+    # call-seq:
+    #   setOnTouchEndHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the TouchEnd event occurs.
+    #
+    def setOnTouchEndHandler(cb_proc = nil, &cb_block)
+      @on_touch_end_thread.kill if defined? @on_touch_end_thread and @on_touch_end_thread.alive?
+      callback = cb_proc || cb_block
+      @on_touch_end_thread = Thread.new {ext_setOnTouchEndHandler(callback)}
+    end
+
+    # call-seq:
+    #   setOnTouchHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the PositionChange event occurs.
+    #
+    def setOnTouchHandler(cb_proc = nil, &cb_block)
+      @on_touch_thread.kill if defined? @on_touch_thread and @on_touch_thread.alive?
+      callback = cb_proc || cb_block
+      @on_touch_thread = Thread.new {ext_setOnTouchHandler(callback)}
+    end
+
+    alias :on_touch_end :setOnTouchEndHandler
+    alias :on_touch :setOnTouchHandler
+
+  end
+end
+

data/lib/phidgets/common.rb

@@ -3,83 +3,54 @@ module Phidgets
   class Common
 
     # call-seq:
-    #   open(args)
+    #   setOnAttachHandler(proc=nil, &block)
     #
-    # Opens a Phidget. Will attempt to make the correct open call (openLabel, openRemote, openRemoteIP, etc)
-    # based on the arguments passed in. Args can either be a serial number or a hash of arguments. If it is a
-    # hash, the following keys may be used: :serial_number, :label, :server_id, :address, :port, :password.
+    # Assigns a handler that will be called when the Attach event occurs.
     #
-    def open(args)
-      args = {:serial_number => args.to_i} unless args.is_a? Hash
-      if args.key? :server_id
-        return open_remote(args[:serial_number], args[:server_id], args[:password]) if args.key? :serial_number
-        return open_label_remote(args[:label], args[:server_id], args[:password]) if args.key? :label
-      elsif args.key? :address
-        return open_remote_ip(args[:serial_number], args[:address], args[:port], args[:password]) if args.key? :serial_number
-        return open_label_remote_ip(args[:label], args[:address], args[:port], args[:password]) if args.key? :label
-      else
-        return ext_open(args[:serial_number]) if args.key? :serial_number
-        return open_label(args[:label]) if args.key? :label
-      end
-      raise Phidgets::Error::InvalidArg.new
+    def setOnAttachHandler(cb_proc = nil, &cb_block)
+      @on_attach_thread.kill if defined? @on_attach_thread
+      callback = cb_proc || cb_block
+      @on_attach_thread = Thread.new {ext_setOnAttachHandler(callback)}
     end
 
+    # call-seq:
+    #   setOnDetachHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the Detach event occurs.
+    #
+    def setOnDetachHandler(cb_proc = nil, &cb_block)
+      @on_detach_thread.kill if defined? @on_detach_thread
+      callback = cb_proc || cb_block
+      @on_detach_thread = Thread.new {ext_setOnDetachHandler(callback)}
+    end
 
-    unless RUBY_VERSION < '1.9.0'
-
-      # call-seq:
-      #   setOnAttachHandler(proc=nil, &block)
-      #
-      # Sets an attach handler callback function. This is called when this Phidget is plugged into the system, and is ready for use.
-      #
-      def setOnAttachHandler(cb_proc = nil, &cb_block)
-        @on_attach_thread.kill if defined? @on_attach_thread
-        callback = cb_proc || cb_block
-        @on_attach_thread = Thread.new {ext_setOnAttachHandler(callback)}
-      end
-
-      # call-seq:
-      #   setOnDetachHandler(proc=nil, &block)
-      #
-      # Sets a detach handler callback function. This is called when this Phidget is unplugged from the system.
-      #
-      def setOnDetachHandler(cb_proc = nil, &cb_block)
-        @on_detach_thread.kill if defined? @on_detach_thread
-        callback = cb_proc || cb_block
-        @on_detach_thread = Thread.new {ext_setOnDetachHandler(callback)}
-      end
-
-      # call-seq:
-      #   setOnServerConnectHandler(proc=nil, &block)
-      #
-      # Sets a server connect handler callback function. This is used for opening Phidgets remotely,
-      # and is called when a connection to the sever has been made.
-      #
-      def setOnServerConnectHandler(cb_proc = nil, &cb_block)
-        @on_server_connect_thread.kill if defined? @on_server_connect_thread
-        callback = cb_proc || cb_block
-        @on_server_connect_thread = Thread.new {ext_setOnServerConnectHandler(callback)}
-      end
-
-      # call-seq:
-      #   setOnServerDisconnectHandler(proc=nil, &block)
-      #
-      # Sets a server disconnect handler callback function. This is used for opening Phidgets remotely,
-      # and is called when a connection to the server has been lost.
-      #
-      def setOnServerDisconnectHandler(cb_proc = nil, &cb_block)
-        @on_server_disconnect_thread.kill if defined? @on_server_disconnect_thread
-        callback = cb_proc || cb_block
-        @on_server_disconnect_thread = Thread.new {ext_setOnServerDisconnectHandler(callback)}
-      end
-
-      alias :on_attach :setOnAttachHandler
-      alias :on_detach :setOnDetachHandler
-      alias :on_server_connect :setOnServerConnectHandler
-      alias :on_server_disconnect :setOnServerDisconnectHandler
+    # call-seq:
+    #   setOnErrorHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the Error event occurs.
+    #
+    def setOnErrorHandler(cb_proc = nil, &cb_block)
+      @on_error_thread.kill if defined? @on_error_thread
+      callback = cb_proc || cb_block
+      @on_error_thread = Thread.new {ext_setOnErrorHandler(callback)}
+    end
 
+    # call-seq:
+    #   setOnPropertyChangeHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the PropertyChange event occurs.
+    #
+    def setOnPropertyChangeHandler(cb_proc = nil, &cb_block)
+      @on_property_change_thread.kill if defined? @on_property_change_thread
+      callback = cb_proc || cb_block
+      @on_property_change_thread = Thread.new {ext_setOnPropertyChangeHandler(callback)}
     end
 
+    alias :on_attach :setOnAttachHandler
+    alias :on_detach :setOnDetachHandler
+    alias :on_error :setOnErrorHandler
+    alias :on_property_change :setOnPropertyChangeHandler
+
   end
 end
 

data/lib/phidgets/current_input.rb

@@ -0,0 +1,21 @@
+
+
+module Phidgets
+  class CurrentInput < Common
+
+    # call-seq:
+    #   setOnCurrentChangeHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the CurrentChange event occurs.
+    #
+    def setOnCurrentChangeHandler(cb_proc = nil, &cb_block)
+      @on_current_change_thread.kill if defined? @on_current_change_thread and @on_current_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_current_change_thread = Thread.new {ext_setOnCurrentChangeHandler(callback)}
+    end
+
+    alias :on_current_change :setOnCurrentChangeHandler
+
+  end
+end
+

data/lib/phidgets/dc_motor.rb

@@ -0,0 +1,45 @@
+
+
+module Phidgets
+  class DCMotor < Common
+
+    # call-seq:
+    #   setOnBackEMFChangeHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the BackEMFChange event occurs.
+    #
+    def setOnBackEMFChangeHandler(cb_proc = nil, &cb_block)
+      @on_back_emf_change_thread.kill if defined? @on_back_emf_change_thread and @on_back_emf_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_back_emf_change_thread = Thread.new {ext_setOnBackEMFChangeHandler(callback)}
+    end
+
+    # call-seq:
+    #   setOnBrakingStrengthChangeHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the Stopped event occurs.
+    #
+    def setOnBrakingStrengthChangeHandler(cb_proc = nil, &cb_block)
+      @on_braking_strength_change_thread.kill if defined? @on_braking_strength_change_thread and @on_braking_strength_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_braking_strength_change_thread = Thread.new {ext_setOnBrakingStrengthChangeHandler(callback)}
+    end
+
+    # call-seq:
+    #   setOnVelocityUpdateHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the VelocityChange event occurs.
+    #
+    def setOnVelocityUpdateHandler(cb_proc = nil, &cb_block)
+      @on_velocity_update_thread.kill if defined? @on_velocity_update_thread and @on_velocity_update_thread.alive?
+      callback = cb_proc || cb_block
+      @on_velocity_update_thread = Thread.new {ext_setOnVelocityUpdateHandler(callback)}
+    end
+
+    alias :on_back_emf_change :setOnBackEMFChangeHandler
+    alias :on_braking_strength_change :setOnBrakingStrengthChangeHandler
+    alias :on_velocity_update :setOnVelocityUpdateHandler
+
+  end
+end
+

data/lib/phidgets/dictionary.rb

@@ -1,53 +1,44 @@
 
 module Phidgets
-  class Dictionary
+  class Dictionary < Common
 
     # call-seq:
-    #   open(args)
+    #   setOnAddHandler(proc=nil, &block)
     #
-    # Opens a Dictionary. Will attempt to make the correct open call (openRemote, openRemoteIP) based
-    # on the arguments passed in. Args is a hash and the following keys may be used:
-    # :server_id, :address, :port, :password.
+    # Assigns a handler that will be called when the Add event occurs.
     #
-    def open(args)
-      if args.key? :server_id
-        return open_remote(args[:server_id], args[:password])
-      elsif args.key? :address
-        return open_remote_ip(args[:address], args[:port], args[:password])
-      end
-      raise Phidgets::Error::InvalidArg.new
+    def setOnAddHandler(cb_proc = nil, &cb_block)
+      @on_add_thread.kill if defined? @on_add_thread and @on_add_thread.alive?
+      callback = cb_proc || cb_block
+      @on_add_thread = Thread.new {ext_setOnAddHandler(callback)}
     end
 
+    # call-seq:
+    #   setOnRemoveHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the Remove event occurs.
+    #
+    def setOnRemoveHandler(cb_proc = nil, &cb_block)
+      @on_remove_thread.kill if defined? @on_remove_thread and @on_remove_thread.alive?
+      callback = cb_proc || cb_block
+      @on_remove_thread = Thread.new {ext_setOnRemoveHandler(callback)}
+    end
 
-    unless RUBY_VERSION < '1.9.0'
-
-      # call-seq:
-      #   setOnServerConnectHandler(proc=nil, &block)
-      #
-      # Sets a server connect handler callback function. This is called when a connection to the sever has been made.
-      #
-      def setOnServerConnectHandler(cb_proc = nil, &cb_block)
-        @on_server_connect_thread.kill if defined? @on_server_connect_thread
-        callback = cb_proc || cb_block
-        @on_server_connect_thread = Thread.new {ext_setOnServerConnectHandler(callback)}
-      end
-
-      # call-seq:
-      #   setOnServerDisconnectHandler(proc=nil, &block)
-      #
-      # Sets a server disconnect handler callback function. This is called when a connection to the server has been lost.
-      #
-      def setOnServerDisconnectHandler(cb_proc = nil, &cb_block)
-        @on_server_disconnect_thread.kill if defined? @on_server_disconnect_thread
-        callback = cb_proc || cb_block
-        @on_server_disconnect_thread = Thread.new {ext_setOnServerDisconnectHandler(callback)}
-      end
-
-      alias :on_server_connect :setOnServerConnectHandler
-      alias :on_server_disconnect :setOnServerDisconnectHandler
-
+    # call-seq:
+    #   setOnUpdateHandler(proc=nil, &block)
+    #
+    # Assigns a handler that will be called when the Update event occurs.
+    #
+    def setOnUpdateHandler(cb_proc = nil, &cb_block)
+      @on_update_thread.kill if defined? @on_update_thread and @on_update_thread.alive?
+      callback = cb_proc || cb_block
+      @on_update_thread = Thread.new {ext_setOnUpdateHandler(callback)}
     end
 
+    alias :on_add :setOnAddHandler
+    alias :on_remove :setOnRemoveHandler
+    alias :on_update :setOnUpdateHandler
+
   end
 end
 

data/lib/phidgets/digital_input.rb

@@ -0,0 +1,21 @@
+
+
+module Phidgets
+  class DigitalInput < Common
+
+    # call-seq:
+    #   setOnStateChangeHandler(proc=nil, &block)
+    #
+    # Set a digital input change handler. This is called when a digital input changes.
+    #
+    def setOnStateChangeHandler(cb_proc = nil, &cb_block)
+      @on_state_change_thread.kill if defined? @on_state_change_thread and @on_state_change_thread.alive?
+      callback = cb_proc || cb_block
+      @on_state_change_thread = Thread.new {ext_setOnStateChangeHandler(callback)}
+    end
+
+    alias :on_state_change :setOnStateChangeHandler
+
+  end
+end
+

data/lib/phidgets/digital_output.rb

@@ -0,0 +1,56 @@
+
+
+module Phidgets
+  class DigitalOutput < Common
+
+    # call-seq:
+    #   setDutyCycle_async(duty_cycle, proc=nil, &block)
+    #
+    # The DutyCycle represents the fraction of time the output is on (high).
+    # This will override the State setting on the channel.
+    # A DutyCycle of 1.0 translates to a high output, a DutyCycle of 0 translates to a low output.
+    # This is equivalent to setting a State of TRUE and FALSE respectively.
+    # A DutyCycle of 0.5 translates to an output that is high half the time, which results in an average output voltage of (output voltage x 0.5)
+    # You can use the DutyCycle to create a dimming effect on LEDs.
+    # If the DigitalOutput channel you are using does not support PWM, then this value may only be set to 1.0 or 0.0.
+    #
+    def setDutyCycle_async(duty_cycle, cb_proc = nil, &cb_block)
+      @duty_cycle_async_thread.kill if defined? @duty_cycle_async_thread and @duty_cycle_async_thread.alive?
+      callback = cb_proc || cb_block
+      @duty_cycle_async_thread = Thread.new {ext_setDutyCycle_async(duty_cycle, callback)}
+    end
+
+    alias :set_duty_cycle_async :setDutyCycle_async
+
+    # call-seq:
+    #   setLEDCurrentLimit_async(duty_cycle, proc=nil, &block)
+    #
+    # The LEDCurrentLimit is the maximum amount of current that the controller will provide to the output.
+    # Reference the data sheet of the LED you are using before setting this value.
+    #
+    def setLEDCurrentLimit_async(current_limit, cb_proc = nil, &cb_block)
+      @led_current_limit_async_thread.kill if defined? @led_current_limit_async_thread and @led_current_limit_async_thread.alive?
+      callback = cb_proc || cb_block
+      @led_current_limit_async_thread = Thread.new {ext_setLEDCurrentLimit_async(current_limit, callback)}
+    end
+
+    alias :set_led_current_limit_async :setLEDCurrentLimit_async
+
+    # call-seq:
+    #   setState_async(state, proc=nil, &block)
+    #
+    # The State will dictate whether the output is constantly high (TRUE) or low (FALSE).
+    # This will override any DutyCycle that may have been set on the channel.
+    # Setting the State to TRUE is the same as setting DutyCycle to 1.0, and setting the State to FALSE is the same as setting a DutyCycle of 0.0.
+    #
+    def setState_async(state, cb_proc = nil, &cb_block)
+      @state_async_thread.kill if defined? @state_async_thread and @state_async_thread.alive?
+      callback = cb_proc || cb_block
+      @state_async_thread = Thread.new {ext_setState_async(state, callback)}
+    end
+
+    alias :set_state_async :setState_async
+
+  end
+end
+