phidgets 0.1.3 → 1.0.0

data/ext/phidgets/phidgets_capacitive_touch.c

@@ -0,0 +1,302 @@
+
+#include "phidgets.h"
+
+#define CAP_TOUCH_TOUCH_END_CALLBACK   0
+#define CAP_TOUCH_TOUCH_CALLBACK       1
+
+
+VALUE ph_capacitive_touch_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetCapacitiveTouch_create((PhidgetCapacitiveTouchHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_capacitive_touch_get_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetCapacitiveTouch_getDataInterval);
+}
+
+VALUE ph_capacitive_touch_set_data_interval(VALUE self, VALUE interval) {
+  ph_raise(PhidgetCapacitiveTouch_setDataInterval((PhidgetCapacitiveTouchHandle)get_ph_handle(self), NUM2UINT(interval)));
+  return Qnil;
+}
+
+VALUE ph_capacitive_touch_get_min_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetCapacitiveTouch_getMinDataInterval);
+}
+
+VALUE ph_capacitive_touch_get_max_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetCapacitiveTouch_getMaxDataInterval);
+}
+
+VALUE ph_capacitive_touch_get_is_touched(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), (phidget_get_bool_func)PhidgetCapacitiveTouch_getIsTouched);
+}
+
+VALUE ph_capacitive_touch_get_sensitivity(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getSensitivity);
+}
+
+VALUE ph_capacitive_touch_set_sensitivity(VALUE self, VALUE sensitivity) {
+  ph_raise(PhidgetCapacitiveTouch_setSensitivity((PhidgetCapacitiveTouchHandle)get_ph_handle(self), NUM2DBL(sensitivity)));
+  return Qnil;
+}
+
+VALUE ph_capacitive_touch_get_min_sensitivity(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getMinSensitivity);
+}
+
+VALUE ph_capacitive_touch_get_max_sensitivity(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getMaxSensitivity);
+}
+
+VALUE ph_capacitive_touch_get_touch_value(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getTouchValue);
+}
+
+VALUE ph_capacitive_touch_get_min_touch_value(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getMinTouchValue);
+}
+
+VALUE ph_capacitive_touch_get_max_touch_value(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getMaxTouchValue);
+}
+
+VALUE ph_capacitive_touch_get_touch_value_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getTouchValueChangeTrigger);
+}
+
+VALUE ph_capacitive_touch_set_touch_value_change_trigger(VALUE self, VALUE trigger) {
+  ph_raise(PhidgetCapacitiveTouch_setTouchValueChangeTrigger((PhidgetCapacitiveTouchHandle)get_ph_handle(self), NUM2DBL(trigger)));
+  return Qnil;
+}
+
+VALUE ph_capacitive_touch_get_min_touch_value_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getMinTouchValueChangeTrigger);
+}
+
+VALUE ph_capacitive_touch_get_max_touch_value_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetCapacitiveTouch_getMaxTouchValueChangeTrigger);
+}
+
+
+void CCONV ph_capacitive_touch_on_touch_end(PhidgetCapacitiveTouchHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = Qnil;
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
+}
+
+
+VALUE ph_capacitive_touch_set_on_touch_end_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[CAP_TOUCH_TOUCH_END_CALLBACK];
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
+    callback_data->exit = true;
+    ph_raise(PhidgetCapacitiveTouch_setOnTouchEndHandler((PhidgetCapacitiveTouchHandle)ph->handle, NULL, (void *)NULL));
+    sem_post(&callback_data->callback_called);
+  } else {
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(PhidgetCapacitiveTouch_setOnTouchEndHandler((PhidgetCapacitiveTouchHandle)ph->handle, ph_capacitive_touch_on_touch_end, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+void CCONV ph_capacitive_touch_on_touch(PhidgetCapacitiveTouchHandle phid, void *userPtr, double touch_value) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = DBL2NUM(touch_value);
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
+}
+
+
+VALUE ph_capacitive_touch_set_on_touch_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[CAP_TOUCH_TOUCH_CALLBACK];
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
+    callback_data->exit = true;
+    ph_raise(PhidgetCapacitiveTouch_setOnTouchHandler((PhidgetCapacitiveTouchHandle)ph->handle, NULL, (void *)NULL));
+    sem_post(&callback_data->callback_called);
+  } else {
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(PhidgetCapacitiveTouch_setOnTouchHandler((PhidgetCapacitiveTouchHandle)ph->handle, ph_capacitive_touch_on_touch, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+
+void Init_capacitive_touch() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_capacitive_touch = rb_define_class_under(ph_module, "CapacitiveTouch", ph_common);
+
+
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget CapacitiveTouch object.
+   */
+  rb_define_method(ph_capacitive_touch, "initialize", ph_capacitive_touch_init, 0);
+
+  /* Document-method: getDataInterval
+   * call-seq: getDataInterval -> interval
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another Touch event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between Touch events can also affected by the TouchValueChangeTrigger.
+   */
+  rb_define_method(ph_capacitive_touch, "getDataInterval", ph_capacitive_touch_get_data_interval, 0);
+  rb_define_alias(ph_capacitive_touch, "data_interval", "getDataInterval");
+
+  /* Document-method: setDataInterval
+   * call-seq: setDataInterval(interval)
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another Touch event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between Touch events can also affected by the TouchValueChangeTrigger.
+   */
+  rb_define_method(ph_capacitive_touch, "setDataInterval", ph_capacitive_touch_set_data_interval, 1);
+  rb_define_alias(ph_capacitive_touch, "data_interval=", "setDataInterval");
+
+  /* Document-method: getMinDataInterval
+   * call-seq: getMinDataInterval -> interval
+   *
+   * The minimum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_capacitive_touch, "getMinDataInterval", ph_capacitive_touch_get_min_data_interval, 0);
+  rb_define_alias(ph_capacitive_touch, "min_data_interval", "getMinDataInterval");
+
+  /* Document-method: getMaxDataInterval
+   * call-seq: getMaxDataInterval -> interval
+   *
+   * The maximum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_capacitive_touch, "getMaxDataInterval", ph_capacitive_touch_get_max_data_interval, 0);
+  rb_define_alias(ph_capacitive_touch, "max_data_interval", "getMaxDataInterval");
+
+  /* Document-method: getIsTouched
+   * call-seq: getIsTouched -> true or false
+   *
+   * The most recent touch state that the channel has reported.
+   */
+  rb_define_method(ph_capacitive_touch, "getIsTouched", ph_capacitive_touch_get_is_touched, 0);
+  rb_define_alias(ph_capacitive_touch, "is_touched?", "getIsTouched");
+
+  /* Document-method: getSensitivity
+   * call-seq: getSensitivity -> sensitivity
+   *
+   * Determines the sensitivity of all capacitive regions on the device.
+   * Higher values result in greater touch sensitivity.
+   * The sensitivity value is bounded by MinSensitivity and MaxSensitivity.
+   */
+  rb_define_method(ph_capacitive_touch, "getSensitivity", ph_capacitive_touch_get_sensitivity, 0);
+  rb_define_alias(ph_capacitive_touch, "sensitivity", "getSensitivity");
+
+  /* Document-method: setSensitivity
+   * call-seq: setSensitivity(sensitivity)
+   *
+   * Determines the sensitivity of all capacitive regions on the device.
+   * Higher values result in greater touch sensitivity.
+   * The sensitivity value is bounded by MinSensitivity and MaxSensitivity.
+   */
+  rb_define_method(ph_capacitive_touch, "setSensitivity", ph_capacitive_touch_set_sensitivity, 1);
+  rb_define_alias(ph_capacitive_touch, "sensitivity=", "setSensitivity");
+
+  /* Document-method: getMinSensitivity
+   * call-seq: getMinSensitivity -> sensitivity
+   *
+   * The minimum value that Sensitivity can be set to.
+   */
+  rb_define_method(ph_capacitive_touch, "getMinSensitivity", ph_capacitive_touch_get_min_sensitivity, 0);
+  rb_define_alias(ph_capacitive_touch, "min_sensitivity", "getMinSensitivity");
+
+  /* Document-method: getMaxSensitivity
+   * call-seq: getMaxSensitivity -> sensitivity
+   *
+   * The maximum value that Sensitivity can be set to.
+   */
+  rb_define_method(ph_capacitive_touch, "getMaxSensitivity", ph_capacitive_touch_get_max_sensitivity, 0);
+  rb_define_alias(ph_capacitive_touch, "max_sensitivity", "getMaxSensitivity");
+
+  /* Document-method: getTouchValue
+   * call-seq: getTouchValue -> touch_value
+   *
+   * The most recent touch value that the channel has reported.
+   * This will be 0 or 1 for button-type inputs, or a ratio between 0-1 for axis-type inputs.
+   * This value is bounded by MinTouchValue and MaxTouchValue
+   * The value is not reset when the touch ends.
+   */
+  rb_define_method(ph_capacitive_touch, "getTouchValue", ph_capacitive_touch_get_touch_value, 0);
+  rb_define_alias(ph_capacitive_touch, "touch_value", "getTouchValue");
+
+  /* Document-method: getMinTouchValue
+   * call-seq: getMinTouchValue -> touch_value
+   *
+   * The minimum value the Touch event will report.
+   */
+  rb_define_method(ph_capacitive_touch, "getMinTouchValue", ph_capacitive_touch_get_min_touch_value, 0);
+  rb_define_alias(ph_capacitive_touch, "min_touch_value", "getMinTouchValue");
+
+  /* Document-method: getMaxTouchValue
+   * call-seq: getMaxTouchValue -> touch_value
+   *
+   * The maximum value the Touch event will report.
+   */
+  rb_define_method(ph_capacitive_touch, "getMaxTouchValue", ph_capacitive_touch_get_max_touch_value, 0);
+  rb_define_alias(ph_capacitive_touch, "max_touch_value", "getMaxTouchValue");
+
+  /* Document-method: getTouchValueChangeTrigger
+   * call-seq: getTouchValueChangeTrigger -> trigger
+   *
+   * The channel will not issue a Touch event until the touch value has changed by the amount specified by the TouchValueChangeTrigger.
+   * Setting the TouchValueChangeTrigger to 0 will result in the channel firing events every DataInterval. This is useful for applications that implement their own data filtering.
+   */
+  rb_define_method(ph_capacitive_touch, "getTouchValueChangeTrigger", ph_capacitive_touch_get_touch_value_change_trigger, 0);
+  rb_define_alias(ph_capacitive_touch, "touch_value_change_trigger", "getTouchValueChangeTrigger");
+
+  /* Document-method: setTouchValueChangeTrigger
+   * call-seq: setTouchValueChangeTrigger(trigger)
+   *
+   * The channel will not issue a Touch event until the touch value has changed by the amount specified by the TouchValueChangeTrigger.
+   * Setting the TouchValueChangeTrigger to 0 will result in the channel firing events every DataInterval. This is useful for applications that implement their own data filtering.
+   */
+  rb_define_method(ph_capacitive_touch, "setTouchValueChangeTrigger", ph_capacitive_touch_set_touch_value_change_trigger, 1);
+  rb_define_alias(ph_capacitive_touch, "touch_value_change_trigger=", "setTouchValueChangeTrigger");
+
+  /* Document-method: getMinTouchValueChangeTrigger
+   * call-seq: getMinTouchValueChangeTrigger -> trigger
+   *
+   * The minimum value that TouchValueChangeTrigger can be set to.
+   */
+  rb_define_method(ph_capacitive_touch, "getMinTouchValueChangeTrigger", ph_capacitive_touch_get_min_touch_value_change_trigger, 0);
+  rb_define_alias(ph_capacitive_touch, "min_touch_value_change_trigger", "getMinTouchValueChangeTrigger");
+
+  /* Document-method: getMaxTouchValueChangeTrigger
+   * call-seq: getMaxTouchValueChangeTrigger -> trigger
+   *
+   * The maximum value that TouchValueChangeTrigger can be set to.
+   */
+  rb_define_method(ph_capacitive_touch, "getMaxTouchValueChangeTrigger", ph_capacitive_touch_get_max_touch_value_change_trigger, 0);
+  rb_define_alias(ph_capacitive_touch, "max_touch_value_change_trigger", "getMaxTouchValueChangeTrigger");
+
+
+  rb_define_private_method(ph_capacitive_touch, "ext_setOnTouchEndHandler", ph_capacitive_touch_set_on_touch_end_handler, 1);
+  rb_define_private_method(ph_capacitive_touch, "ext_setOnTouchHandler", ph_capacitive_touch_set_on_touch_handler, 1);
+}
+

data/ext/phidgets/phidgets_common.c

@@ -2,370 +2,287 @@
 #include "phidgets.h"
 
 
-VALUE ph_common_allocate(VALUE klass);
-void  ph_common_free(ph_data_t *ph);
-VALUE ph_common_open(VALUE self, VALUE serial_number);
-VALUE ph_common_open_label(VALUE self, VALUE label);
-VALUE ph_common_open_remote(VALUE self, VALUE serial_number, VALUE server_id, VALUE password);
-VALUE ph_common_open_label_remote(VALUE self, VALUE label, VALUE server_id, VALUE password);
-VALUE ph_common_open_remote_ip(VALUE self, VALUE serial_number, VALUE address, VALUE port, VALUE password);
-VALUE ph_common_open_label_remote_ip(VALUE self, VALUE label, VALUE address, VALUE port, VALUE password);
-VALUE ph_common_wait_for_attachment(VALUE self, VALUE milliseconds);
-VALUE ph_common_close(VALUE self);
-VALUE ph_common_get_device_class(VALUE self);
-VALUE ph_common_get_device_id(VALUE self);
-VALUE ph_common_get_device_type(VALUE self);
-VALUE ph_common_get_device_name(VALUE self);
-VALUE ph_common_get_serial_number(VALUE self);
-VALUE ph_common_get_device_version(VALUE self);
-VALUE ph_common_get_device_status(VALUE self);
-VALUE ph_common_get_device_label(VALUE self);
-VALUE ph_common_set_device_label(VALUE self, VALUE label);
-VALUE ph_common_get_server_id(VALUE self);
-VALUE ph_common_get_server_address(VALUE self);
-VALUE ph_common_get_server_status(VALUE self);
-
-#ifdef PH_CALLBACK
-VALUE ph_common_set_on_attach_handler(VALUE self, VALUE handler);
-VALUE ph_common_set_on_detach_handler(VALUE self, VALUE handler);
-VALUE ph_common_set_on_server_connect_handler(VALUE self, VALUE handler);
-VALUE ph_common_set_on_server_disconnect_handler(VALUE self, VALUE handler);
-int ph_common_on_attach(CPhidgetHandle phid, void *userPtr);
-int ph_common_on_detach(CPhidgetHandle phid, void *userPtr);
-int ph_common_on_server_connect(CPhidgetHandle phid, void *userPtr);
-int ph_common_on_server_disconnect(CPhidgetHandle phid, void *userPtr);
-#endif
+void ph_common_free(ph_data_t *ph) {
+  if (ph && ph->handle) {
+    Phidget_close(ph->handle);
+    Phidget_delete(&ph->handle);
+    ph->handle = NULL;
+  }
+  if(ph) {
+    sem_destroy(&ph->attach_callback.handler_ready);
+    sem_destroy(&ph->attach_callback.callback_called);
+    sem_destroy(&ph->detach_callback.handler_ready);
+    sem_destroy(&ph->detach_callback.callback_called);
+    sem_destroy(&ph->error_callback.handler_ready);
+    sem_destroy(&ph->error_callback.callback_called);
+    sem_destroy(&ph->property_change_callback.handler_ready);
+    sem_destroy(&ph->property_change_callback.callback_called);
+    sem_destroy(&ph->dev_callbacks[0].handler_ready);
+    sem_destroy(&ph->dev_callbacks[0].callback_called);
+    sem_destroy(&ph->dev_callbacks[1].handler_ready);
+    sem_destroy(&ph->dev_callbacks[1].callback_called);
+    sem_destroy(&ph->dev_callbacks[2].handler_ready);
+    sem_destroy(&ph->dev_callbacks[2].callback_called);
+    sem_destroy(&ph->dev_callbacks[3].handler_ready);
+    sem_destroy(&ph->dev_callbacks[3].callback_called);
+    xfree(ph);
+  }
+}
 
 
-void Init_common() {
-  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
-  VALUE ph_common = rb_define_class_under(ph_module, "Common", rb_cObject);
-  rb_define_alloc_func(ph_common, ph_common_allocate);
-  rb_define_private_method(ph_common, "ext_open", ph_common_open, 1);
+VALUE ph_common_allocate(VALUE klass) {
+  ph_data_t *ph;
+  VALUE self = Data_Make_Struct(klass, ph_data_t, 0, ph_common_free, ph);
+  memset(ph, 0, sizeof(ph_data_t));
+  sem_init(&ph->attach_callback.handler_ready, 0, 0);
+  sem_init(&ph->attach_callback.callback_called, 0, 0);
+  sem_init(&ph->detach_callback.handler_ready, 0, 0);
+  sem_init(&ph->detach_callback.callback_called, 0, 0);
+  sem_init(&ph->error_callback.handler_ready, 0, 0);
+  sem_init(&ph->error_callback.callback_called, 0, 0);
+  sem_init(&ph->property_change_callback.handler_ready, 0, 0);
+  sem_init(&ph->property_change_callback.callback_called, 0, 0);
+  sem_init(&ph->dev_callbacks[0].handler_ready, 0, 0);
+  sem_init(&ph->dev_callbacks[0].callback_called, 0, 0);
+  sem_init(&ph->dev_callbacks[1].handler_ready, 0, 0);
+  sem_init(&ph->dev_callbacks[1].callback_called, 0, 0);
+  sem_init(&ph->dev_callbacks[2].handler_ready, 0, 0);
+  sem_init(&ph->dev_callbacks[2].callback_called, 0, 0);
+  sem_init(&ph->dev_callbacks[3].handler_ready, 0, 0);
+  sem_init(&ph->dev_callbacks[3].callback_called, 0, 0);
+  return self;
+}
 
-  /* Document-method: openLabel
-   * call-seq: openLabel(label)
-   *
-   * Opens a Phidget by label.
-   */
-  rb_define_method(ph_common, "openLabel", ph_common_open_label, 1);
 
-  /* Document-method: openRemote
-   * call-seq: openRemote(serial, server_id, password)
-   *
-   * Opens a Phidget remotely by ServerID. Note that this requires Bonjour (mDNS) to be running on both the host and the server.
-   */
-  rb_define_method(ph_common, "openRemote", ph_common_open_remote, 3);
+VALUE ph_common_open(VALUE self) {
+  ph_raise(Phidget_open(get_ph_handle(self)));
+  return Qnil;
+}
 
-  /* Document-method: openLabelRemote
-   * call-seq: openLabelRemote(label, server_id, password)
-   *
-   * Opens a Phidget remotely by ServerID. Note that this requires Bonjour (mDNS) to be running on both the host and the server.
-   */
-  rb_define_method(ph_common, "openLabelRemote", ph_common_open_label_remote, 3);
+VALUE ph_common_open_wait_for_attachment(VALUE self, VALUE milliseconds) {
+  ph_raise(Phidget_openWaitForAttachment(get_ph_handle(self), NUM2UINT(milliseconds)));
+  return Qnil;
+}
 
-  /* Document-method: openRemoteIP
-   * call-seq: openRemoteIP(serial, address, port, password)
-   *
-   * Opens a Phidget remotely by address and port, with optional serial number.
-   */
-  rb_define_method(ph_common, "openRemoteIP", ph_common_open_remote_ip, 4);
+VALUE ph_common_get_attached(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), (phidget_get_bool_func)Phidget_getAttached);
+}
 
-  /* Document-method: openLabelRemoteIP
-   * call-seq: openLabelRemoteIP(label, address, port, password)
-   *
-   * Opens a Phidget remotely by address and port, with optional label.
-   */
-  rb_define_method(ph_common, "openLabelRemoteIP", ph_common_open_label_remote_ip, 4);
+VALUE ph_common_close(VALUE self) {
+  ph_raise(Phidget_close(get_ph_handle(self)));
+  return Qnil;
+}
 
-  /* Document-method: waitForAttachment
-   * call-seq: waitForAttachment(milliseconds)
-   *
-   * Waits for attachment to happen. This can be called right after calling open, as an alternative to using the attach handler.
-   */
-  rb_define_method(ph_common, "waitForAttachment", ph_common_wait_for_attachment, 1);
+VALUE ph_common_get_device_channel_count(VALUE self, VALUE channel_class) {
+  uint32_t count;
+  ph_raise(Phidget_getDeviceChannelCount(get_ph_handle(self), NUM2INT(channel_class), &count));
+  return UINT2NUM(count);
+}
 
-  /* Document-method: close
-   * call-seq: close
-   *
-   * Closes a Phidget.
-   */
-  rb_define_method(ph_common, "close", ph_common_close, 0);
+VALUE ph_common_get_device_class(VALUE self) {
+  return ph_get_int(get_ph_handle(self), (phidget_get_int_func)Phidget_getDeviceClass);
+}
 
-  /* Document-method: getDeviceClass
-   * call-seq: getDeviceClass -> device_class
-   *
-   * Gets the class of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceClass", ph_common_get_device_class, 0);
+VALUE ph_common_get_device_class_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), (phidget_get_string_func)Phidget_getDeviceClassName);
+}
 
-  /* Document-method: getDeviceID
-   * call-seq: getDeviceID -> device_id
-   *
-   * Gets the device ID of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceID", ph_common_get_device_id, 0);
+VALUE ph_common_get_device_id(VALUE self) {
+  return ph_get_int(get_ph_handle(self), (phidget_get_int_func)Phidget_getDeviceID);
+}
 
-  /* Document-method: getDeviceType
-   * call-seq: getDeviceType -> device_type
-   *
-   * Gets the type (class) of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceType", ph_common_get_device_type, 0);
+VALUE ph_common_get_device_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getDeviceName);
+}
 
-  /* Document-method: getDeviceName
-   * call-seq: getDeviceName -> device_name
-   *
-   * Gets the specific name of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceName", ph_common_get_device_name, 0);
+VALUE ph_common_get_device_serial_number(VALUE self) {
+  return ph_get_int(get_ph_handle(self), Phidget_getDeviceSerialNumber);
+}
 
-  /* Document-method: getSerialNumber
-   * call-seq: getSerialNumber -> serial_number
-   *
-   * Gets the serial number of a Phidget.
-   */
-  rb_define_method(ph_common, "getSerialNumber", ph_common_get_serial_number, 0);
+VALUE ph_common_set_device_serial_number(VALUE self, VALUE serial_number) {
+  ph_raise(Phidget_setDeviceSerialNumber(get_ph_handle(self), NUM2INT(serial_number)));
+  return Qnil;
+}
 
-  /* Document-method: getDeviceVersion
-   * call-seq: getDeviceVersion -> version
-   *
-   * Gets the firmware version of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceVersion", ph_common_get_device_version, 0);
+VALUE ph_common_get_device_sku(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getDeviceSKU);
+}
 
-  /* Document-method: getDeviceStatus
-   * call-seq: getDeviceStatus -> status
-   *
-   * Gets the attached status of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceStatus", ph_common_get_device_status, 0);
+VALUE ph_common_get_device_version(VALUE self) {
+  return ph_get_int(get_ph_handle(self), Phidget_getDeviceVersion);
+}
 
-  /* Document-method: getDeviceLabel
-   * call-seq: getDeviceLabel -> label
-   *
-   * Gets the label of a Phidget.
-   */
-  rb_define_method(ph_common, "getDeviceLabel", ph_common_get_device_label, 0);
+VALUE ph_common_get_device_label(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getDeviceLabel);
+}
 
-  /* Document-method: setDeviceLabel
-   * call-seq: setDeviceLabel(label)
-   *
-   * Sets the label of a Phidget. Note that this is not supported on very old Phidgets, and not yet supported in Windows.
-   */
-  rb_define_method(ph_common, "setDeviceLabel", ph_common_set_device_label, 1);
+VALUE ph_common_set_device_label(VALUE self, VALUE label) {
+  ph_raise(Phidget_setDeviceLabel(get_ph_handle(self), StringValueCStr(label)));
+  return Qnil;
+}
 
-  /* Document-method: getServerID
-   * call-seq: getServerID -> server_id
-   *
-   * Gets the server ID of a remotely opened Phidget. This will fail if the Phidget was opened locally.
-   */
-  rb_define_method(ph_common, "getServerID", ph_common_get_server_id, 0);
+VALUE ph_common_write_device_label(VALUE self, VALUE label) {
+  ph_raise(Phidget_writeDeviceLabel(get_ph_handle(self), StringValueCStr(label)));
+  return Qnil;
+}
 
-  /* Document-method: getServerAddress
-   * call-seq: getServerAddress -> [address, port]
-   *
-   * Gets the address and port of a remotely opened Phidget. This will fail if the Phidget was opened locally.
-   */
-  rb_define_method(ph_common, "getServerAddress", ph_common_get_server_address, 0);
+VALUE ph_common_get_channel(VALUE self) {
+  return ph_get_int(get_ph_handle(self), Phidget_getChannel);
+}
 
-  /* Document-method: getServerStatus
-   * call-seq: getServerStatus -> status
-   *
-   * Gets the connected to server status of a remotely opened Phidget. This will fail if the Phidget was opened locally.
-   */
-  rb_define_method(ph_common, "getServerStatus", ph_common_get_server_status, 0);
+VALUE ph_common_set_channel(VALUE self, VALUE channel) {
+  ph_raise(Phidget_setChannel(get_ph_handle(self), NUM2INT(channel)));
+  return Qnil;
+}
 
-#ifdef PH_CALLBACK
-  rb_define_private_method(ph_common, "ext_setOnAttachHandler", ph_common_set_on_attach_handler, 1);
-  rb_define_private_method(ph_common, "ext_setOnDetachHandler", ph_common_set_on_detach_handler, 1);
-  rb_define_private_method(ph_common, "ext_setOnServerConnectHandler", ph_common_set_on_server_connect_handler, 1);
-  rb_define_private_method(ph_common, "ext_setOnServerDisconnectHandler", ph_common_set_on_server_disconnect_handler, 1);
-#endif
-
-  rb_define_alias(ph_common, "open_label", "openLabel");
-  rb_define_alias(ph_common, "open_remote", "openRemote");
-  rb_define_alias(ph_common, "open_label_remote", "openLabelRemote");
-  rb_define_alias(ph_common, "open_remote_ip", "openRemoteIP");
-  rb_define_alias(ph_common, "open_label_remote_ip", "openLabelRemoteIP");
-  rb_define_alias(ph_common, "wait_for_attachment", "waitForAttachment");
-  rb_define_alias(ph_common, "device_class", "getDeviceClass");
-  rb_define_alias(ph_common, "device_id", "getDeviceID");
-  rb_define_alias(ph_common, "device_type", "getDeviceType");
-  rb_define_alias(ph_common, "device_name", "getDeviceName");
-  rb_define_alias(ph_common, "serial_number", "getSerialNumber");
-  rb_define_alias(ph_common, "device_version", "getDeviceVersion");
-  rb_define_alias(ph_common, "device_status", "getDeviceStatus");
-  rb_define_alias(ph_common, "device_label", "getDeviceLabel");
-  rb_define_alias(ph_common, "device_label=", "setDeviceLabel");
-  rb_define_alias(ph_common, "server_id", "getServerID");
-  rb_define_alias(ph_common, "server_address", "getServerAddress");
-  rb_define_alias(ph_common, "server_status", "getServerStatus");
+VALUE ph_common_get_channel_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getChannelName);
 }
 
+VALUE ph_common_get_channel_class(VALUE self) {
+  return ph_get_int(get_ph_handle(self), (phidget_get_int_func)Phidget_getChannelClass);
+}
 
+VALUE ph_common_get_channel_class_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getChannelClassName);
+}
 
-VALUE ph_common_allocate(VALUE klass) {
-  ph_data_t *ph;
-  VALUE self = Data_Make_Struct(klass, ph_data_t, 0, ph_common_free, ph);
-  memset(ph, 0, sizeof(ph_data_t));
-  return self;
+VALUE ph_common_get_channel_subclass(VALUE self) {
+  return ph_get_int(get_ph_handle(self), (phidget_get_int_func)Phidget_getChannelSubclass);
 }
 
-void ph_common_free(ph_data_t *ph) {
-  if (ph && ph->handle) {
-    CPhidget_close(ph->handle);
-    CPhidget_delete(ph->handle);
-    ph->handle = NULL;
-  }
-  if(ph) xfree(ph);
+VALUE ph_common_get_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), Phidget_getDataInterval);
 }
 
-VALUE ph_common_open(VALUE self, VALUE serial_number) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_open(handle, FIX2INT(serial_number)));
+VALUE ph_common_set_data_interval(VALUE self, VALUE interval) {
+  ph_raise(Phidget_setDataInterval(get_ph_handle(self), NUM2UINT(interval)));
   return Qnil;
 }
 
-VALUE ph_common_open_label(VALUE self, VALUE label) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_openLabel(handle, StringValueCStr(label)));
-  return Qnil;
+VALUE ph_common_get_hub_port(VALUE self) {
+  return ph_get_int(get_ph_handle(self), Phidget_getHubPort);
 }
 
-VALUE ph_common_open_remote(VALUE self, VALUE serial_number, VALUE server_id, VALUE password) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_openRemote(handle, FIX2INT(serial_number), StringValueCStr(server_id), StringValueCStr(password)));
+VALUE ph_common_set_hub_port(VALUE self, VALUE hub_port) {
+  ph_raise(Phidget_setHubPort(get_ph_handle(self), NUM2INT(hub_port)));
   return Qnil;
 }
 
-VALUE ph_common_open_label_remote(VALUE self, VALUE label, VALUE server_id, VALUE password) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_openLabelRemote(handle, StringValueCStr(label), StringValueCStr(server_id), StringValueCStr(password)));
-  return Qnil;
+VALUE ph_common_get_hub_port_count(VALUE self) {
+  return ph_get_int(get_ph_handle(self), Phidget_getHubPortCount);
 }
 
-VALUE ph_common_open_remote_ip(VALUE self, VALUE serial_number, VALUE address, VALUE port, VALUE password) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_openRemoteIP(handle, FIX2INT(serial_number), StringValueCStr(address), FIX2INT(port), StringValueCStr(password)));
-  return Qnil;
+VALUE ph_common_get_is_channel(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), Phidget_getIsChannel);
 }
 
-VALUE ph_common_open_label_remote_ip(VALUE self, VALUE label, VALUE address, VALUE port, VALUE password) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_openLabelRemoteIP(handle, StringValueCStr(label), StringValueCStr(address), FIX2INT(port), StringValueCStr(password)));
-  return Qnil;
+VALUE ph_common_get_is_hub_port_device(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), Phidget_getIsHubPortDevice);
 }
 
-VALUE ph_common_wait_for_attachment(VALUE self, VALUE milliseconds) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_waitForAttachment(handle, FIX2INT(milliseconds)));
+VALUE ph_common_set_is_hub_port_device(VALUE self, VALUE is_hub_port_device) {
+  ph_raise(Phidget_setIsHubPortDevice(get_ph_handle(self), TYPE(is_hub_port_device) == T_TRUE ? PTRUE : PFALSE));
   return Qnil;
 }
 
-VALUE ph_common_close(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_close(handle));
-  return Qnil;
+VALUE ph_common_get_is_local(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), Phidget_getIsLocal);
 }
 
-VALUE ph_common_get_device_class(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  CPhidget_DeviceClass device_class;
-  ph_raise(CPhidget_getDeviceClass(handle, &device_class));
-  return INT2FIX(device_class);
+VALUE ph_common_set_is_local(VALUE self, VALUE is_local) {
+  ph_raise(Phidget_setIsLocal(get_ph_handle(self), TYPE(is_local) == T_TRUE ? PTRUE : PFALSE));
+  return Qnil;
 }
 
-VALUE ph_common_get_device_id(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  CPhidget_DeviceID device_id;
-  ph_raise(CPhidget_getDeviceID(handle, &device_id));
-  return INT2FIX(device_id);
+VALUE ph_common_get_is_remote(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), Phidget_getIsRemote);
 }
 
-VALUE ph_common_get_device_type(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  const char *device_type;
-  ph_raise(CPhidget_getDeviceType(handle, &device_type));
-  return rb_str_new2(device_type);
+VALUE ph_common_set_is_remote(VALUE self, VALUE is_remote) {
+  ph_raise(Phidget_setIsRemote(get_ph_handle(self), TYPE(is_remote) == T_TRUE ? PTRUE : PFALSE));
+  return Qnil;
 }
 
-VALUE ph_common_get_device_name(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  const char *device_name;
-  ph_raise(CPhidget_getDeviceName(handle, &device_name));
-  return rb_str_new2(device_name);
+VALUE ph_common_get_server_hostname(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getServerHostname);
 }
 
-VALUE ph_common_get_serial_number(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  int serial;
-  ph_raise(CPhidget_getSerialNumber(handle, &serial));
-  return INT2FIX(serial);
+VALUE ph_common_get_server_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getServerName);
 }
 
-VALUE ph_common_get_device_version(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  int device_version;
-  ph_raise(CPhidget_getDeviceVersion(handle, &device_version));
-  return INT2FIX(device_version);
+VALUE ph_common_set_server_name(VALUE self, VALUE server_name) {
+  ph_raise(Phidget_setServerName(get_ph_handle(self), StringValueCStr(server_name)));
+  return Qnil;
 }
 
-VALUE ph_common_get_device_status(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  int device_status;
-  ph_raise(CPhidget_getDeviceStatus(handle, &device_status));
-  return INT2FIX(device_status);
+VALUE ph_common_get_server_peer_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getServerPeerName);
 }
 
-VALUE ph_common_get_device_label(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  const char *device_label;
-  ph_raise(CPhidget_getDeviceLabel(handle, &device_label));
-  return rb_str_new2(device_label);
+VALUE ph_common_get_server_unique_name(VALUE self) {
+  return ph_get_string(get_ph_handle(self), Phidget_getServerUniqueName);
 }
 
-VALUE ph_common_set_device_label(VALUE self, VALUE label) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  ph_raise(CPhidget_setDeviceLabel(handle, StringValueCStr(label)));
-  return Qnil;
+
+void CCONV ph_common_on_attach(PhidgetHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = Qnil;
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
 }
 
-VALUE ph_common_get_server_id(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  const char *server_id;
-  ph_raise(CPhidget_getServerID(handle, &server_id));
-  return rb_str_new2(server_id);
+
+void CCONV ph_common_on_detach(PhidgetHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = Qnil;
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
 }
 
-VALUE ph_common_get_server_address(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  const char *address;
-  int port;
-  ph_raise(CPhidget_getServerAddress(handle, &address, &port));
-  return rb_ary_new3(2, rb_str_new2(address), INT2FIX(port));
+
+void CCONV ph_common_on_error(PhidgetHandle phid, void *userPtr, Phidget_ErrorEventCode code, const char* description) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = INT2NUM(code);
+  callback_data->arg2 = rb_str_new2(description);
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
 }
 
-VALUE ph_common_get_server_status(VALUE self) {
-  CPhidgetHandle handle = get_ph_handle(self);
-  int server_status;
-  ph_raise(CPhidget_getServerStatus(handle, &server_status));
-  return INT2FIX(server_status);
+
+void CCONV ph_common_on_property_change(PhidgetHandle phid, void *userPtr, const char *propertyName) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = rb_str_new2(propertyName);
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
 }
 
-#ifdef PH_CALLBACK
+
 VALUE ph_common_set_on_attach_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
   ph_callback_data_t *callback_data = &ph->attach_callback;
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidget_set_OnAttach_Handler(ph->handle, NULL, (void *)NULL));
+    ph_raise(Phidget_setOnAttachHandler(ph->handle, NULL, (void *)NULL));
+    sem_post(&callback_data->callback_called);
   } else {
-    callback_data->called = false;
     callback_data->exit = false;
     callback_data->phidget = self;
     callback_data->callback = handler;
-    ph_raise(CPhidget_set_OnAttach_Handler(ph->handle, ph_common_on_attach, (void *)callback_data));
+    ph_raise(Phidget_setOnAttachHandler(ph->handle, ph_common_on_attach, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
@@ -375,79 +292,417 @@ VALUE ph_common_set_on_detach_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
   ph_callback_data_t *callback_data = &ph->detach_callback;
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidget_set_OnDetach_Handler(ph->handle, NULL, (void *)NULL));
+    ph_raise(Phidget_setOnDetachHandler(ph->handle, NULL, (void *)NULL));
+    sem_post(&callback_data->callback_called);
   } else {
-    callback_data->called = false;
     callback_data->exit = false;
     callback_data->phidget = self;
     callback_data->callback = handler;
-    ph_raise(CPhidget_set_OnDetach_Handler(ph->handle, ph_common_on_detach, (void *)callback_data));
+    ph_raise(Phidget_setOnDetachHandler(ph->handle, ph_common_on_detach, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
 }
 
-VALUE ph_common_set_on_server_connect_handler(VALUE self, VALUE handler) {
+VALUE ph_common_set_on_error_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
-  ph_callback_data_t *callback_data = &ph->server_connect_callback;
+  ph_callback_data_t *callback_data = &ph->error_callback;
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidget_set_OnServerConnect_Handler(ph->handle, NULL, (void *)NULL));
+    ph_raise(Phidget_setOnErrorHandler(ph->handle, NULL, (void *)NULL));
+    sem_post(&callback_data->callback_called);
   } else {
-    callback_data->called = false;
     callback_data->exit = false;
     callback_data->phidget = self;
     callback_data->callback = handler;
-    ph_raise(CPhidget_set_OnServerConnect_Handler(ph->handle, ph_common_on_server_connect, (void *)callback_data));
+    ph_raise(Phidget_setOnErrorHandler(ph->handle, ph_common_on_error, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
 }
 
-VALUE ph_common_set_on_server_disconnect_handler(VALUE self, VALUE handler) {
+VALUE ph_common_set_on_property_change_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
-  ph_callback_data_t *callback_data = &ph->server_disconnect_callback;
+  ph_callback_data_t *callback_data = &ph->property_change_callback;
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidget_set_OnServerDisconnect_Handler(ph->handle, NULL, (void *)NULL));
+    ph_raise(Phidget_setOnPropertyChangeHandler(ph->handle, NULL, (void *)NULL));
+    sem_post(&callback_data->callback_called);
   } else {
-    callback_data->called = false;
     callback_data->exit = false;
     callback_data->phidget = self;
     callback_data->callback = handler;
-    ph_raise(CPhidget_set_OnServerDisconnect_Handler(ph->handle, ph_common_on_server_disconnect, (void *)callback_data));
+    ph_raise(Phidget_setOnPropertyChangeHandler(ph->handle, ph_common_on_property_change, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
 }
 
 
-int ph_common_on_attach(CPhidgetHandle phid, void *userPtr) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
-}
+void Init_common() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_define_class_under(ph_module, "Common", rb_cObject);
+  rb_define_alloc_func(ph_common, ph_common_allocate);
 
+  /* Document-method: open
+   * call-seq: open
+   *
+   * Opens the Phidget channel. The specific channel to be opened can be specified by setting any of the following properties:
+   *    DeviceSerialNumber
+   *    DeviceLabel
+   *    Channel
+   *    HubPort
+   *    IsHubPortDevice
+   *    ServerName
+   *    IsLocal
+   *    IsRemote
+   *
+   * open will return immediately, with the attachment process proceeding asynchronously. Use the Attach event or Attached property to determine when the channel is ready to use.
+   */
+  rb_define_method(ph_common, "open", ph_common_open, 0);
 
-int ph_common_on_detach(CPhidgetHandle phid, void *userPtr) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
-}
+  /* Document-method: openWaitForAttachment
+   * call-seq: openWaitForAttachment(milliseconds)
+   *
+   * Opens the Phidget channel and waits a defined amount of time for the device to attach.The specific channel to be opened can be specified by setting any of the following properties:
+   *    DeviceSerialNumber
+   *    DeviceLabel
+   *    Channel
+   *    HubPort
+   *    IsHubPortDevice
+   *    ServerName
+   *    IsLocal
+   *    IsRemote
+   *
+   * openWaitForAttachment will block until the channel is attached or a timeout occurs. A timeout value of 0 will wait forever.
+   */
+  rb_define_method(ph_common, "openWaitForAttachment", ph_common_open_wait_for_attachment, 1);
+  rb_define_alias(ph_common, "open_wait_for_attachment", "openWaitForAttachment");
 
+  /* Document-method: getAttached
+   * call-seq: getAttached -> status
+   *
+   * Gets the attached status of channel. A Phidget is attached after it has been opened and the Phidget library finds and connects to the corresponding hardware device.
+   */
+  rb_define_method(ph_common, "getAttached", ph_common_get_attached, 0);
+  rb_define_alias(ph_common, "attached?", "getAttached");
 
-int ph_common_on_server_connect(CPhidgetHandle phid, void *userPtr) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
-}
+  /* Document-method: close
+   * call-seq: close
+   *
+   * Closes a Phidget channel that has been opened.
+   */
+  rb_define_method(ph_common, "close", ph_common_close, 0);
 
+  /* Document-method: getDeviceChannelCount
+   * call-seq: getDeviceChannelCount(channel_class) -> channel_count
+   *
+   * Gets the number of channels of the specified channel class on the device. Pass Phidgets::CHCLASS_NOTHING to get the total number of channels.
+   */
+  rb_define_method(ph_common, "getDeviceChannelCount", ph_common_get_device_channel_count, 1);
+  rb_define_alias(ph_common, "device_channel_count", "getDeviceChannelCount");
 
-int ph_common_on_server_disconnect(CPhidgetHandle phid, void *userPtr) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
+  /* Document-method: getDeviceClass
+   * call-seq: getDeviceClass -> device_class
+   *
+   * Gets the device class for the Phidget which this channel is a part of.
+   */
+  rb_define_method(ph_common, "getDeviceClass", ph_common_get_device_class, 0);
+  rb_define_alias(ph_common, "device_class", "getDeviceClass");
+
+  /* Document-method: getDeviceClassName
+   * call-seq: getDeviceClassName -> device_class_name
+   *
+   * Gets the name of the device class for the Phidget which this channel is a part of.
+   */
+  rb_define_method(ph_common, "getDeviceClassName", ph_common_get_device_class_name, 0);
+  rb_define_alias(ph_common, "device_class_name", "getDeviceClassName");
+
+  /* Document-method: getDeviceID
+   * call-seq: getDeviceID -> device_id
+   *
+   * Gets the DeviceID for the Phidget which this channel is a part of.
+   */
+  rb_define_method(ph_common, "getDeviceID", ph_common_get_device_id, 0);
+  rb_define_alias(ph_common, "device_id", "getDeviceID");
+
+  /* Document-method: getDeviceName
+   * call-seq: getDeviceName -> device_name
+   *
+   * Gets the name of the Phidget which this channel is a part of.
+   */
+  rb_define_method(ph_common, "getDeviceName", ph_common_get_device_name, 0);
+  rb_define_alias(ph_common, "device_name", "getDeviceName");
+
+  /* Document-method: getDeviceSerialNumber
+   * call-seq: getDeviceSerialNumber -> serial_number
+   *
+   * Gets the serial number of the Phidget which this channel is a part of.
+   * If the channel is part of a VINT device, this will be the serial number of the VINT Hub the device is attached to.
+   */
+  rb_define_method(ph_common, "getDeviceSerialNumber", ph_common_get_device_serial_number, 0);
+  rb_define_alias(ph_common, "device_serial_number", "getDeviceSerialNumber");
+
+  /* Document-method: setDeviceSerialNumber
+   * call-seq: setDeviceSerialNumber(serial_number)
+   *
+   * Specifies the serial number of the Phidget to be opened. Leave un-set, or set to Phidgets::SERIALNUMBER_ANY to open any serial number.
+   * If the channel is part of a VINT device, this will be the serial number of the VINT Hub the device is attached to.
+   *
+   * If setting this property, it must be set before the channel is opened. The behaviour of setting this property while the channel is open is undefined.
+   */
+  rb_define_method(ph_common, "setDeviceSerialNumber", ph_common_set_device_serial_number, 1);
+  rb_define_alias(ph_common, "device_serial_number=", "setDeviceSerialNumber");
+
+  /* Document-method: getDeviceSKU
+   * call-seq: getDeviceSKU -> device_sku
+   *
+   * Gets the SKU (part number) of the Phidget which this channel is a part of.
+   */
+  rb_define_method(ph_common, "getDeviceSKU", ph_common_get_device_sku, 0);
+  rb_define_alias(ph_common, "device_sku", "getDeviceSKU");
+
+  /* Document-method: getDeviceVersion
+   * call-seq: getDeviceVersion -> version
+   *
+   * Gets the firmware version of the Phidget which this channel is a part of.
+   */
+  rb_define_method(ph_common, "getDeviceVersion", ph_common_get_device_version, 0);
+  rb_define_alias(ph_common, "device_version", "getDeviceVersion");
+
+  /* Document-method: getDeviceLabel
+   * call-seq: getDeviceLabel -> label
+   *
+   * Gets the label of the Phidget which this channel is a part of. A device label is a custom string used to more easily identify a Phidget.
+   * Labels are written to a Phidget using writeDeviceLabel().
+   */
+  rb_define_method(ph_common, "getDeviceLabel", ph_common_get_device_label, 0);
+  rb_define_alias(ph_common, "device_label", "getDeviceLabel");
+
+  /* Document-method: setDeviceLabel
+   * call-seq: setDeviceLabel(label)
+   *
+   * Specifies the label of the Phidget to be opened. Leave un-set to open any label. A device label is a custom string used to more easily identify a Phidget.
+   * Labels are written to a Phidget using writeDeviceLabel().
+   */
+  rb_define_method(ph_common, "setDeviceLabel", ph_common_write_device_label, 1);
+  rb_define_alias(ph_common, "device_label=", "setDeviceLabel");
+
+  /* Document-method: writeDeviceLabel
+   * call-seq: writeDeviceLabel(label)
+   *
+   * Writes a label to the device in the form of a string in the device flash memory. This label can then be used to identify the device, and will persist across power cycles.
+   */
+  rb_define_method(ph_common, "writeDeviceLabel", ph_common_write_device_label, 1);
+  rb_define_alias(ph_common, "write_device_label", "writeDeviceLabel");
+
+  /* Document-method: getChannel
+   * call-seq: getChannel -> channel
+   *
+   * Gets the channel index of the channel on the device.
+   */
+  rb_define_method(ph_common, "getChannel", ph_common_get_channel, 0);
+  rb_define_alias(ph_common, "channel", "getChannel");
+
+  /* Document-method: setChannel
+   * call-seq: setChannel(channel)
+   *
+   * Specifies the channel index to be opened. The default channel is 0. Set to PHIDGET_CHANNEL_ANY to open any channel on the specified device.
+   * If setting this property, it must be set before the channel is opened. The behaviour of setting this property while the channel is open is undefined.
+   */
+  rb_define_method(ph_common, "setChannel", ph_common_set_channel, 1);
+  rb_define_alias(ph_common, "channel=", "setChannel");
+
+  /* Document-method: getChannelName
+   * call-seq: getChannelName -> channel_name
+   *
+   * Gets the channel's name. This name serves as a description of the specific nature of the channel.
+   */
+  rb_define_method(ph_common, "getChannelName", ph_common_get_channel_name, 0);
+  rb_define_alias(ph_common, "channel_name", "getChannelName");
+
+  /* Document-method: getChannelClass
+   * call-seq: getChannelClass -> channel_class
+   *
+   * Gets the channel class of the channel.
+   */
+  rb_define_method(ph_common, "getChannelClass", ph_common_get_channel_class, 0);
+  rb_define_alias(ph_common, "channel_class", "getChannelClass");
+
+  /* Document-method: getChannelClassName
+   * call-seq: getChannelClassName -> channel_class_name
+   *
+   * Gets the name of the channel class the channel belongs to.
+   */
+  rb_define_method(ph_common, "getChannelClassName", ph_common_get_channel_class_name, 0);
+  rb_define_alias(ph_common, "channel_class_name", "getChannelClassName");
+
+  /* Document-method: getChannelSubclass
+   * call-seq: getChannelSubclass -> channel_subclass
+   *
+   * Gets the subclass for this channel. Allows for identifying channels with specific characteristics without needing to know the exact device and channel index.
+   */
+  rb_define_method(ph_common, "getChannelSubclass", ph_common_get_channel_subclass, 0);
+  rb_define_alias(ph_common, "channel_subclass", "getChannelSubclass");
+
+  /* Document-method: getDataInterval
+   * call-seq: getDataInterval -> data_interval
+   *
+   * Gets the data interval for any channel that supports one. 
+   * The DataInterval is the time that must elapse before the channel will fire another data event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between data events can also be affected by the specific change trigger for the channel.
+   */
+  rb_define_method(ph_common, "getDataInterval", ph_common_get_data_interval, 0);
+  rb_define_alias(ph_common, "data_interval", "getDataInterval");
+
+  /* Document-method: setDataInterval
+   * call-seq: setDataInterval(data_interval)
+   *
+   * Sets the data interval for any channel that supports one. 
+   * The DataInterval is the time that must elapse before the channel will fire another data event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between data events can also be affected by the specific change trigger for the channel.
+   */
+  rb_define_method(ph_common, "setDataInterval", ph_common_set_data_interval, 1);
+  rb_define_alias(ph_common, "data_interval=", "setDataInterval");
+
+  /* Document-method: getHubPort
+   * call-seq: getHubPort -> hub_port
+   *
+   * Gets the hub port index of the VINT Hub port that the channel is attached to.
+   */
+  rb_define_method(ph_common, "getHubPort", ph_common_get_hub_port, 0);
+  rb_define_alias(ph_common, "hub_port", "getHubPort");
+
+  /* Document-method: setHubPort
+   * call-seq: setHubPort(hub_port)
+   *
+   * Specifies the hub port index of the VINT Hub port to open this channel on. Leave un-set, or set to Phidgets::HUBPORT_ANY to open the channel on any VINT Hub port.
+   */
+  rb_define_method(ph_common, "setHubPort", ph_common_set_hub_port, 1);
+  rb_define_alias(ph_common, "hub_port=", "setHubPort");
+
+  /* Document-method: getHubPortCount
+   * call-seq: getHubPortCount -> hub_port_count
+   *
+   * Gets the number of VINT ports present on the VINT Hub that the channel is attached to.
+   */
+  rb_define_method(ph_common, "getHubPortCount", ph_common_get_hub_port_count, 0);
+  rb_define_alias(ph_common, "hub_port_count", "getHubPortCount");
+
+  /* Document-method: getIsChannel
+   * call-seq: getIsChannel -> is_channel
+   *
+   * Returns true if it is a channel. Mostly for use alongside getParent() to distinguish channel handles from device handles.
+   */
+  rb_define_method(ph_common, "getIsChannel", ph_common_get_is_channel, 0);
+  rb_define_alias(ph_common, "is_channel?", "getIsChannel");
+
+  /* Document-method: getIsHubPortDevice
+   * call-seq: getIsHubPortDevice -> is_hub_port_device
+   *
+   * Gets whether this channel is a VINT Hub port channel, or part of a VINT device attached to a hub port.
+   */
+  rb_define_method(ph_common, "getIsHubPortDevice", ph_common_get_is_hub_port_device, 0);
+  rb_define_alias(ph_common, "is_hub_port_device?", "getIsHubPortDevice");
+
+  /* Document-method: setIsHubPortDevice
+   * call-seq: setIsHubPortDevice(is_hub_port_device)
+   *
+   * Specifies whether this channel should be opened on a VINT Hub port directly, or on a VINT device attached to a hub port.
+   */
+  rb_define_method(ph_common, "setIsHubPortDevice", ph_common_set_is_hub_port_device, 1);
+  rb_define_alias(ph_common, "is_hub_port_device=", "setIsHubPortDevice");
+
+  /* Document-method: getIsLocal
+   * call-seq: getIsLocal -> is_local
+   *
+   * Returns true when this channel is attached directly on the local machine, or false otherwise.
+   */
+  rb_define_method(ph_common, "getIsLocal", ph_common_get_is_local, 0);
+  rb_define_alias(ph_common, "is_local?", "getIsLocal");
+
+  /* Document-method: setIsLocal
+   * call-seq: setIsLocal(is_local)
+   *
+   * Set to true if the channel is to be opened locally, and not over a network. If both this and IsRemote are set to False (the default),
+   * the channel will be opened either locally or remotely, on whichever matching channel is found first.
+   */
+  rb_define_method(ph_common, "setIsLocal", ph_common_set_is_local, 1);
+  rb_define_alias(ph_common, "is_local=", "setIsLocal");
+
+  /* Document-method: getIsRemote
+   * call-seq: getIsRemote -> is_remote
+   *
+   * Returns true when this channel is attached via a Phidget network server, or false otherwise.
+   */
+  rb_define_method(ph_common, "getIsRemote", ph_common_get_is_remote, 0);
+  rb_define_alias(ph_common, "is_remote?", "getIsRemote");
+
+  /* Document-method: setIsRemote
+   * call-seq: setIsRemote(is_remote)
+   *
+   * Set to true if the channel is to be opened remotely, rather than locally. If both this and IsLocal are set to False (the default),
+   * the channel will be opened either locally or remotely, on whichever matching channel is found first.
+   */
+  rb_define_method(ph_common, "setIsRemote", ph_common_set_is_remote, 1);
+  rb_define_alias(ph_common, "is_remote=", "setIsRemote");
+
+  /* Document-method: getServerHostname
+   * call-seq: getServerHostname -> server_hostname
+   *
+   * Gets the hostname of the Phidget network server for network attached Phidgets.
+   * Fails if the channel is not connected to a Phidget network server.
+   */
+  rb_define_method(ph_common, "getServerHostname", ph_common_get_server_hostname, 0);
+  rb_define_alias(ph_common, "server_hostname", "getServerHostname");
+
+  /* Document-method: getServerName
+   * call-seq: getServerName -> server_name
+   *
+   * Gets the name of the Phidget network server the channel is attached to, if any. 
+   * Fails if the channel is not connected to a Phidget network server.
+   */
+  rb_define_method(ph_common, "getServerName", ph_common_get_server_name, 0);
+  rb_define_alias(ph_common, "server_name", "getServerName");
+
+  /* Document-method: setServerName
+   * call-seq: setServerName(server_name)
+   *
+   * Specifies that this channel will be opened remotely, on a Phidget network server with this name.
+   * This function should only be used if you want your Phidget to be found on a specific server, and does not need to be specified if the Phidget can be on any any available server.
+   * In order for your program to have access to remote Phidgets, you must use the Networking API to EnableServerDiscovery or AddServer.
+   * If setting this property, it must be set before the channel is opened. The behaviour of setting this property while the channel is open is undefined.
+   */
+  rb_define_method(ph_common, "setServerName", ph_common_set_server_name, 1);
+  rb_define_alias(ph_common, "server_name=", "setServerName");
+
+  /* Document-method: getServerPeerName
+   * call-seq: getServerPeerName -> peer_name
+   *
+   * Gets the peer name (address and port) of the Phidget server for network attached Phidgets, formatted as: address:port 
+   * Fails if the channel is not connected to a Phidget network server.
+   */
+  rb_define_method(ph_common, "getServerPeerName", ph_common_get_server_peer_name, 0);
+  rb_define_alias(ph_common, "server_peer_name", "getServerPeerName");
+
+  /* Document-method: getServerUniqueName
+   * call-seq: getServerUniqueName -> unique_name
+   *
+   * Gets the unique name for the server the channel is attached to, if any. This is either a unique mDNS name, or the name specified in addServer
+   * Fails if the channel is not connected to a Phidget network server.
+   */
+  rb_define_method(ph_common, "getServerUniqueName", ph_common_get_server_unique_name, 0);
+  rb_define_alias(ph_common, "server_unique_name", "getServerUniqueName");
+
+  rb_define_private_method(ph_common, "ext_setOnAttachHandler", ph_common_set_on_attach_handler, 1);
+  rb_define_private_method(ph_common, "ext_setOnDetachHandler", ph_common_set_on_detach_handler, 1);
+  rb_define_private_method(ph_common, "ext_setOnErrorHandler", ph_common_set_on_error_handler, 1);
+  rb_define_private_method(ph_common, "ext_setOnPropertyChangeHandler", ph_common_set_on_property_change_handler, 1);
 }
-#endif