phidgets 0.0.5 → 0.1.0

data/ext/phidgets/phidgets_servo.c

@@ -0,0 +1,276 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_servo_init(VALUE self);
+VALUE ph_servo_get_motor_count(VALUE self);
+VALUE ph_servo_get_position(VALUE self, VALUE index);
+VALUE ph_servo_get_position_min(VALUE self, VALUE index);
+VALUE ph_servo_get_position_max(VALUE self, VALUE index);
+VALUE ph_servo_set_position(VALUE self, VALUE index, VALUE position);
+VALUE ph_servo_get_engaged(VALUE self, VALUE index);
+VALUE ph_servo_set_engaged(VALUE self, VALUE index, VALUE engaged);
+VALUE ph_servo_get_servo_type(VALUE self, VALUE index);
+VALUE ph_servo_set_servo_type(VALUE self, VALUE index, VALUE type);
+VALUE ph_servo_set_servo_parameters(VALUE self, VALUE index, VALUE min_us, VALUE max_us, VALUE degrees);
+
+#ifdef PH_CALLBACK
+VALUE ph_servo_set_on_position_change_handler(VALUE self, VALUE handler);
+int ph_servo_on_position_change(CPhidgetServoHandle phid, void *userPtr, int index, double position);
+#endif
+
+
+VALUE Init_phidgets_servo(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_servo = rb_define_class_under(ph_module, "Servo", ph_common);
+
+  /* Default - This is what the servo API been historically used, originally based on the Futaba FP-S148 */
+  rb_define_const(ph_servo, "DEFAULT", INT2FIX(PHIDGET_SERVO_DEFAULT));
+  /* Raw us mode - all position, velocity, acceleration functions are specified in microseconds rather then degrees */
+  rb_define_const(ph_servo, "RAW_US_MODE", INT2FIX(PHIDGET_SERVO_RAW_us_MODE));
+  /* HiTec HS-322HD Standard \Servo */
+  rb_define_const(ph_servo, "HITEC_HS322HD", INT2FIX(PHIDGET_SERVO_HITEC_HS322HD));
+  /* HiTec HS-5245MG Digital Mini \Servo */
+  rb_define_const(ph_servo, "HITEC_HS5245MG", INT2FIX(PHIDGET_SERVO_HITEC_HS5245MG));
+  /* HiTec HS-805BB Mega Quarter Scale \Servo */
+  rb_define_const(ph_servo, "HITEC_805BB", INT2FIX(PHIDGET_SERVO_HITEC_805BB));
+  /* HiTec HS-422 Standard \Servo */
+  rb_define_const(ph_servo, "HITEC_HS422", INT2FIX(PHIDGET_SERVO_HITEC_HS422));
+  /* Tower Pro MG90 Micro \Servo */
+  rb_define_const(ph_servo, "TOWERPRO_MG90", INT2FIX(PHIDGET_SERVO_TOWERPRO_MG90));
+  /* HiTec HSR-1425CR Continuous Rotation \Servo */
+  rb_define_const(ph_servo, "HITEC_HSR1425CR", INT2FIX(PHIDGET_SERVO_HITEC_HSR1425CR));
+  /* HiTec HS-785HB Sail Winch \Servo */
+  rb_define_const(ph_servo, "HITEC_HS785HB", INT2FIX(PHIDGET_SERVO_HITEC_HS785HB));
+  /* HiTec HS-485HB Deluxe \Servo */
+  rb_define_const(ph_servo, "HITEC_HS485HB", INT2FIX(PHIDGET_SERVO_HITEC_HS485HB));
+  /* HiTec HS-645MG Ultra Torque \Servo */
+  rb_define_const(ph_servo, "HITEC_HS645MG", INT2FIX(PHIDGET_SERVO_HITEC_HS645MG));
+  /* HiTec HS-815BB Mega Sail \Servo */
+  rb_define_const(ph_servo, "HITEC_815BB", INT2FIX(PHIDGET_SERVO_HITEC_815BB));
+  /* Document-const:
+   * Firgelli L12 Linear Actuator 30mm 50\:1 */
+  rb_define_const(ph_servo, "FIRGELLI_L12_30_50_06_R", INT2FIX(PHIDGET_SERVO_FIRGELLI_L12_30_50_06_R));
+  /* Document-const:
+   * Firgelli L12 Linear Actuator 50mm 100\:1 */
+  rb_define_const(ph_servo, "FIRGELLI_L12_50_100_06_R", INT2FIX(PHIDGET_SERVO_FIRGELLI_L12_50_100_06_R));
+  /* Document-const:
+   * Firgelli L12 Linear Actuator 50mm 210\:1 */
+  rb_define_const(ph_servo, "FIRGELLI_L12_50_210_06_R", INT2FIX(PHIDGET_SERVO_FIRGELLI_L12_50_210_06_R));
+  /* Document-const:
+   * Firgelli L12 Linear Actuator 100mm 50\:1 */
+  rb_define_const(ph_servo, "FIRGELLI_L12_100_50_06_R", INT2FIX(PHIDGET_SERVO_FIRGELLI_L12_100_50_06_R));
+  /* Document-const:
+   * Firgelli L12 Linear Actuator 100mm 100\:1 */
+  rb_define_const(ph_servo, "FIRGELLI_L12_100_100_06_R", INT2FIX(PHIDGET_SERVO_FIRGELLI_L12_100_100_06_R));
+  /* SpringRC SM-S2313M Micro \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S2313M", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S2313M));
+  /* SpringRC SM-S3317M Small \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S3317M", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S3317M));
+  /* SpringRC SM-S3317SR Small Continuous Rotation \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S3317SR", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S3317SR));
+  /* SpringRC SM-S4303R Standard Continuous Rotation \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S4303R", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S4303R));
+  /* SpringRC SM-S4315M High Torque \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S4315M", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S4315M));
+  /* SpringRC SM-S4315R High Torque Continuous Rotation \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S4315R", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S4315R));
+  /* SpringRC SM-S4505B Standard \Servo */
+  rb_define_const(ph_servo, "SPRINGRC_SM_S4505B", INT2FIX(PHIDGET_SERVO_SPRINGRC_SM_S4505B));
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget Servo object.
+   */
+  rb_define_method(ph_servo, "initialize", ph_servo_init, 0);
+
+  /* Document-method: getMotorCount
+   * call-seq: getMotorCount -> count
+   *
+   * Gets the number of motors supported by this controller
+   */
+  rb_define_method(ph_servo, "getMotorCount", ph_servo_get_motor_count, 0);
+
+  /* Document-method: getPosition
+   * call-seq: getPosition(index) -> position
+   *
+   * Gets the current position of a motor.
+   */
+  rb_define_method(ph_servo, "getPosition", ph_servo_get_position, 1);
+
+  /* Document-method: getPositionMin
+   * call-seq: getPositionMin(index) -> min
+   *
+   * Gets the minimum position that a motor can go to.
+   */
+  rb_define_method(ph_servo, "getPositionMin", ph_servo_get_position_min, 1);
+
+  /* Document-method: getPositionMax
+   * call-seq: getPositionMax(index) -> max
+   *
+   * Gets the maximum position that a motor can go to.
+   */
+  rb_define_method(ph_servo, "getPositionMax", ph_servo_get_position_max, 1);
+
+  /* Document-method: setPosition
+   * call-seq: setPosition(index, position)
+   *
+   * Sets the position of a motor.
+   */
+  rb_define_method(ph_servo, "setPosition", ph_servo_set_position, 2);
+
+  /* Document-method: getEngaged
+   * call-seq: getEngaged(index) -> true or false
+   *
+   * Gets the engaged state of a motor. This is whether the motor is powered or not.
+   */
+  rb_define_method(ph_servo, "getEngaged", ph_servo_get_engaged, 1);
+
+  /* Document-method: setEngaged
+   * call-seq: setEngaged(index, state)
+   *
+   * Sets the engaged state of a motor. This is whether the motor is powered or not.
+   */
+  rb_define_method(ph_servo, "setEngaged", ph_servo_set_engaged, 2);
+
+  /* Document-method: getServoType
+   * call-seq: getServoType(index) -> servo_type
+   *
+   * Gets the servo type of a motor.
+   */
+  rb_define_method(ph_servo, "getServoType", ph_servo_get_servo_type, 1);
+
+  /* Document-method: setServoType
+   * call-seq: setServoType(index, servo_type)
+   *
+   * Sets the servo type of a motor.
+   */
+  rb_define_method(ph_servo, "setServoType", ph_servo_set_servo_type, 2);
+
+  /* Document-method: setServoParameters
+   * call-seq: setServoParameters(index, min_us, max_us, degrees)
+   *
+   * Sets the servo parameters of a motor.
+   */
+  rb_define_method(ph_servo, "setServoParameters", ph_servo_set_servo_parameters, 4);
+
+#ifdef PH_CALLBACK
+  rb_define_private_method(ph_servo, "ext_setOnPositionChangeHandler", ph_servo_set_on_position_change_handler, 1);
+#endif
+
+  rb_define_alias(ph_servo, "motor_count", "getMotorCount");
+  rb_define_alias(ph_servo, "position", "getPosition");
+  rb_define_alias(ph_servo, "position_min", "getPositionMin");
+  rb_define_alias(ph_servo, "position_max", "getPositionMax");
+  rb_define_alias(ph_servo, "set_position", "setPosition");
+  rb_define_alias(ph_servo, "engaged?", "getEngaged");
+  rb_define_alias(ph_servo, "set_engaged", "setEngaged");
+  rb_define_alias(ph_servo, "servo_type", "getServoType");
+  rb_define_alias(ph_servo, "set_servo_type", "setServoType");
+  rb_define_alias(ph_servo, "set_servo_parameters", "setServoParameters");
+
+  return ph_servo;
+}
+
+
+
+VALUE ph_servo_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetServo_create((CPhidgetServoHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_servo_get_motor_count(VALUE self) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetServo_getMotorCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_servo_get_position(VALUE self, VALUE index) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  double position;
+  ph_raise(CPhidgetServo_getPosition(handle, FIX2INT(index), &position));
+  return rb_float_new(position);
+}
+
+VALUE ph_servo_get_position_min(VALUE self, VALUE index) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  double position;
+  ph_raise(CPhidgetServo_getPositionMin(handle, FIX2INT(index), &position));
+  return rb_float_new(position);
+}
+
+VALUE ph_servo_get_position_max(VALUE self, VALUE index) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  double position;
+  ph_raise(CPhidgetServo_getPositionMax(handle, FIX2INT(index), &position));
+  return rb_float_new(position);
+}
+
+VALUE ph_servo_set_position(VALUE self, VALUE index, VALUE position) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  ph_raise(CPhidgetServo_setPosition(handle, FIX2INT(index), NUM2DBL(position)));
+  return Qnil;
+}
+
+VALUE ph_servo_get_engaged(VALUE self, VALUE index) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  int engaged;
+  ph_raise(CPhidgetServo_getEngaged(handle, FIX2INT(index), &engaged));
+  return engaged == PTRUE ? Qtrue : Qfalse;
+}
+
+VALUE ph_servo_set_engaged(VALUE self, VALUE index, VALUE engaged) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  ph_raise(CPhidgetServo_setEngaged(handle, FIX2INT(index), TYPE(engaged) == T_TRUE ? PTRUE : PFALSE));
+  return Qnil;
+}
+
+VALUE ph_servo_get_servo_type(VALUE self, VALUE index) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  CPhidget_ServoType type;
+  ph_raise(CPhidgetServo_getServoType(handle, FIX2INT(index), &type));
+  return INT2FIX(type);
+}
+
+VALUE ph_servo_set_servo_type(VALUE self, VALUE index, VALUE type) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  ph_raise(CPhidgetServo_setServoType(handle, FIX2INT(index), (CPhidget_ServoType)FIX2INT(type)));
+  return Qnil;
+}
+
+VALUE ph_servo_set_servo_parameters(VALUE self, VALUE index, VALUE min_us, VALUE max_us, VALUE degrees) {
+  CPhidgetServoHandle handle = (CPhidgetServoHandle)get_ph_handle(self);
+  ph_raise(CPhidgetServo_setServoParameters(handle, FIX2INT(index), NUM2DBL(min_us), NUM2DBL(max_us), NUM2DBL(degrees)));
+  return Qnil;
+}
+
+
+#ifdef PH_CALLBACK
+VALUE ph_servo_set_on_position_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callback_1;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetServo_set_OnPositionChange_Handler((CPhidgetServoHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetServo_set_OnPositionChange_Handler((CPhidgetServoHandle)ph->handle, ph_servo_on_position_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+int ph_servo_on_position_change(CPhidgetServoHandle phid, void *userPtr, int index, double position) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+#endif
+

data/ext/phidgets/phidgets_spatial.c

@@ -0,0 +1,369 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_spatial_init(VALUE self);
+VALUE ph_spatial_get_acceleration_axis_count(VALUE self);
+VALUE ph_spatial_get_gyro_axis_count(VALUE self);
+VALUE ph_spatial_get_compass_axis_count(VALUE self);
+VALUE ph_spatial_get_acceleration(VALUE self, VALUE index);
+VALUE ph_spatial_get_acceleration_min(VALUE self, VALUE index);
+VALUE ph_spatial_get_acceleration_max(VALUE self, VALUE index);
+VALUE ph_spatial_get_angular_rate(VALUE self, VALUE index);
+VALUE ph_spatial_get_angular_rate_min(VALUE self, VALUE index);
+VALUE ph_spatial_get_angular_rate_max(VALUE self, VALUE index);
+VALUE ph_spatial_get_magnetic_field(VALUE self, VALUE index);
+VALUE ph_spatial_get_magnetic_field_min(VALUE self, VALUE index);
+VALUE ph_spatial_get_magnetic_field_max(VALUE self, VALUE index);
+VALUE ph_spatial_get_data_rate(VALUE self);
+VALUE ph_spatial_get_data_rate_min(VALUE self);
+VALUE ph_spatial_get_data_rate_max(VALUE self);
+VALUE ph_spatial_set_data_rate(VALUE self, VALUE rate);
+VALUE ph_spatial_zero_gyro(VALUE self);
+VALUE ph_spatial_set_compass_correction_parameters(VALUE self, VALUE mag_field, VALUE offset0, VALUE offset1, VALUE offset2, VALUE gain0, VALUE gain1, VALUE gain2, VALUE T0, VALUE T1, VALUE T2, VALUE T3, VALUE T4, VALUE T5);
+VALUE ph_spatial_reset_compass_correction_parameters(VALUE self);
+
+#ifdef PH_CALLBACK
+VALUE ph_spatial_set_on_spatial_data_handler(VALUE self, VALUE handler);
+int ph_spatial_on_spatial_data(CPhidgetSpatialHandle phid, void *userPtr, CPhidgetSpatial_SpatialEventDataHandle *data, int data_count);
+#endif
+
+
+VALUE Init_phidgets_spatial(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_spatial = rb_define_class_under(ph_module, "Spatial", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget Spatial object.
+   */
+  rb_define_method(ph_spatial, "initialize", ph_spatial_init, 0);
+
+  /* Document-method: getAccelerationAxisCount
+   * call-seq: getAccelerationAxisCount -> count
+   *
+   * Gets the number of acceleration axes supplied by this board.
+   */
+  rb_define_method(ph_spatial, "getAccelerationAxisCount", ph_spatial_get_acceleration_axis_count, 0);
+
+  /* Document-method: getGyroAxisCount
+   * call-seq: getGyroAxisCount -> count
+   *
+   * Gets the number of gyroscope axes supplied by this board.
+   */
+  rb_define_method(ph_spatial, "getGyroAxisCount", ph_spatial_get_gyro_axis_count, 0);
+
+  /* Document-method: getCompassAxisCount
+   * call-seq: getCompassAxisCount -> count
+   *
+   * Gets the number of compass axes supplied by this board.
+   */
+  rb_define_method(ph_spatial, "getCompassAxisCount", ph_spatial_get_compass_axis_count, 0);
+
+  /* Document-method: getAcceleration
+   * call-seq: getAcceleration(index) -> acceleration
+   *
+   * Gets the current acceleration of an axis.
+   */
+  rb_define_method(ph_spatial, "getAcceleration", ph_spatial_get_acceleration, 1);
+
+  /* Document-method: getAccelerationMin
+   * call-seq: getAccelerationMin(index) -> acceleration
+   *
+   * Gets the minimum acceleration supported by an axis.
+   */
+  rb_define_method(ph_spatial, "getAccelerationMin", ph_spatial_get_acceleration_min, 1);
+
+  /* Document-method: getAccelerationMax
+   * call-seq: getAccelerationMax(index) -> acceleration
+   *
+   * Gets the maximum accleration supported by an axis.
+   */
+  rb_define_method(ph_spatial, "getAccelerationMax", ph_spatial_get_acceleration_max, 1);
+
+  /* Document-method: getAngularRate
+   * call-seq: getAngularRate(index) -> rate
+   *
+   * Gets the current angular rate of an axis.
+   */
+  rb_define_method(ph_spatial, "getAngularRate", ph_spatial_get_angular_rate, 1);
+
+  /* Document-method: getAngularRateMin
+   * call-seq: getAngularRateMin(index) -> rate
+   *
+   * Gets the minimum angular rate supported by an axis.
+   */
+  rb_define_method(ph_spatial, "getAngularRateMin", ph_spatial_get_angular_rate_min, 1);
+
+  /* Document-method: getAngularRateMax
+   * call-seq: getAngularRateMax(index) -> rate
+   *
+   * Gets the maximum angular rate supported by an axis.
+   */
+  rb_define_method(ph_spatial, "getAngularRateMax", ph_spatial_get_angular_rate_max, 1);
+
+  /* Document-method: getMagneticField
+   * call-seq: getMagneticField(index) -> field
+   *
+   * Gets the current magnetic field stregth of an axis.
+   */
+  rb_define_method(ph_spatial, "getMagneticField", ph_spatial_get_magnetic_field, 1);
+
+  /* Document-method: getMagneticFieldMin
+   * call-seq: getMagneticFieldMin(index) -> field
+   *
+   * Gets the minimum magnetic field stregth supported by an axis.
+   */
+  rb_define_method(ph_spatial, "getMagneticFieldMin", ph_spatial_get_magnetic_field_min, 1);
+
+  /* Document-method: getMagneticFieldMax
+   * call-seq: getMagneticFieldMax(index) -> field
+   *
+   * Gets the maximum magnetic field stregth supported by an axis.
+   */
+  rb_define_method(ph_spatial, "getMagneticFieldMax", ph_spatial_get_magnetic_field_max, 1);
+
+  /* Document-method: getDataRate
+   * call-seq: getDataRate -> rate
+   *
+   * Get the data rate in milliseconds.
+   */
+  rb_define_method(ph_spatial, "getDataRate", ph_spatial_get_data_rate, 0);
+
+  /* Document-method: getDataRateMin
+   * call-seq: getDataRateMin -> rate
+   *
+   * Gets the minimum supported data rate in milliseconds.
+   */
+  rb_define_method(ph_spatial, "getDataRateMin", ph_spatial_get_data_rate_min, 0);
+
+  /* Document-method: getDataRateMax
+   * call-seq: getDataRateMax -> rate
+   *
+   * Gets the maximum supported data rate in milliseconds.
+   */
+  rb_define_method(ph_spatial, "getDataRateMax", ph_spatial_get_data_rate_max, 0);
+
+  /* Document-method: setDataRate
+   * call-seq: setDataRate(rate)
+   *
+   * Sets the data rate in milliseconds.
+   */
+  rb_define_method(ph_spatial, "setDataRate", ph_spatial_set_data_rate, 1);
+
+  /* Document-method: zeroGyro
+   * call-seq: zeroGyro
+   *
+   * Zeroes the gyroscope. This takes about two seconds and the gyro zxes will report 0 during the process.
+   * This should only be called when the board is not moving.
+   */
+  rb_define_method(ph_spatial, "zeroGyro", ph_spatial_zero_gyro, 0);
+
+  /* Document-method: setCompassCorrectionParameters
+   * call-seq: setCompassCorrectionParameters(mag_field, offset0, offset1, offset2, gain0, gain1, gain2, T0, T1, T2, T3, T4, T5)
+   *
+   * Sets the compass correction factors. This can be used to correcting any sensor errors,
+   * including hard and soft iron offsets and sensor error factors.
+   */
+  rb_define_method(ph_spatial, "setCompassCorrectionParameters", ph_spatial_set_compass_correction_parameters, 13);
+
+  /* Document-method: resetCompassCorrectionParameters
+   * call-seq: resetCompassCorrectionParameters
+   *
+   * Resets the compass correction factors. Magnetic field data will be presented directly as reported by the sensor.
+   */
+  rb_define_method(ph_spatial, "resetCompassCorrectionParameters", ph_spatial_reset_compass_correction_parameters, 0);
+
+#ifdef PH_CALLBACK
+  rb_define_private_method(ph_spatial, "ext_setOnSpatialDataHandler", ph_spatial_set_on_spatial_data_handler, 1);
+#endif
+
+  rb_define_alias(ph_spatial, "acceleration_axis_count", "getAccelerationAxisCount");
+  rb_define_alias(ph_spatial, "gyro_axis_count", "getGyroAxisCount");
+  rb_define_alias(ph_spatial, "compass_axis_count", "getCompassAxisCount");
+  rb_define_alias(ph_spatial, "acceleration", "getAcceleration");
+  rb_define_alias(ph_spatial, "acceleration_min", "getAccelerationMin");
+  rb_define_alias(ph_spatial, "acceleration_max", "getAccelerationMax");
+  rb_define_alias(ph_spatial, "angular_rate", "getAngularRate");
+  rb_define_alias(ph_spatial, "angular_rate_min", "getAngularRateMin");
+  rb_define_alias(ph_spatial, "angular_rate_max", "getAngularRateMax");
+  rb_define_alias(ph_spatial, "magnetic_field", "getMagneticField");
+  rb_define_alias(ph_spatial, "magnetic_field_min", "getMagneticFieldMin");
+  rb_define_alias(ph_spatial, "magnetic_field_max", "getMagneticFieldMax");
+  rb_define_alias(ph_spatial, "data_rate", "getDataRate");
+  rb_define_alias(ph_spatial, "data_rate_min", "getDataRateMin");
+  rb_define_alias(ph_spatial, "data_rate_max", "getDataRateMax");
+  rb_define_alias(ph_spatial, "data_rate=", "setDataRate");
+  rb_define_alias(ph_spatial, "zero_gyro", "zeroGyro");
+  rb_define_alias(ph_spatial, "set_compass_correction_parameters", "setCompassCorrectionParameters");
+  rb_define_alias(ph_spatial, "reset_compass_correction_parameters", "resetCompassCorrectionParameters");
+
+  return ph_spatial;
+}
+
+
+
+VALUE ph_spatial_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetSpatial_create((CPhidgetSpatialHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_spatial_get_acceleration_axis_count(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetSpatial_getAccelerationAxisCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_spatial_get_gyro_axis_count(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetSpatial_getGyroAxisCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_spatial_get_compass_axis_count(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetSpatial_getCompassAxisCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_spatial_get_acceleration(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getAcceleration(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_acceleration_min(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getAccelerationMin(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_acceleration_max(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getAccelerationMax(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_angular_rate(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getAngularRate(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_angular_rate_min(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getAngularRateMin(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_angular_rate_max(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getAngularRateMax(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_magnetic_field(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getMagneticField(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_magnetic_field_min(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getMagneticFieldMin(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_magnetic_field_max(VALUE self, VALUE index) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  double value;
+  ph_raise(CPhidgetSpatial_getMagneticFieldMax(handle, FIX2INT(index), &value));
+  return rb_float_new(value);
+}
+
+VALUE ph_spatial_get_data_rate(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  int value;
+  ph_raise(CPhidgetSpatial_getDataRate(handle, &value));
+  return INT2FIX(value);
+}
+
+VALUE ph_spatial_get_data_rate_min(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  int value;
+  ph_raise(CPhidgetSpatial_getDataRateMin(handle, &value));
+  return INT2FIX(value);
+}
+
+VALUE ph_spatial_get_data_rate_max(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  int value;
+  ph_raise(CPhidgetSpatial_getDataRateMax(handle, &value));
+  return INT2FIX(value);
+}
+
+VALUE ph_spatial_set_data_rate(VALUE self, VALUE milliseconds) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  ph_raise(CPhidgetSpatial_setDataRate(handle, FIX2INT(milliseconds)));
+  return Qnil;
+}
+
+VALUE ph_spatial_zero_gyro(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  ph_raise(CPhidgetSpatial_zeroGyro(handle));
+  return Qnil;
+}
+
+VALUE ph_spatial_set_compass_correction_parameters(VALUE self, VALUE mag_field, VALUE offset0, VALUE offset1, VALUE offset2, VALUE gain0, VALUE gain1, VALUE gain2, VALUE T0, VALUE T1, VALUE T2, VALUE T3, VALUE T4, VALUE T5) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  ph_raise(CPhidgetSpatial_setCompassCorrectionParameters(handle, NUM2DBL(mag_field), NUM2DBL(offset0), NUM2DBL(offset1), NUM2DBL(offset2),
+      NUM2DBL(gain0), NUM2DBL(gain1), NUM2DBL(gain2), NUM2DBL(T0), NUM2DBL(T1), NUM2DBL(T2), NUM2DBL(T3), NUM2DBL(T4), NUM2DBL(T5)));
+  return Qnil;
+}
+
+VALUE ph_spatial_reset_compass_correction_parameters(VALUE self) {
+  CPhidgetSpatialHandle handle = (CPhidgetSpatialHandle)get_ph_handle(self);
+  ph_raise(CPhidgetSpatial_resetCompassCorrectionParameters(handle));
+  return Qnil;
+}
+
+
+#ifdef PH_CALLBACK
+VALUE ph_spatial_set_on_spatial_data_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callback_1;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetSpatial_set_OnSpatialData_Handler((CPhidgetSpatialHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetSpatial_set_OnSpatialData_Handler((CPhidgetSpatialHandle)ph->handle, ph_spatial_on_spatial_data, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+int ph_spatial_on_spatial_data(CPhidgetSpatialHandle phid, void *userPtr, CPhidgetSpatial_SpatialEventDataHandle *data, int data_count) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+#endif
+