phidgets 0.0.5 → 0.1.0

data/lib/phidgets/encoder.rb

@@ -0,0 +1,49 @@
+
+
+module Phidgets
+  class Encoder < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnInputChangeHandler(proc=nil, &block)
+      #
+      # Sets an input change handler. This is called when a digital input changes.
+      #
+      def setOnInputChangeHandler(cb_proc = nil, &cb_block)
+        @on_input_change_thread.kill if defined? @on_input_change_thread
+        callback = cb_proc || cb_block
+        @on_input_change_thread = Thread.new {ext_setOnInputChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnPositionChangeHandler(proc=nil, &block)
+      #
+      # Sets an encoder position change handler. This is called when an encoder position changes.
+      #
+      def setOnPositionChangeHandler(cb_proc = nil, &cb_block)
+        @on_position_change_thread.kill if defined? @on_position_change_thread
+        callback = cb_proc || cb_block
+        @on_position_change_thread = Thread.new {ext_setOnPositionChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnIndexHandler(proc=nil, &block)
+      #
+      # Sets an encoder index handler. This is called when there is a pulse on the index pin.
+      #
+      def setOnIndexHandler(cb_proc = nil, &cb_block)
+        @on_index_thread.kill if defined? @on_index_thread
+        callback = cb_proc || cb_block
+        @on_index_thread = Thread.new {ext_setOnIndexHandler(callback)}
+      end
+
+      alias :on_input_change :setOnInputChangeHandler
+      alias :on_position_change :setOnPositionChangeHandler
+      alias :on_index :setOnIndexHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/frequency_counter.rb

@@ -0,0 +1,25 @@
+
+
+module Phidgets
+  class FrequencyCounter < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnCountHandler(proc=nil, &block)
+      #
+      # Sets a count event handler. This is called when ticks have been counted on an input, or when the timeout has passed.
+      #
+      def setOnCountHandler(cb_proc = nil, &cb_block)
+        @on_count_thread.kill if defined? @on_count_thread
+        callback = cb_proc || cb_block
+        @on_count_thread = Thread.new {ext_setOnCountHandler(callback)}
+      end
+
+      alias :on_count :setOnCountHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/gps.rb

@@ -0,0 +1,37 @@
+
+
+module Phidgets
+  class GPS < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnPositionChangeHandler(proc=nil, &block)
+      #
+      # Sets a position change event handler. This is called when any of latitude, longitude, or altitude change.
+      #
+      def setOnPositionChangeHandler(cb_proc = nil, &cb_block)
+        @on_position_change_thread.kill if defined? @on_position_change_thread
+        callback = cb_proc || cb_block
+        @on_position_change_thread = Thread.new {ext_setOnPositionChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnPositionFixStatusChangeHandler(proc=nil, &block)
+      #
+      # Sets a position fix status change event handler. This is called when a position fix is aquired or lost.
+      #
+      def setOnPositionFixStatusChangeHandler(cb_proc = nil, &cb_block)
+        @on_position_fix_status_change_thread.kill if defined? @on_position_fix_status_change_thread
+        callback = cb_proc || cb_block
+        @on_position_fix_status_change_thread = Thread.new {ext_setOnPositionFixStatusChangeHandler(callback)}
+      end
+
+      alias :on_position_change :setOnPositionChangeHandler
+      alias :on_position_fix_status_change :setOnPositionFixStatusChangeHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/interfacekit.rb

@@ -1,139 +1,49 @@
 
 
 module Phidgets
-
-  extern "int CPhidgetInterfaceKit_create(void *)"
-  extern "int CPhidgetInterfaceKit_getInputCount(void *, int *)"
-  extern "int CPhidgetInterfaceKit_getInputState(void *, int, int *)"
-  extern "int CPhidgetInterfaceKit_getOutputCount(void *, int *)"
-  extern "int CPhidgetInterfaceKit_getOutputState(void *, int, int *)"
-  extern "int CPhidgetInterfaceKit_setOutputState(void *, int, int)"
-  extern "int CPhidgetInterfaceKit_getSensorCount(void *, int *)"
-  extern "int CPhidgetInterfaceKit_getSensorValue(void *, int, int *)"
-  extern "int CPhidgetInterfaceKit_getSensorRawValue(void *, int, int *)"
-  extern "int CPhidgetInterfaceKit_getRatiometric(void *, int *)"
-  extern "int CPhidgetInterfaceKit_setRatiometric(void *, int)"
-  
-  
   class InterfaceKit < Common
 
-    # Create a new InterfaceKit object.
-    # === Parameters
-    # * _serial_number_ = Serial number of the phidget board to open. Specify -1 to open any.
-    # * _timeout_       = Time to wait for attachment. Specify 0 to not call open.
-    def initialize(serial_number=-1, timeout=0)
-      super()
-      create
-      open(serial_number, timeout) if timeout > 0
-    end
-
-    # Gets the number of digital inputs supported by this board.
-    def getInputCount
-      cnt = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getInputCount', @handle, cnt.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      cnt.free = nil
-      cnt.to_i
-    end
-
-    # Gets the state of a digital input.
-    # === Parameters
-    # * _index_ = The input index.
-    def getInputState(index)
-      state = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getInputState', @handle, index.to_i, state.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      state.free = nil
-      state.to_i
-    end
-
-    # Gets the number of digital outputs supported by this board.
-    def getOutputCount
-      cnt = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getOutputCount', @handle, cnt.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      cnt.free = nil
-      cnt.to_i
-    end
-
-    # Gets the state of a digital output.
-    # === Parameters
-    # * _index_ = The output index.
-    def getOutputState(index)
-      state = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getOutputState', @handle, index.to_i, state.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      state.free = nil
-      state.to_i
-    end
-
-    # Sets the state of a digital output.
-    # === Parameters
-    # * _index_ = The output index.
-    # * _state_ = The output state. Possible values are PTRUE and PFALSE.
-    def setOutputState(index, state)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_setOutputState', @handle, index.to_i, state.to_i)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Gets the number of sensor (analog) inputs supported by this board.
-    def getSensorCount
-      cnt = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getSensorCount', @handle, cnt.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      cnt.free = nil
-      cnt.to_i
-    end
-
-    # Gets a sensor value (0-1000).
-    # === Parameters
-    # * _index_ = The sensor index.
-    def getSensorValue(index)
-      state = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getSensorValue', @handle, index.to_i, state.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      state.free = nil
-      state.to_i
-    end
-
-    # Gets a sensor raw value (12-bit).
-    # === Parameters
-    # * _index_ = The sensor index.
-    def getSensorRawValue(index)
-      state = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getSensorRawValue', @handle, index.to_i, state.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      state.free = nil
-      state.to_i
-    end
-
-    # Gets the ratiometric state for this board.
-    def getRatiometric
-      ratio = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_getRatiometric', @handle, ratio.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ratio.free = nil
-      ratio.to_i
-    end
-
-    # Sets the ratiometric state for this board.
-    # === Parameters
-    # * _ratiometric_ = The ratiometric state. Possible values are PTRUE  and PFALSE.
-    def setRatiometric(ratiometric)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_setRatiometric', @handle, ratiometric.to_i)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnInputChangeHandler(proc=nil, &block)
+      #
+      # Set a digital input change handler. This is called when a digital input changes.
+      #
+      def setOnInputChangeHandler(cb_proc = nil, &cb_block)
+        @on_input_change_thread.kill if defined? @on_input_change_thread
+        callback = cb_proc || cb_block
+        @on_input_change_thread = Thread.new {ext_setOnInputChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnOutputChangeHandler(proc=nil, &block)
+      #
+      # Set a digital output change handler. This is called when a digital output changes.
+      #
+      def setOnOutputChangeHandler(cb_proc = nil, &cb_block)
+        @on_output_change_thread.kill if defined? @on_output_change_thread
+        callback = cb_proc || cb_block
+        @on_output_change_thread = Thread.new {ext_setOnOutputChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnSensorChangeHandler(proc=nil, &block)
+      #
+      # Set a sensor change handler. This is called when a sensor value changes by more then the change trigger.
+      #
+      def setOnSensorChangeHandler(cb_proc = nil, &cb_block)
+        @on_sensor_change_thread.kill if defined? @on_sensor_change_thread
+        callback = cb_proc || cb_block
+        @on_sensor_change_thread = Thread.new {ext_setOnSensorChangeHandler(callback)}
+      end
+
+      alias :on_input_change :setOnInputChangeHandler
+      alias :on_output_change :setOnOutputChangeHandler
+      alias :on_sensor_change :setOnSensorChangeHandler
 
-    private
-    
-    # Creates a Phidget InterfaceKit handle.
-    def create
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetInterfaceKit_create', @handle.ref)
-      raise Phidgets::Exception.new(r) if r != 0
     end
 
   end
-
 end
 

data/lib/phidgets/ir.rb

@@ -0,0 +1,50 @@
+
+
+module Phidgets
+  class IR < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnCodeHandler(proc=nil, &block)
+      #
+      # Set a Code handler. This is called when a code has been received that could be
+      # automatically decoded.
+      #
+      def setOnCodeHandler(cb_proc = nil, &cb_block)
+        @on_code_thread.kill if defined? @on_code_thread
+        callback = cb_proc || cb_block
+        @on_code_thread = Thread.new {ext_setOnCodeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnLearnHandler(proc=nil, &block)
+      #
+      # Set a Learn handler. This is called when a code has been received for long enough to be learned.
+      #
+      def setOnLearnHandler(cb_proc = nil, &cb_block)
+        @on_learn_thread.kill if defined? @on_learn_thread
+        callback = cb_proc || cb_block
+        @on_learn_thread = Thread.new {ext_setOnLearnHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnRawDataHandler(proc=nil, &block)
+      #
+      # Set a Raw Data handler. This is called when raw data has been read from the device.
+      #
+      def setOnRawDataHandler(cb_proc = nil, &cb_block)
+        @on_raw_data_thread.kill if defined? @on_raw_data_thread
+        callback = cb_proc || cb_block
+        @on_raw_data_thread = Thread.new {ext_setOnRawDataHandler(callback)}
+      end
+
+      alias :on_code :setOnCodeHandler
+      alias :on_learn :setOnLearnHandler
+      alias :on_raw_data :setOnRawDataHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/led.rb

@@ -0,0 +1,8 @@
+
+
+module Phidgets
+  class LED < Common
+
+  end
+end
+

data/lib/phidgets/manager.rb

@@ -1,132 +1,80 @@
 
 module Phidgets
-
-  extern "int CPhidgetManager_create(void *)"
-  extern "int CPhidgetManager_open(void *)"
-  extern "int CPhidgetManager_close(void *)"
-  extern "int CPhidgetManager_delete(void *)"
-  extern "int CPhidgetManager_getAttachedDevices(void *, void *, int *)"
-  extern "int CPhidgetManager_freeAttachedDevicesArray(void *)"
-  extern "int CPhidgetManager_openRemote(void *, void *, void *)"
-  extern "int CPhidgetManager_openRemoteIP(void *, char *, int, void *)"
-
-
   class Manager
 
-    # Creates a new Manager object.
-    def initialize
-      @server = nil
-      @port = nil
-      @password = nil
-      @handle = Phidgets.malloc(SIZEOF_VOIDP)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_create', @handle.ref)
-      raise Phidgets::Exception.new(r) if r != 0
+    # call-seq:
+    #   open(args)
+    #
+    # Opens a Manager. Will attempt to make the correct open call (open, openRemote, openRemoteIP) based
+    # on the arguments passed in. Args is a hash and the following keys may be used:
+    # :server_id, :address, :port, :password.
+    #
+    def open(args={})
+      if args.key? :server_id
+        open_remote(args[:server_id], args[:password])
+      elsif args.key? :address
+        open_remote_ip(args[:address], args[:port], args[:password])
+      else
+        ext_open
+      end
     end
 
-    # Opens a Manager.
-    def open
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_open', @handle)
-      raise Phidgets::Exception.new(r) if r != 0
 
-      # a delay is required between the time the manager is opened and when it is used, otherwise it will report that no phidgets are attached. there really should be a better way.
-      sleep 1
-    end
-
-    # Opens a Manager remotely by ServerID. Note that this requires Bonjour (mDNS) to be running on both the host and the server.
-    # === Parameters
-    # * _server_        = Server ID. Specify nil to open any.
-    # * _password_      = Password. Can be nil if the server is running unsecured.
-    def openRemote(server=nil, password=nil)
-      @server = server
-      @password = password
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_openRemote', @handle, server, password)
-      raise Phidgets::Exception.new(r) if r != 0
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnAttachHandler(proc=nil, &block)
+      #
+      # Sets an attach handler callback function. This is called when a Phidget is plugged into the system.
+      #
+      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 a 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 Phidget Managers 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 Phidget Managers 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
 
-      # a delay is required between the time the manager is opened and when it is used, otherwise it will report that no phidgets are attached. there really should be a better way.
-      sleep 2
     end
 
-    # Opens a Manager remotely by address and port.
-    # === Parameters
-    # * _address_       = Address. This can be a hostname or IP address.
-    # * _port_          = Port number. Default is 5001.
-    # * _password_      = Password. Can be nil if the server is running unsecured.
-    def openRemoteIP(address, port=5001, password=nil)
-      @server = address
-      @port = port.to_i
-      @password = password
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_openRemoteIP', @handle, address, port.to_i, password)
-      raise Phidgets::Exception.new(r) if r != 0
-
-      # a delay is required between the time the manager is opened and when it is used, otherwise it will report that no phidgets are attached. there really should be a better way.
-      sleep 2
-    end
-
-    # Closes a Manager.
-    def close
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_close', @handle)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Frees a Manager handle.
-    def delete
-      @handle.free = nil
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_delete', @handle)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Gets a hash of all currently attached Phidgets. The indices into the hash are the serial numbers of the Phidgets.
-    def getAttachedDevices
-      handles = Phidgets.malloc(SIZEOF_VOIDP)
-      count = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_getAttachedDevices', @handle, handles.ref, count.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      count.free = nil
-
-      devices = {}
-      count.to_i.times { |i|
-        handle = handles + (i * SIZEOF_VOIDP)
-        serial = getSerialNumber(handle)
-
-        devices[serial] = case getDeviceClass(handle)
-        when CLASS_INTERFACEKIT
-          InterfaceKit.new
-        when CLASS_RFID
-          RFID.new
-        when CLASS_SERVO
-          Servo.new
-        end
-
-        devices[serial].open(serial, 3000) unless @server
-        devices[serial].openRemote(serial, @server, @password, 4000) if @server and !@port
-        devices[serial].openRemoteIP(serial, @server, @port, @password, 4000) if @server and @port
-      }
-
-      r = Phidgets.send(FUNCTION_PREFIX + 'PhidgetManager_freeAttachedDevicesArray', handles)
-      raise Phidgets::Exception.new(r) if r != 0
-      
-      devices
-    end
-
-    private
-  
-    def getDeviceClass handle
-      dev_class = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceClass', handle.ptr, dev_class.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      dev_class.free = nil
-      dev_class.to_i
-    end
-  
-    def getSerialNumber handle
-      sn = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getSerialNumber', handle.ptr, sn.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      sn.free = nil
-      sn.to_i
-    end
-  
   end
-
 end
 

data/lib/phidgets/motor_control.rb

@@ -0,0 +1,110 @@
+
+
+module Phidgets
+  class MotorControl < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnVelocityChangeHandler(proc=nil, &block)
+      #
+      # Sets a velocity change event handler. This is called when the velocity changes.
+      #
+      def setOnVelocityChangeHandler(cb_proc = nil, &cb_block)
+        @on_velocity_change_thread.kill if defined? @on_velocity_change_thread
+        callback = cb_proc || cb_block
+        @on_velocity_change_thread = Thread.new {ext_setOnVelocityChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnCurrentChangeHandler(proc=nil, &block)
+      #
+      # Sets a current change event handler. This is called when the current draw changes.
+      #
+      def setOnCurrentChangeHandler(cb_proc = nil, &cb_block)
+        @on_current_change_thread.kill if defined? @on_current_change_thread
+        callback = cb_proc || cb_block
+        @on_current_change_thread = Thread.new {ext_setOnCurrentChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnCurrentUpdateHandler(proc=nil, &block)
+      #
+      # Set a current update handler. This is called at a constant rate; every 8ms.
+      #
+      def setOnCurrentUpdateHandler(cb_proc = nil, &cb_block)
+        @on_current_update_thread.kill if defined? @on_current_update_thread
+        callback = cb_proc || cb_block
+        @on_current_update_thread = Thread.new {ext_setOnCurrentUpdateHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnInputChangeHandler(proc=nil, &block)
+      #
+      # Set a digital input change handler. This is called when a digital input changes.
+      #
+      def setOnInputChangeHandler(cb_proc = nil, &cb_block)
+        @on_input_change_thread.kill if defined? @on_input_change_thread
+        callback = cb_proc || cb_block
+        @on_input_change_thread = Thread.new {ext_setOnInputChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnEncoderPositionChangeHandler(proc=nil, &block)
+      #
+      # Set an encoder position change handler. This is called when the encoder position changes.
+      #
+      def setOnEncoderPositionChangeHandler(cb_proc = nil, &cb_block)
+        @on_encoder_position_change_thread.kill if defined? @on_encoder_position_change_thread
+        callback = cb_proc || cb_block
+        @on_encoder_position_change_thread = Thread.new {ext_setOnEncoderPositionChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnEncoderPositionUpdateHandler(proc=nil, &block)
+      #
+      # Set an encoder position update handler. This is called at a constant rate; every 8ms, whether the encoder
+      # position has changed or not.
+      #
+      def setOnEncoderPositionUpdateHandler(cb_proc = nil, &cb_block)
+        @on_encoder_position_update_thread.kill if defined? @on_encoder_position_update_thread
+        callback = cb_proc || cb_block
+        @on_encoder_position_update_thread = Thread.new {ext_setOnEncoderPositionUpdateHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnBackEMFUpdateHandler(proc=nil, &block)
+      #
+      # Set a back EMF update handler. This is called at a constant rate; every 16ms, when back EMF sensing is enabled for that motor.
+      #
+      def setOnBackEMFUpdateHandler(cb_proc = nil, &cb_block)
+        @on_back_emf_update_thread.kill if defined? @on_back_emf_update_thread
+        callback = cb_proc || cb_block
+        @on_back_emf_update_thread = Thread.new {ext_setOnBackEMFUpdateHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnSensorUpdateHandler(proc=nil, &block)
+      #
+      # Set a sensor update handler. This is called at a constant rate; every 8ms.
+      #
+      def setOnSensorUpdateHandler(cb_proc = nil, &cb_block)
+        @on_sensor_update_thread.kill if defined? @on_sensor_update_thread
+        callback = cb_proc || cb_block
+        @on_sensor_update_thread = Thread.new {ext_setOnSensorUpdateHandler(callback)}
+      end
+
+      alias :on_velocity_change :setOnVelocityChangeHandler
+      alias :on_current_change :setOnCurrentChangeHandler
+      alias :on_current_update :setOnCurrentUpdateHandler
+      alias :on_input_change :setOnInputChangeHandler
+      alias :on_encoder_position_change :setOnEncoderPositionChangeHandler
+      alias :on_encoder_position_update :setOnEncoderPositionUpdateHandler
+      alias :on_back_emf_update :setOnBackEMFUpdateHandler
+      alias :on_sensor_update :setOnSensorUpdateHandler
+
+    end
+
+  end
+end
+