phidgets_native 0.1.0 → 0.2.0

data/README.rdoc

@@ -22,16 +22,16 @@ Presumably most other UNIX variants will work just fine. Probably win32/win64
 will not.
 
 ==Supported Devices
-As of this version, we currently only support the following phidgets:
+As of the most recent version of this library, we support the following phidgets:
 * Phidget Spatial
 * Phidget GPS
 * Phidget Interface Kit
-There will soon be support for the "Phidget Servo" phidget. If you have a phidget 
-that's not on our current compatibility list, either get me a copy of the phidget 
-to work with at my desk, or check out the existing modules for a reference in 
-setting up your own class, and push your changes to my repo. Most of the difficult 
-work is done, and you'll find plenty of stubs to work with for nearly all the 
-available phidgets.
+* Phidget Advanced Servo
+If you have a phidget that's not on the compatibility list, either buy me a copy 
+of the phidget you need support for, or check out the existing modules for a 
+reference in setting up your own class, and push your changes to my repo. Most 
+of the difficult work is done, and you'll find plenty of stubs to work with for 
+nearly all the available phidgets.
 
 =Why not Phidgets-FFI?
 Though encompassing, Phidgets-FFI is seemingly quite buggy, and a bit slow. Particularly
@@ -60,7 +60,7 @@ is attached. If the device is disconnected and reconnected, your phidget object
 will automatically re-register its handlers with the device, and continue to 
 function as if the device were never disconnected to begin with. Keep in mind that
 any attributes relating to the device's capabilities (mostly those in the 
-Phidget::Device class, though there are things like the axial extents in the 
+PhidgetsNative::Device class, though there are things like the axial extents in the 
 spatial object) will be 'cached' from the previous connection. "State" attributes
 (such as the spatial's accelerometer output) will return nil or 0.
 
@@ -68,7 +68,7 @@ In practice, if you need an event-driven model for your code, you can almost cer
 get by using a ruby thread with a polling loop, like so:
 
   is_fixed_last = false 
-  @poller = Thread.new(Phidget::GPS(12345)) do |gps| 
+  @poller = Thread.new(PhidgetsNative::GPS(12345)) do |gps| 
     gps.wait_for_attachment(10000)
 
     begin
@@ -91,8 +91,8 @@ latest Phidget driver for your system.
 We also recommend that you read the following reference materials:
 * {General Phidget Programming}[http://www.phidgets.com/docs/General_Phidget_Programming]
 * The {User Guide}[http://www.phidgets.com/docs/Category:UserGuide] for your device
-* {RubyDoc API Documentation}[http://rubydoc.info/gems/phidgets_native/frames]
-* {Ruby code samples}[https://github.com/kreynolds/phidgets_native/tree/master/examples]
+* {RubyDoc API Documentation}[http://rubydoc.info/github/brighton36/phidgets_native/master/frames]
+* {Ruby code samples}[https://github.com/brighton36/phidgets_native/tree/master/examples]
 
 The RubyDoc API manual contains calls and events for every type of Phidget and 
 can be used as a reference. You can find a high level discussion about programming 
@@ -136,7 +136,7 @@ will reserve the device until closed. This prevents any other instances from
 retrieving data from the Phidget, including other programs. 
 
 ==Standard accessors
-All devices support the accessors defined in the Phidget::Device class from which
+All devices support the accessors defined in the PhidgetsNative::Device class from which
 they inherit. 
 
 ==A note about device availability

data/examples/advancedservo.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require '%s/lib/common' % File.dirname(__FILE__)
+
+additional_attribs = [
+  %w(Motor\ Count motor_count),
+  %w(Acceleration\ Max acceleration_max),
+  %w(Acceleration\ Min acceleration_min),
+  %w(Velocity\ Max velocity_max),
+  %w(Velocity\ Min velocity_min)
+]
+
+phidgets_example_for(PhidgetsNative::AdvancedServo, additional_attribs) do |servo|
+  servo.acceleration 0, servo.acceleration_max[0]
+  servo.velocity_limit 0, servo.velocity_max[0]
+  # NOTE that these doesn't seem to be supported on all servo types
+  servo.position_max 0, 220 
+  servo.position_min 0, 0 
+  # /NOTE
+  servo.servo_type 0, :default
+  servo.speed_ramping 0, false
+  servo.engaged 0, true
+
+  servo_range = servo.position_max(0) - servo.position_min(0)
+  servo_middle = servo.position_min(0) + servo_range/2
+  servo_left = servo.position_min(0) + servo_middle - servo_range / 4
+  servo_right = servo.position_min(0) + servo_middle + servo_range / 4
+
+  servo.position 0, servo_middle
+
+  puts "\nServo-specific Attributes:"
+  ConsoleTable.new([
+    'Servo Offset', 'Acceleration Max', 'Acceleration Min','Velocity Limit', 'Position Max', 'Position Min', 
+    'Speed_Ramping?', 'Engaged?', 'Stopped?', 'Servo Type' ]).output do 
+    (0...servo.motor_count).collect do |i| 
+      ([i, servo.acceleration_max[i], servo.acceleration_min[i]]+%w( 
+      velocity_limit position_max position_min speed_ramping? engaged? 
+      stopped? servo_type).collect{|attr|
+        begin
+          servo.send(attr, i) 
+        rescue PhidgetsNative::UnknownValError
+          nil
+        end
+      }).collect(&:inspect)
+    end 
+  end
+
+  puts "\nPolled Values:"
+  i = 0
+  ConsoleTable.new([
+    'Sample Rates',
+    'Currents',
+    'Positions',
+    'Velocities'
+  ]).output(:header => (i == 0), :separator => false) do |columns|
+    i+=1
+
+    servo.position 0, (i % 2 == 0) ? servo_left : servo_right if (i != 0)
+    [ [servo.sample_rates, servo.currents, servo.positions, servo.velocities].collect(&:inspect) ]
+  end while sleep(3)
+end

data/examples/interface_kit.rb

@@ -32,6 +32,9 @@ phidgets_example_for(PhidgetsNative::InterfaceKit, additional_attribs) do |ifkit
     end
   end
 
+  # Set the ratiometric state
+  ifkit.ratiometric = false
+
   # Test sensor_raw
   puts "Raw Analog sensor values:"
   ConsoleTable.new((0...ifkit.sensor_count).collect{|i| "Sensor #{i}"}).output do 
@@ -50,8 +53,6 @@ phidgets_example_for(PhidgetsNative::InterfaceKit, additional_attribs) do |ifkit
   ]).output(:header => (i == 0), :separator => false) do |columns|
     i+=1
 
-    #TODO Test the ratiometric set at some point
-
     [ [ifkit.input_sample_rates, ifkit.sensor_sample_rates, ifkit.ratiometric?.inspect, 
       ifkit.sensors.inspect]+[ifkit.inputs, ifkit.outputs].collect{ |bools|
         (bools.kind_of? Array) ? 

data/ext/phidgets_native/advancedservo.c

@@ -0,0 +1,112 @@
+#include "phidgets_native.h"
+
+int CCONV advancedservo_on_attach(CPhidgetHandle phid, void *userptr) {
+  PhidgetInfo *info = userptr;
+  AdvancedServoInfo *servo_info = info->type_info;
+  CPhidgetAdvancedServoHandle advancedservo = (CPhidgetAdvancedServoHandle) phid;
+
+  report(CPhidgetAdvancedServo_getMotorCount(advancedservo, &servo_info->motor_count));
+  servo_info->is_motor_count_known = true;
+
+  if (servo_info->motor_count != servo_info->motor_count_prior) {
+    if(servo_info->acceleration_min) xfree(servo_info->acceleration_min);
+    if(servo_info->acceleration_max) xfree(servo_info->acceleration_max);
+    if(servo_info->velocity_min) xfree(servo_info->velocity_min);
+    if(servo_info->velocity_max) xfree(servo_info->velocity_max);
+    if(servo_info->sample_rates) xfree(servo_info->sample_rates);
+
+    servo_info->acceleration_max = ALLOC_N(double, servo_info->motor_count); 
+    servo_info->acceleration_min = ALLOC_N(double, servo_info->motor_count); 
+    servo_info->velocity_min = ALLOC_N(double, servo_info->motor_count); 
+    servo_info->velocity_max = ALLOC_N(double, servo_info->motor_count); 
+    servo_info->sample_rates = ALLOC_N(SampleRate, servo_info->motor_count); 
+
+    memset(servo_info->sample_rates, 0, sizeof(SampleRate) * servo_info->motor_count);
+
+    for (int i=0; i < servo_info->motor_count; i++) {
+      report(CPhidgetAdvancedServo_getAccelerationMax(advancedservo,i,&servo_info->acceleration_max[i]));
+      report(CPhidgetAdvancedServo_getAccelerationMin(advancedservo,i,&servo_info->acceleration_min[i]));
+      report(CPhidgetAdvancedServo_getVelocityMax(advancedservo,i,&servo_info->velocity_max[i]));
+      report(CPhidgetAdvancedServo_getVelocityMin(advancedservo,i,&servo_info->velocity_min[i]));
+    }
+  }
+
+  servo_info->current = ALLOC_N(double, servo_info->motor_count); 
+  servo_info->position = ALLOC_N(double, servo_info->motor_count); 
+  servo_info->velocity = ALLOC_N(double, servo_info->motor_count); 
+  
+  memset(servo_info->current, 0, sizeof(double) * servo_info->motor_count);
+  memset(servo_info->position, 0, sizeof(double) * servo_info->motor_count);
+  memset(servo_info->velocity, 0, sizeof(double) * servo_info->motor_count);
+
+  return 0;
+}
+
+int CCONV advancedservo_on_detach(CPhidgetHandle phid, void *userptr) {
+  PhidgetInfo *info = userptr;
+  AdvancedServoInfo *servo_info = info->type_info;
+
+  servo_info->motor_count_prior = servo_info->motor_count;
+
+  if(servo_info->current) xfree(servo_info->current);
+  if(servo_info->position) xfree(servo_info->position);
+  if(servo_info->velocity) xfree(servo_info->velocity);
+
+  servo_info->current = 0;
+  servo_info->position = 0;
+  servo_info->velocity = 0;
+
+  memset(servo_info->sample_rates, 0, sizeof(SampleRate) * servo_info->motor_count);
+
+  return 0;
+}
+
+void advancedservo_on_free(void *type_info) {
+  AdvancedServoInfo *servo_info = type_info;
+
+  if(servo_info->sample_rates) xfree(servo_info->sample_rates);
+  if(servo_info->acceleration_min) xfree(servo_info->acceleration_min);
+  if(servo_info->acceleration_max) xfree(servo_info->acceleration_max);
+  if(servo_info->velocity_min) xfree(servo_info->velocity_min);
+  if(servo_info->velocity_max) xfree(servo_info->velocity_max);
+  if(servo_info->current) xfree(servo_info->current);
+  if(servo_info->position) xfree(servo_info->position);
+  if(servo_info->velocity) xfree(servo_info->velocity);
+  if (servo_info) xfree(servo_info);
+
+  return;
+}
+
+int CCONV advancedservo_on_velocity_change(CPhidgetAdvancedServoHandle phid, void *userptr, int index, double velocity) {
+  PhidgetInfo *info = userptr;
+  AdvancedServoInfo *servo_info = info->type_info;
+
+  sample_tick(&servo_info->sample_rates[index], NULL);
+
+  if (servo_info->velocity) servo_info->velocity[index] = velocity;
+
+  return 0;
+}
+
+int CCONV advancedservo_on_position_change(CPhidgetAdvancedServoHandle phid, void *userptr, int index, double position) {
+  PhidgetInfo *info = userptr;
+  AdvancedServoInfo *servo_info = info->type_info;
+
+  sample_tick(&servo_info->sample_rates[index], NULL);
+
+  if (servo_info->position) servo_info->position[index] = position;
+
+  return 0;
+}
+
+int CCONV advancedservo_on_current_change(CPhidgetAdvancedServoHandle phid, void *userptr, int index, double current) {
+  PhidgetInfo *info = userptr;
+  AdvancedServoInfo *servo_info = info->type_info;
+
+  sample_tick(&servo_info->sample_rates[index], NULL);
+
+  if (servo_info->current) servo_info->current[index] = current;
+
+  return 0;
+}
+

data/ext/phidgets_native/advancedservo_ruby.c

@@ -1,5 +1,15 @@
 #include "phidgets_native.h"
 
+const char MSG_INDEX_MUST_BE_FIXNUM[] = "servo index must be fixnum";
+const char MSG_VALUE_MUST_BE_FLOAT[] = "value must be a floating point number";
+const char MSG_VALUE_MUST_BE_BOOL[] = "value must be either true or false";
+const char MSG_SERVO_MIN_US_MUST_BE_FLOAT[] = "min_us must be a floating point number";
+const char MSG_SERVO_MAX_US_MUST_BE_FLOAT[] = "max_us must be a floating point number";
+const char MSG_SERVO_DEGREES_MUST_BE_FLOAT[] = "degrees_us must be a floating point number";
+const char MSG_SERVO_VELOCITY_MAX_MUST_BE_FLOAT[] = "velocity_max must be a floating point number";
+const char MSG_TYPE_MUST_BE_SYMBOL[] = "type must be a symbol";
+const char MSG_UNRECOGNIZED_SERVO_TYPE[] = "unrecognized servo type, double check your spelling and/or revisit the rdoc";
+
 /* 
  * Document-class: PhidgetsNative::AdvancedServo < PhidgetsNative::Device
  *
@@ -22,12 +32,828 @@ void Init_phidgets_native_advancedservo(VALUE m_Phidget) {
    * are required to be Fixnums (aka "unsigned integers").
    */
   rb_define_method(c_AdvancedServo, "initialize", advancedservo_initialize, 1);
+
+  /*
+   * Document-method: motor_count
+   * call-seq:
+   *   motor_count -> Fixnum
+   *
+   * Returns an integer which represents the number of motor interfaces provided
+   * by this advanced servo controller, or nil if the device has yet to be connected.
+   */
+  rb_define_method(c_AdvancedServo, "motor_count", advancedservo_motor_count, 0);
+
+  /*
+   * Document-method: sample_rates
+   * call-seq:
+   *   sample_rates -> Array
+   *
+   * The advancedservo object tracks the sample rate of each servo individually. 
+   * This method returns an array containing the sample rates of each servo
+   */
+  rb_define_method(c_AdvancedServo, "sample_rates", advancedservo_sample_rates, 0);
+
+  /*
+   * Document-method: acceleration_max
+   * call-seq:
+   *   acceleration_max -> Array
+   *
+   * Returns an array of Floats which specify the maximum acceleration value that can 
+   * be configured on each servo, or nil if the device has yet to be connected.
+   */
+  rb_define_method(c_AdvancedServo, "acceleration_max", advancedservo_acceleration_max, 0);
+
+  /*
+   * Document-method: acceleration_min
+   * call-seq:
+   *   acceleration_min -> Array
+   *
+   * Returns an array of Floats which specify the minimum acceleration value that can 
+   * be configured on each servo, or nil if the device has yet to be connected.
+   */
+  rb_define_method(c_AdvancedServo, "acceleration_min", advancedservo_acceleration_min, 0);
+
+  /*
+   * Document-method: velocity_max
+   * call-seq:
+   *   velocity_max -> Array
+   *
+   * Returns an array of Floats which specify the maximum velocity value that can 
+   * be configured on each servo, or nil if the device has yet to be connected.
+   */
+  rb_define_method(c_AdvancedServo, "velocity_max", advancedservo_velocity_max, 0);
+
+  /*
+   * Document-method: velocity_min
+   * call-seq:
+   *   velocity_min -> Array
+   *
+   * Returns an array of Floats which specify the minimum velocity value that can 
+   * be configured on each servo, or nil if the device is disconnected.
+   */
+  rb_define_method(c_AdvancedServo, "velocity_min", advancedservo_velocity_min, 0);
+
+  /*
+   * Document-method: currents
+   * call-seq:
+   *   currents -> Array
+   *
+   * Returns an array of Floats which represent the current draw of each servo
+   * attached to the system, or nil if the device is disconnected.
+   */
+  rb_define_method(c_AdvancedServo, "currents", advancedservo_currents, 0);
+
+  /*
+   * Document-method: positions
+   * call-seq:
+   *   positions -> Array
+   *
+   * Returns an array of Floats which represent the positions of each servo
+   * attached to the system, or nil if the device has yet to be connected.
+   */
+  rb_define_method(c_AdvancedServo, "positions", advancedservo_positions, 0);
+
+  /*
+   * Document-method: velocities
+   * call-seq:
+   *   velocities -> Array
+   *
+   * Returns an array of Floats which represent the velocities of each servo
+   * attached to the system, or nil if the device is disconnected.
+   */
+  rb_define_method(c_AdvancedServo, "velocities", advancedservo_velocities, 0);
+
+  /*
+   * Document-method: acceleration
+   * call-seq:
+   *   acceleration(Fixnum index, Float value = nil) -> Float
+   *
+   * If a value is passed, the acceleration of a servo is set to the specified
+   * value at the provided index.
+   * Returns a float representing the "acceleration" of the servo at the provided
+   * index. This value comes directly from the 
+   * CPhidgetAdvancedServo_getAcceleration[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "acceleration", advancedservo_acceleration, -1);
+
+  /*
+   * Document-method: velocity_limit
+   * call-seq:
+   *   velocity_limit(Fixnum index, Float value = nil) -> Float
+   *
+   * If a value is passed, the velocity_limit of a servo is set to the specified
+   * value at the provided index.
+   * Returns a float representing the "velocity limit" of the servo at the provided
+   * index. This value comes directly from the 
+   * CPhidgetAdvancedServo_getVelocityLimit[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "velocity_limit", advancedservo_velocity_limit, -1);
+
+  /*
+   * Document-method: position
+   * call-seq:
+   *   position(Fixnum index, Float value = nil) -> Float
+   *
+   * Sets the servo position of the servo at the provided index.
+   * Returns the passed position. This value comes directly from the 
+   * CPhidgetAdvancedServo_setPosition[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "position", advancedservo_position_set, 2);
+
+  /*
+   * Document-method: position_max
+   * call-seq:
+   *   position_max(Fixnum index, Float value = nil) -> Float
+   *
+   * If a value is passed, the position_max of a servo is set to the specified
+   * value at the provided index.
+   * Returns a float representing the "maximum position" of the servo at the provided
+   * index. This value comes directly from the 
+   * CPhidgetAdvancedServo_getPositionMax[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "position_max", advancedservo_position_max, -1);
+
+  /*
+   * Document-method: position_min
+   * call-seq:
+   *   position_min(Fixnum index, Float value = nil) -> Float
+   *
+   * If a value is passed, the position_min of a servo is set to the specified
+   * value at the provided index.
+   * Returns a float representing the "minimum position" of the servo at the provided
+   * index. This value comes directly from the 
+   * CPhidgetAdvancedServo_getPositionMin[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "position_min", advancedservo_position_min, -1);
+
+  /*
+   * Document-method: servo_type
+   * call-seq:
+   *   servo_type(Fixnum index, Float value = nil) -> Symbol
+   *
+   * If a value is passed, the type of servo is set to the specified
+   * value at the provided index.
+   * Returns a symbol indicating the model/type of the servo at the provided
+   * index. This value comes directly from the 
+   * CPhidgetAdvancedServo_getServoType[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   *
+   * Currently, the following servo types are returned:
+   * * :default
+   * * :raw_us_mode
+   * * :hitec_hs322hd
+   * * :hitec_hs5245mg
+   * * :hitec_805bb
+   * * :hitec_hs422
+   * * :towerpro_mg90
+   * * :hitec_hsr1425cr
+   * * :hitec_hs785hb
+   * * :hitec_hs485hb
+   * * :hitec_hs645mg
+   * * :hitec_815bb
+   * * :firgelli_l12_30_50_06_r
+   * * :firgelli_l12_50_100_06_r
+   * * :firgelli_l12_50_210_06_r
+   * * :firgelli_l12_100_50_06_r
+   * * :firgelli_l12_100_100_06_r
+   * * :springrc_sm_s2313m
+   * * :springrc_sm_s3317m
+   * * :springrc_sm_s3317sr
+   * * :springrc_sm_s4303r
+   * * :springrc_sm_s4315m
+   * * :springrc_sm_s4315r
+   * * :springrc_sm_s4505b
+   * * :unknown
+   *
+   * NOTE: Servo types cannot be set to :unknown, though :unknown is possibly
+   * returned if an unrecognized servo type is returned by the phidget libraries.
+   */
+  rb_define_method(c_AdvancedServo, "servo_type", advancedservo_servo_type, -1);
+
+  /*
+   * Document-method: speed_ramping?
+   * call-seq:
+   *   speed_ramping?(Fixnum index) -> Boolean
+   *
+   * Returns either true or false, depending on whether the servo at the provided
+   * index is configured to speed ramp. This value comes directly from the 
+   * CPhidgetAdvancedServo_getSpeedRampingOn[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "speed_ramping?", advancedservo_is_speed_ramping, 1);
+
+  /*
+   * Document-method: engaged?
+   * call-seq:
+   *   engaged?(Fixnum index) -> Boolean
+   *
+   * Returns either true or false, depending on whether the servo at the provided
+   * index is engaged (aka - whether the motor is powered or not). This value 
+   * comes directly from the 
+   * CPhidgetAdvancedServo_getEngaged[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "engaged?", advancedservo_is_engaged, 1);
+
+  /*
+   * Document-method: stopped?
+   * call-seq:
+   *   stopped?(Fixnum index) -> Boolean
+   *
+   * Returns either true or false, depending on whether the servo at the provided
+   * index is stopped (aka - whether the motor is currently moving or not). This 
+   * value comes directly from the 
+   * CPhidgetAdvancedServo_getStopped[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "stopped?", advancedservo_is_stopped, 1);
+
+
+  /*
+   * Document-method: speed_ramping
+   * call-seq:
+   *   speed_ramping(Fixnum index, Boolean) -> Boolean
+   *
+   * Sets the "speed ramping" of the servo at the provided index.
+   * This value is sent directly to the
+   * CPhidgetAdvancedServo_setSpeedRampingOn[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "speed_ramping", advancedservo_speed_ramping_set, 2);
+
+  /*
+   * Document-method: engaged
+   * call-seq:
+   *   engaged(Fixnum index, Boolean) -> Boolean
+   *
+   * Sets the "engagement" of the servo at the provided index.
+   * This value is sent directly to the
+   * CPhidgetAdvancedServo_setEngaged[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "engaged", advancedservo_engaged_set, 2);
+
+  /*
+   * Document-method: servo_parameters
+   * call-seq:
+   *   servo_parameters(Fixnum index, Float min_us, Float max_us, Float degrees, Float velocity_max) -> Qnil
+   *
+   * Sets the "servo parameters" of the servo at the provided index.
+   * This value is sent directly to the
+   * CPhidgetAdvancedServo_setServoParameters[http://www.phidgets.com/documentation/web/cdoc/group__phidadvservo.html] 
+   * function.
+   */
+  rb_define_method(c_AdvancedServo, "servo_parameters", advancedservo_servo_parameters_set, 5);
 }
 
 VALUE advancedservo_initialize(VALUE self, VALUE serial) {
   PhidgetInfo *info = device_info(self);
+  
+  AdvancedServoInfo *servo_info = ALLOC(AdvancedServoInfo); 
+  memset(servo_info, 0, sizeof(AdvancedServoInfo));
+  servo_info->is_motor_count_known = false;
+
   CPhidgetAdvancedServoHandle advancedservo = 0;
   ensure(CPhidgetAdvancedServo_create(&advancedservo));
+
   info->handle = (CPhidgetHandle)advancedservo;
+  info->on_type_attach = advancedservo_on_attach;
+  info->on_type_detach = advancedservo_on_detach;
+  info->on_type_free = advancedservo_on_free;
+  info->type_info = servo_info;
+
+  ensure(CPhidgetAdvancedServo_set_OnVelocityChange_Handler(advancedservo, advancedservo_on_velocity_change, info));
+  ensure(CPhidgetAdvancedServo_set_OnPositionChange_Handler(advancedservo, advancedservo_on_position_change, info));
+  ensure(CPhidgetAdvancedServo_set_OnCurrentChange_Handler(advancedservo, advancedservo_on_current_change, info));
+
   return rb_call_super(1, &serial);
 }
+
+VALUE advancedservo_close(VALUE self) {
+  PhidgetInfo *info = device_info(self);
+
+  ensure(CPhidgetAdvancedServo_set_OnVelocityChange_Handler((CPhidgetAdvancedServoHandle)info->handle, NULL, NULL));
+  ensure(CPhidgetAdvancedServo_set_OnPositionChange_Handler((CPhidgetAdvancedServoHandle)info->handle, NULL, NULL));
+  ensure(CPhidgetAdvancedServo_set_OnCurrentChange_Handler((CPhidgetAdvancedServoHandle)info->handle, NULL, NULL));
+
+  return rb_call_super(0,NULL);
+}
+
+VALUE advancedservo_motor_count(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->is_motor_count_known) ? 
+    INT2FIX(servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_sample_rates(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  if (!servo_info->is_motor_count_known) return Qnil;
+
+  int *rates_in_hz = ALLOC_N(int, servo_info->motor_count);
+  for(int i=0; i<servo_info->motor_count; i++)
+    rates_in_hz[i] = servo_info->sample_rates[i].in_hz;
+
+  VALUE ret = int_array_to_rb(rates_in_hz, servo_info->motor_count);
+
+  xfree(rates_in_hz);
+
+  return ret;
+}
+
+VALUE advancedservo_acceleration_max(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->is_motor_count_known) ? 
+    double_array_to_rb(servo_info->acceleration_max, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_acceleration_min(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->is_motor_count_known) ? 
+    double_array_to_rb(servo_info->acceleration_min, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_velocity_max(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->is_motor_count_known) ? 
+    double_array_to_rb(servo_info->velocity_max, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_velocity_min(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->is_motor_count_known) ? 
+    double_array_to_rb(servo_info->velocity_min, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_currents(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->current) ? 
+    double_array_to_rb(servo_info->current, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_positions(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->position) ? 
+    double_array_to_rb(servo_info->position, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_velocities(VALUE self) {
+  AdvancedServoInfo *servo_info = device_type_info(self);
+
+  return (servo_info->velocity) ? 
+    double_array_to_rb(servo_info->velocity, servo_info->motor_count) : Qnil;
+}
+
+VALUE advancedservo_acceleration(int argc, VALUE* argv, VALUE self) {
+  VALUE index;
+  VALUE value;
+
+  rb_scan_args(argc, argv, "11", &index, &value);
+
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+  double value_dbl;
+
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+
+  if(NIL_P(value)) {
+    // It's a get request:
+    ensure(CPhidgetAdvancedServo_getAcceleration(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, &value_dbl ));
+
+  } else {
+    // Set request
+    if ( (TYPE(value) != T_FLOAT) && (TYPE(value) != T_FIXNUM) )
+      rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_FLOAT);
+
+    value_dbl = NUM2DBL(value);
+
+    ensure(CPhidgetAdvancedServo_setAcceleration(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, value_dbl ));
+  }
+
+  return DBL2NUM(value_dbl);
+}
+
+VALUE advancedservo_velocity_limit(int argc, VALUE* argv, VALUE self) {
+  VALUE index;
+  VALUE value;
+
+  rb_scan_args(argc, argv, "11", &index, &value);
+
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+  double value_dbl;
+
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+
+  if(NIL_P(value)) {
+    // It's a get request:
+    ensure(CPhidgetAdvancedServo_getVelocityLimit(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, &value_dbl ));
+
+  } else {
+    // Set request
+    if ( (TYPE(value) != T_FLOAT) && (TYPE(value) != T_FIXNUM) )
+      rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_FLOAT);
+
+    value_dbl = NUM2DBL(value);
+
+    ensure(CPhidgetAdvancedServo_setVelocityLimit(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, value_dbl ));
+  }
+
+  return DBL2NUM(value_dbl);
+}
+
+VALUE advancedservo_position_max(int argc, VALUE* argv, VALUE self) {
+  VALUE index;
+  VALUE value;
+
+  rb_scan_args(argc, argv, "11", &index, &value);
+
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+  double value_dbl;
+
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+
+  if(NIL_P(value)) {
+    // It's a get request:
+    ensure(CPhidgetAdvancedServo_getPositionMax(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, &value_dbl ));
+
+  } else {
+    // Set request
+    if ( (TYPE(value) != T_FLOAT) && (TYPE(value) != T_FIXNUM) )
+      rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_FLOAT);
+
+    value_dbl = NUM2DBL(value);
+    ensure(CPhidgetAdvancedServo_setPositionMax(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, value_dbl ));
+  }
+
+  return DBL2NUM(value_dbl);
+}
+
+VALUE advancedservo_position_min(int argc, VALUE* argv, VALUE self) {
+  VALUE index;
+  VALUE value;
+
+  rb_scan_args(argc, argv, "11", &index, &value);
+
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+  double value_dbl;
+
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+
+  if(NIL_P(value)) {
+    // It's a get request:
+    ensure(CPhidgetAdvancedServo_getPositionMin(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, &value_dbl ));
+
+  } else {
+    // Set request
+    if ( (TYPE(value) != T_FLOAT) && (TYPE(value) != T_FIXNUM) )
+      rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_FLOAT);
+
+    value_dbl = NUM2DBL(value);
+
+    ensure(CPhidgetAdvancedServo_setPositionMin(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, value_dbl ));
+  }
+
+  return DBL2NUM(value_dbl);
+}
+
+VALUE advancedservo_is_speed_ramping(VALUE self, VALUE index) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+
+  int is_ret;
+  ensure(CPhidgetAdvancedServo_getSpeedRampingOn(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, &is_ret ));
+
+  return (is_ret == PTRUE) ? Qtrue : Qfalse;
+}
+
+VALUE advancedservo_is_engaged(VALUE self, VALUE index) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+
+  int is_ret;
+  ensure(CPhidgetAdvancedServo_getEngaged(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, &is_ret ));
+
+  return (is_ret == PTRUE) ? Qtrue : Qfalse;
+}
+
+VALUE advancedservo_is_stopped(VALUE self, VALUE index) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+
+  int is_ret;
+  ensure(CPhidgetAdvancedServo_getStopped(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, &is_ret ));
+
+  return (is_ret == PTRUE) ? Qtrue : Qfalse;
+}
+
+
+VALUE advancedservo_position_set(VALUE self, VALUE index, VALUE value) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+  if ( (TYPE(value) != T_FLOAT) && (TYPE(value) != T_FIXNUM) )
+    rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_FLOAT);
+
+  int index_int = FIX2INT(index);
+  double value_dbl = NUM2DBL(value);
+
+  double ret;
+  ensure(CPhidgetAdvancedServo_setPosition(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, value_dbl ));
+
+  return DBL2NUM(value_dbl);
+}
+
+VALUE advancedservo_speed_ramping_set(VALUE self, VALUE index, VALUE value) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+
+  int index_int = FIX2INT(index);
+  int value_int;
+
+  if (TYPE(value) == T_TRUE) 
+    value_int = PTRUE;
+  else if (TYPE(value) == T_FALSE)
+    value_int = PFALSE;
+  else
+    rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_BOOL);
+
+  ensure(CPhidgetAdvancedServo_setSpeedRampingOn(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, value_int ));
+
+  return (value_int == PTRUE) ? Qtrue : Qfalse;
+}
+
+VALUE advancedservo_engaged_set(VALUE self, VALUE index, VALUE value) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+  int value_int;
+
+  if (TYPE(value) == T_TRUE) 
+    value_int = PTRUE;
+  else if (TYPE(value) == T_FALSE)
+    value_int = PFALSE;
+  else
+    rb_raise(rb_eTypeError, MSG_VALUE_MUST_BE_BOOL);
+
+  ensure(CPhidgetAdvancedServo_setEngaged(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, value_int ));
+
+  return (value_int == PTRUE) ? Qtrue : Qfalse;
+}
+
+VALUE advancedservo_servo_parameters_set(VALUE self, VALUE index, VALUE min_us, VALUE max_us, VALUE degrees, VALUE velocity_max) {
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  if ( (TYPE(min_us) != T_FLOAT) && (TYPE(min_us) != T_FIXNUM) )
+    rb_raise(rb_eTypeError, MSG_SERVO_MIN_US_MUST_BE_FLOAT);
+
+  if ( (TYPE(max_us) != T_FLOAT) && (TYPE(max_us) != T_FIXNUM) )
+    rb_raise(rb_eTypeError, MSG_SERVO_MAX_US_MUST_BE_FLOAT);
+
+  if ( (TYPE(degrees) != T_FLOAT) && (TYPE(degrees) != T_FIXNUM) )
+    rb_raise(rb_eTypeError, MSG_SERVO_DEGREES_MUST_BE_FLOAT);
+
+  if ( (TYPE(velocity_max) != T_FLOAT) && (TYPE(velocity_max) != T_FIXNUM) )
+    rb_raise(rb_eTypeError, MSG_SERVO_VELOCITY_MAX_MUST_BE_FLOAT);
+
+  int index_int = FIX2INT(index);
+  double min_us_dbl = NUM2DBL(min_us);
+  double max_us_dbl = NUM2DBL(max_us);
+  double degrees_dbl = NUM2DBL(degrees);
+  double velocity_max_dbl = NUM2DBL(velocity_max);
+
+  ensure(CPhidgetAdvancedServo_setServoParameters(
+    (CPhidgetAdvancedServoHandle)info->handle, index_int, min_us_dbl, max_us_dbl, 
+    degrees_dbl, velocity_max_dbl ));
+
+  return Qnil;
+}
+
+VALUE advancedservo_servo_type(int argc, VALUE* argv, VALUE self) {
+  VALUE index;
+  VALUE value;
+
+  rb_scan_args(argc, argv, "11", &index, &value);
+
+  if (TYPE(index) != T_FIXNUM) rb_raise(rb_eTypeError, MSG_INDEX_MUST_BE_FIXNUM);
+
+  int index_int = FIX2INT(index);
+
+  PhidgetInfo *info = device_info(self);
+
+  if (!info->is_attached) return Qnil;
+
+  VALUE ret;
+  if(NIL_P(value)) {
+    // It's a get request:
+    CPhidget_ServoType servo_type;
+    ensure(CPhidgetAdvancedServo_getServoType(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, &servo_type ));
+
+    switch(servo_type) {
+      case PHIDGET_SERVO_DEFAULT:
+        ret = ID2SYM(rb_intern("default"));
+        break;
+      case PHIDGET_SERVO_RAW_us_MODE:
+        ret = ID2SYM(rb_intern("raw_us_mode"));
+        break;
+      case PHIDGET_SERVO_HITEC_HS322HD:
+        ret = ID2SYM(rb_intern("hitec_hs322hd"));
+        break;
+      case PHIDGET_SERVO_HITEC_HS5245MG:
+        ret = ID2SYM(rb_intern("hitec_hs5245mg"));
+        break;
+      case PHIDGET_SERVO_HITEC_805BB:
+        ret = ID2SYM(rb_intern("hitec_805bb"));
+        break;
+      case PHIDGET_SERVO_HITEC_HS422:
+        ret = ID2SYM(rb_intern("hitec_hs422"));
+        break;
+      case PHIDGET_SERVO_TOWERPRO_MG90:
+        ret = ID2SYM(rb_intern("towerpro_mg90"));
+        break;
+      case PHIDGET_SERVO_HITEC_HSR1425CR:
+        ret = ID2SYM(rb_intern("hitec_hsr1425cr"));
+        break;
+      case PHIDGET_SERVO_HITEC_HS785HB:
+        ret = ID2SYM(rb_intern("hitec_hs785hb"));
+        break;
+      case PHIDGET_SERVO_HITEC_HS485HB:
+        ret = ID2SYM(rb_intern("hitec_hs485hb"));
+        break;
+      case PHIDGET_SERVO_HITEC_HS645MG:
+        ret = ID2SYM(rb_intern("hitec_hs645mg"));
+        break;
+      case PHIDGET_SERVO_HITEC_815BB:
+        ret = ID2SYM(rb_intern("hitec_815bb"));
+        break;
+      case PHIDGET_SERVO_FIRGELLI_L12_30_50_06_R:
+        ret = ID2SYM(rb_intern("firgelli_l12_30_50_06_r"));
+        break;
+      case PHIDGET_SERVO_FIRGELLI_L12_50_100_06_R:
+        ret = ID2SYM(rb_intern("firgelli_l12_50_100_06_r"));
+        break;
+      case PHIDGET_SERVO_FIRGELLI_L12_50_210_06_R:
+        ret = ID2SYM(rb_intern("firgelli_l12_50_210_06_r"));
+        break;
+      case PHIDGET_SERVO_FIRGELLI_L12_100_50_06_R:
+        ret = ID2SYM(rb_intern("firgelli_l12_100_50_06_r"));
+        break;
+      case PHIDGET_SERVO_FIRGELLI_L12_100_100_06_R:
+        ret = ID2SYM(rb_intern("firgelli_l12_100_100_06_r"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S2313M:
+        ret = ID2SYM(rb_intern("springrc_sm_s2313m"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S3317M:
+        ret = ID2SYM(rb_intern("springrc_sm_s3317m"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S3317SR:
+        ret = ID2SYM(rb_intern("springrc_sm_s3317sr"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S4303R:
+        ret = ID2SYM(rb_intern("springrc_sm_s4303r"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S4315M:
+        ret = ID2SYM(rb_intern("springrc_sm_s4315m"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S4315R:
+        ret = ID2SYM(rb_intern("springrc_sm_s4315r"));
+        break;
+      case PHIDGET_SERVO_SPRINGRC_SM_S4505B:
+        ret = ID2SYM(rb_intern("springrc_sm_s4505b"));
+        break;
+      default:
+        ret = ID2SYM(rb_intern("unknown"));
+        break;
+    }
+
+  } else {
+    // Set request
+    if (TYPE(value) != T_SYMBOL) rb_raise(rb_eTypeError, MSG_TYPE_MUST_BE_SYMBOL);
+
+    ID type_id = SYM2ID(value);
+
+    CPhidget_ServoType phidget_type;
+
+    if (rb_intern("default") == type_id)
+      phidget_type = PHIDGET_SERVO_DEFAULT;
+    else if (rb_intern("raw_us_mode") == type_id)
+      phidget_type = PHIDGET_SERVO_RAW_us_MODE;
+    else if (rb_intern("hitec_hs322hd") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HS322HD;
+    else if (rb_intern("hitec_hs5245mg") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HS5245MG;
+    else if (rb_intern("hitec_805bb") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_805BB;
+    else if (rb_intern("hitec_hs422") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HS422;
+    else if (rb_intern("towerpro_mg90") == type_id)
+      phidget_type = PHIDGET_SERVO_TOWERPRO_MG90;
+    else if (rb_intern("hitec_hsr1425cr") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HSR1425CR;
+    else if (rb_intern("hitec_hs785hb") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HS785HB;
+    else if (rb_intern("hitec_hs485hb") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HS485HB;
+    else if (rb_intern("hitec_hs645mg") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_HS645MG;
+    else if (rb_intern("hitec_815bb") == type_id)
+      phidget_type = PHIDGET_SERVO_HITEC_815BB;
+    else if (rb_intern("firgelli_l12_30_50_06_r") == type_id)
+      phidget_type = PHIDGET_SERVO_FIRGELLI_L12_30_50_06_R;
+    else if (rb_intern("firgelli_l12_50_100_06_r") == type_id)
+      phidget_type = PHIDGET_SERVO_FIRGELLI_L12_50_100_06_R;
+    else if (rb_intern("firgelli_l12_50_210_06_r") == type_id)
+      phidget_type = PHIDGET_SERVO_FIRGELLI_L12_50_210_06_R;
+    else if (rb_intern("firgelli_l12_100_50_06_r") == type_id)
+      phidget_type = PHIDGET_SERVO_FIRGELLI_L12_100_50_06_R;
+    else if (rb_intern("firgelli_l12_100_100_06_r") == type_id)
+      phidget_type = PHIDGET_SERVO_FIRGELLI_L12_100_100_06_R;
+    else if (rb_intern("springrc_sm_s2313m") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S2313M;
+    else if (rb_intern("springrc_sm_s3317m") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S3317M;
+    else if (rb_intern("springrc_sm_s3317sr") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S3317SR;
+    else if (rb_intern("springrc_sm_s4303r") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S4303R;
+    else if (rb_intern("springrc_sm_s4315m") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S4315M;
+    else if (rb_intern("springrc_sm_s4315r") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S4315R;
+    else if (rb_intern("springrc_sm_s4505b") == type_id)
+      phidget_type = PHIDGET_SERVO_SPRINGRC_SM_S4505B;
+    else
+      rb_raise(rb_eTypeError, MSG_UNRECOGNIZED_SERVO_TYPE);
+
+    ensure(CPhidgetAdvancedServo_setServoType(
+      (CPhidgetAdvancedServoHandle)info->handle, index_int, phidget_type ));
+    
+    ret = value;
+  }
+
+  return ret;
+}

data/ext/phidgets_native/interfacekit.c

@@ -18,27 +18,36 @@ int CCONV interfacekit_on_attach(CPhidgetHandle phid, void *userptr) {
   ifkit_info->digital_input_states = ALLOC_N(int, ifkit_info->digital_input_count); 
   ifkit_info->analog_input_states = ALLOC_N(int, ifkit_info->analog_input_count); 
 
-  // Allocate our data_rate-related collections
+  if (ifkit_info->digital_input_count_prior != ifkit_info->digital_input_count) {
+    if(ifkit_info->digital_sample_rates) xfree(ifkit_info->digital_sample_rates);
+
+    ifkit_info->digital_sample_rates = ALLOC_N(SampleRate, ifkit_info->digital_input_count); 
+
+    memset(ifkit_info->digital_sample_rates, 0, sizeof(SampleRate) * ifkit_info->digital_input_count);
+  }
+
+  if (ifkit_info->digital_output_count_prior != ifkit_info->digital_output_count) {
+    if(ifkit_info->digital_output_states) xfree(ifkit_info->digital_output_states);
+
+    ifkit_info->digital_output_states = ALLOC_N(int, ifkit_info->digital_output_count); 
+
+    memset(ifkit_info->digital_output_states, 0, sizeof(int) * ifkit_info->digital_output_count);
+  }
+
   if (ifkit_info->analog_input_count_prior != ifkit_info->analog_input_count) {
     if(ifkit_info->data_rates) xfree(ifkit_info->data_rates);
     if(ifkit_info->data_rates_max) xfree(ifkit_info->data_rates_max);
     if(ifkit_info->data_rates_min) xfree(ifkit_info->data_rates_min);
     if(ifkit_info->sensor_change_triggers) xfree(ifkit_info->sensor_change_triggers);
-    if(ifkit_info->digital_sample_rates) xfree(ifkit_info->digital_sample_rates);
     if(ifkit_info->analog_sample_rates) xfree(ifkit_info->analog_sample_rates);
-    if(ifkit_info->digital_output_states) xfree(ifkit_info->digital_output_states);
 
     ifkit_info->data_rates = ALLOC_N(int, ifkit_info->analog_input_count);
     ifkit_info->data_rates_max = ALLOC_N(int, ifkit_info->analog_input_count);
     ifkit_info->data_rates_min = ALLOC_N(int, ifkit_info->analog_input_count);
     ifkit_info->sensor_change_triggers = ALLOC_N(int, ifkit_info->analog_input_count);
-    ifkit_info->digital_output_states = ALLOC_N(int, ifkit_info->digital_output_count); 
 
-    ifkit_info->digital_sample_rates = ALLOC_N(SampleRate, ifkit_info->digital_input_count); 
     ifkit_info->analog_sample_rates = ALLOC_N(SampleRate, ifkit_info->analog_input_count); 
 
-    memset(ifkit_info->digital_output_states, 0, sizeof(int) * ifkit_info->digital_output_count);
-    memset(ifkit_info->digital_sample_rates, 0, sizeof(SampleRate) * ifkit_info->digital_input_count);
     memset(ifkit_info->analog_sample_rates, 0, sizeof(SampleRate) * ifkit_info->analog_input_count);
 
     for(int i=0;i<ifkit_info->analog_input_count;i++) {
@@ -90,6 +99,8 @@ int CCONV interfacekit_on_detach(CPhidgetHandle phid, void *userptr) {
 
   // This is used to determine whethere to preserve the allocated memory on reattach:
   ifkit_info->analog_input_count_prior = ifkit_info->analog_input_count;
+  ifkit_info->digital_input_count_prior = ifkit_info->digital_input_count;
+  ifkit_info->digital_output_count_prior = ifkit_info->digital_output_count;
 
   // Free the polled resources:
   xfree(ifkit_info->digital_input_states);

data/ext/phidgets_native/interfacekit_ruby.c

@@ -262,15 +262,15 @@ VALUE interfacekit_initialize(VALUE self, VALUE serial) {
   CPhidgetInterfaceKitHandle interfacekit = 0;
   ensure(CPhidgetInterfaceKit_create(&interfacekit));
 
-  ensure(CPhidgetInterfaceKit_set_OnInputChange_Handler(interfacekit, interfacekit_on_digital_change, info));
-  ensure(CPhidgetInterfaceKit_set_OnSensorChange_Handler(interfacekit, interfacekit_on_analog_change, info));
-
   info->handle = (CPhidgetHandle)interfacekit;
   info->on_type_attach = interfacekit_on_attach;
   info->on_type_detach = interfacekit_on_detach;
   info->on_type_free = interfacekit_on_free;
   info->type_info = ifkit_info;
 
+  ensure(CPhidgetInterfaceKit_set_OnInputChange_Handler(interfacekit, interfacekit_on_digital_change, info));
+  ensure(CPhidgetInterfaceKit_set_OnSensorChange_Handler(interfacekit, interfacekit_on_analog_change, info));
+
   return rb_call_super(1, &serial);
 }
 
@@ -286,6 +286,8 @@ VALUE interfacekit_close(VALUE self) {
 VALUE interfacekit_sensor_sample_rates(VALUE self) {
   InterfaceKitInfo *ifkit_info = device_type_info(self);
 
+  if (!ifkit_info->is_analog_input_count_known) return Qnil;
+
   int *rates_in_hz = ALLOC_N(int, ifkit_info->analog_input_count);
   for(int i=0; i<ifkit_info->analog_input_count; i++)
     rates_in_hz[i] = ifkit_info->analog_sample_rates[i].in_hz;
@@ -300,7 +302,9 @@ VALUE interfacekit_sensor_sample_rates(VALUE self) {
 VALUE interfacekit_input_sample_rates(VALUE self) {
   InterfaceKitInfo *ifkit_info = device_type_info(self);
 
-  int *rates_in_hz = ALLOC_N(int, ifkit_info->analog_input_count);
+  if (!ifkit_info->is_digital_input_count_known) return Qnil;
+
+  int *rates_in_hz = ALLOC_N(int, ifkit_info->digital_input_count);
   for(int i=0; i<ifkit_info->digital_input_count; i++)
     rates_in_hz[i] = ifkit_info->digital_sample_rates[i].in_hz;
 

data/ext/phidgets_native/phidgets_native.h

@@ -139,6 +139,8 @@ typedef struct interfacekit_info {
   // I use it to determine whether the input counts have changed between device
   // plug events.
   int analog_input_count_prior;
+  int digital_input_count_prior;
+  int digital_output_count_prior;
 
   bool is_ratiometric;
   int rationmetric_changed_usec;
@@ -158,6 +160,24 @@ typedef struct interfacekit_info {
 
 } InterfaceKitInfo;
 
+typedef struct advancedservo_info {
+  SampleRate *sample_rates;
+
+  bool is_motor_count_known;
+  int motor_count;
+  int motor_count_prior;
+
+  double *acceleration_max;
+  double *acceleration_min;
+  double *velocity_max;
+  double *velocity_min;
+
+  double *current;
+  double *position;
+  double *velocity;
+
+} AdvancedServoInfo;
+
 void Init_phidgets_native();
 void Init_phidgets_native_module();
 void Init_phidgets_native_device(VALUE m_Phidget);
@@ -200,7 +220,7 @@ VALUE phidget_disable_logging(VALUE class);
 VALUE phidget_log(VALUE class, VALUE log_level, VALUE message);
 VALUE phidget_all(VALUE class);
 
-// Phidget::Device
+// PhidgetsNative::Device
 PhidgetInfo *device_info(VALUE self);
 void *device_type_info(VALUE self);
 void device_free(PhidgetInfo *info);
@@ -221,7 +241,7 @@ VALUE device_label(VALUE self);
 VALUE device_serial_number(VALUE self);
 VALUE device_version(VALUE self);
 
-// Phidget::Spatial
+// PhidgetsNative::Spatial
 void spatial_on_free(void *type_info);
 int CCONV spatial_on_attach(CPhidgetHandle phid, void *userptr);
 int CCONV spatial_on_detach(CPhidgetHandle phid, void *userptr);
@@ -255,7 +275,7 @@ VALUE spatial_data_rate_max(VALUE self);
 VALUE spatial_data_rate_set(VALUE self, VALUE data_rate);
 VALUE spatial_data_rate_get(VALUE self);
 
-// Phidget::InterfaceKit
+// PhidgetsNative::InterfaceKit
 void interfacekit_on_free(void *type_info);
 int CCONV interfacekit_on_attach(CPhidgetHandle phid, void *userptr);
 int CCONV interfacekit_on_detach(CPhidgetHandle phid, void *userptr);
@@ -283,7 +303,7 @@ VALUE interfacekit_output_set(VALUE self, VALUE index, VALUE is_on);
 VALUE interfacekit_data_rate_set(VALUE self, VALUE index, VALUE rate);
 VALUE interfacekit_change_trigger_set(VALUE self, VALUE index, VALUE rate_thresh);
 
-// Phidget::Gps
+// PhidgetsNative::Gps
 void gps_on_free(void *type_info);
 int CCONV gps_on_attach(CPhidgetHandle phid, void *userptr);
 int CCONV gps_on_detach(CPhidgetHandle phidget, void *userptr);
@@ -300,6 +320,38 @@ VALUE gps_velocity(VALUE self);
 VALUE gps_is_fixed(VALUE self);
 VALUE gps_now_at_utc(VALUE self);
 
+// PhidgetsNative::AdvancedServo
+void advancedservo_on_free(void *type_info);
+int CCONV advancedservo_on_attach(CPhidgetHandle phid, void *userptr);
+int CCONV advancedservo_on_detach(CPhidgetHandle phid, void *userptr);
+int CCONV advancedservo_on_velocity_change(CPhidgetAdvancedServoHandle phid, void *userPtr, int index, double velocity);
+int CCONV advancedservo_on_position_change(CPhidgetAdvancedServoHandle phid, void *userPtr, int index, double position);
+int CCONV advancedservo_on_current_change(CPhidgetAdvancedServoHandle phid, void *userPtr, int index, double current);
+VALUE advancedservo_initialize(VALUE self, VALUE serial);
+VALUE advancedservo_close(VALUE self);
+VALUE advancedservo_motor_count(VALUE self);
+VALUE advancedservo_sample_rates(VALUE self);
+VALUE advancedservo_acceleration_max(VALUE self);
+VALUE advancedservo_acceleration_min(VALUE self);
+VALUE advancedservo_velocity_max(VALUE self);
+VALUE advancedservo_velocity_min(VALUE self);
+VALUE advancedservo_currents(VALUE self);
+VALUE advancedservo_positions(VALUE self);
+VALUE advancedservo_velocities(VALUE self);
+VALUE advancedservo_acceleration(int argc, VALUE* argv, VALUE self);
+VALUE advancedservo_velocity_limit(int argc, VALUE* argv, VALUE self);
+VALUE advancedservo_position_max(int argc, VALUE* argv, VALUE self);
+VALUE advancedservo_position_min(int argc, VALUE* argv, VALUE self);
+VALUE advancedservo_servo_type(int argc, VALUE* argv, VALUE self);
+VALUE advancedservo_position_set(VALUE self, VALUE index, VALUE value);
+VALUE advancedservo_is_speed_ramping(VALUE self, VALUE index);
+VALUE advancedservo_speed_ramping_set(VALUE self, VALUE index, VALUE value);
+VALUE advancedservo_is_engaged(VALUE self, VALUE index);
+VALUE advancedservo_engaged_set(VALUE self, VALUE index, VALUE value);
+VALUE advancedservo_is_stopped(VALUE self, VALUE index);
+VALUE advancedservo_servo_parameters_set(VALUE self, VALUE index, VALUE min_us, VALUE max_us, VALUE degrees, VALUE velocity_max);
+
+
 // Stub initializers:
 VALUE accelerometer_initialize(VALUE self, VALUE serial);
 VALUE advancedservo_initialize(VALUE self, VALUE serial);

data/phidgets_native.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name    = "phidgets_native"
-  s.version = "0.1.0"
+  s.version = "0.2.0"
   s.summary = "Native C-extension gem for the Phidgets library in ruby"
   s.author  = "Chris DeRose"
   s.description = s.summary

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phidgets_native
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-24 00:00:00.000000000 Z
+date: 2013-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &70343382636480 !ruby/object:Gem::Requirement
+  requirement: &70163161506660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70343382636480
+  version_requirements: *70163161506660
 description: Native C-extension gem for the Phidgets library in ruby
 email: cderose@derosetechnologies.com
 executables: []
@@ -30,6 +30,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ext/phidgets_native/accelerometer_ruby.c
+- ext/phidgets_native/advancedservo.c
 - ext/phidgets_native/advancedservo_ruby.c
 - ext/phidgets_native/analog_ruby.c
 - ext/phidgets_native/bridge_ruby.c
@@ -58,6 +59,7 @@ files:
 - ext/phidgets_native/weightsensor_ruby.c
 - ext/phidgets_native/phidgets_native.h
 - ext/phidgets_native/extconf.rb
+- examples/advancedservo.rb
 - examples/gps.rb
 - examples/interface_kit.rb
 - examples/list_all.rb