phidgets 0.0.5 → 0.1.0

data/ext/phidgets/phidgets_led.c

@@ -0,0 +1,178 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_led_init(VALUE self);
+VALUE ph_led_get_led_count(VALUE self);
+VALUE ph_led_get_current_limit(VALUE self);
+VALUE ph_led_set_current_limit(VALUE self, VALUE limit);
+VALUE ph_led_get_voltage(VALUE self);
+VALUE ph_led_set_voltage(VALUE self, VALUE voltage);
+VALUE ph_led_get_brightness(VALUE self, VALUE index);
+VALUE ph_led_set_brightness(VALUE self, VALUE index, VALUE brightness);
+VALUE ph_led_get_current_limit_indexed(VALUE self, VALUE index);
+VALUE ph_led_set_current_limit_indexed(VALUE self, VALUE index, VALUE limit);
+
+
+VALUE Init_phidgets_led(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_led = rb_define_class_under(ph_module, "LED", ph_common);
+
+  rb_define_const(ph_led, "CURRENT_LIMIT_20mA", INT2FIX(PHIDGET_LED_CURRENT_LIMIT_20mA));
+  rb_define_const(ph_led, "CURRENT_LIMIT_40mA", INT2FIX(PHIDGET_LED_CURRENT_LIMIT_40mA));
+  rb_define_const(ph_led, "CURRENT_LIMIT_60mA", INT2FIX(PHIDGET_LED_CURRENT_LIMIT_60mA));
+  rb_define_const(ph_led, "CURRENT_LIMIT_80mA", INT2FIX(PHIDGET_LED_CURRENT_LIMIT_80mA));
+  rb_define_const(ph_led, "VOLTAGE_1_7V", INT2FIX(PHIDGET_LED_VOLTAGE_1_7V));
+  rb_define_const(ph_led, "VOLTAGE_2_75V", INT2FIX(PHIDGET_LED_VOLTAGE_2_75V));
+  rb_define_const(ph_led, "VOLTAGE_3_9V", INT2FIX(PHIDGET_LED_VOLTAGE_3_9V));
+  rb_define_const(ph_led, "VOLTAGE_5_0V", INT2FIX(PHIDGET_LED_VOLTAGE_5_0V));
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget LED object.
+   */
+  rb_define_method(ph_led, "initialize", ph_led_init, 0);
+
+  /* Document-method: getLEDCount
+   * call-seq: getLEDCount -> count
+   *
+   * Gets the number of LEDs supported by this board.
+   */
+  rb_define_method(ph_led, "getLEDCount", ph_led_get_led_count, 0);
+
+  /* Document-method: getCurrentLimit
+   * call-seq: getCurrentLimit -> limit
+   *
+   * Gets the current limit. This is for all ouputs.
+   */
+  rb_define_method(ph_led, "getCurrentLimit", ph_led_get_current_limit, 0);
+
+  /* Document-method: setCurrentLimit
+   * call-seq: setCurrentLimit(limit)
+   *
+   * Sets the current limit. This is for all ouputs.
+   */
+  rb_define_method(ph_led, "setCurrentLimit", ph_led_set_current_limit, 1);
+
+  /* Document-method: getVoltage
+   * call-seq: getVoltage -> voltage
+   *
+   * Gets the output voltage. This is for all ouputs.
+   */
+  rb_define_method(ph_led, "getVoltage", ph_led_get_voltage, 0);
+
+  /* Document-method: setVoltage
+   * call-seq: setVoltage(voltage)
+   *
+   * Sets the output voltage. This is for all ouputs.
+   */
+  rb_define_method(ph_led, "setVoltage", ph_led_set_voltage, 1);
+
+  /* Document-method: getBrightness
+   * call-seq: getBrightness(index) -> brightness
+   *
+   * Gets the brightness of an LED.
+   */
+  rb_define_method(ph_led, "getBrightness", ph_led_get_brightness, 1);
+
+  /* Document-method: setBrightness
+   * call-seq: setBrightness(index, brightness)
+   *
+   * Sets the brightness of an LED.
+   */
+  rb_define_method(ph_led, "setBrightness", ph_led_set_brightness, 2);
+
+  /* Document-method: getCurrentLimitIndexed
+   * call-seq: getCurrentLimitIndexed(index) -> limit
+   *
+   * Gets the current limit of an LED.
+   */
+  rb_define_method(ph_led, "getCurrentLimitIndexed", ph_led_get_current_limit_indexed, 1);
+
+  /* Document-method: setCurrentLimitIndexed
+   * call-seq: setCurrentLimitIndexed(index, limit)
+   *
+   * Sets the current limit of an LED.
+   */
+  rb_define_method(ph_led, "setCurrentLimitIndexed", ph_led_set_current_limit_indexed, 2);
+
+  rb_define_alias(ph_led, "led_count", "getLEDCount");
+  rb_define_alias(ph_led, "current_limit", "getCurrentLimit");
+  rb_define_alias(ph_led, "current_limit=", "setCurrentLimit");
+  rb_define_alias(ph_led, "voltage", "getVoltage");
+  rb_define_alias(ph_led, "voltage=", "setVoltage");
+  rb_define_alias(ph_led, "brightness", "getBrightness");
+  rb_define_alias(ph_led, "set_brightness", "setBrightness");
+  rb_define_alias(ph_led, "current_limit_indexed", "getCurrentLimitIndexed");
+  rb_define_alias(ph_led, "set_current_limit_indexed", "setCurrentLimitIndexed");
+
+  return ph_led;
+}
+
+
+
+VALUE ph_led_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetLED_create((CPhidgetLEDHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_led_get_led_count(VALUE self) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetLED_getLEDCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_led_get_current_limit(VALUE self) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  CPhidgetLED_CurrentLimit limit;
+  ph_raise(CPhidgetLED_getCurrentLimit(handle, &limit));
+  return INT2FIX(limit);
+}
+
+VALUE ph_led_set_current_limit(VALUE self, VALUE limit) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  ph_raise(CPhidgetLED_setCurrentLimit(handle, FIX2INT(limit)));
+  return Qnil;
+}
+
+VALUE ph_led_get_voltage(VALUE self) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  CPhidgetLED_Voltage voltage;
+  ph_raise(CPhidgetLED_getVoltage(handle, &voltage));
+  return INT2FIX(voltage);
+}
+
+VALUE ph_led_set_voltage(VALUE self, VALUE voltage) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  ph_raise(CPhidgetLED_setVoltage(handle, FIX2INT(voltage)));
+  return Qnil;
+}
+
+VALUE ph_led_get_brightness(VALUE self, VALUE index) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  double brightness;
+  ph_raise(CPhidgetLED_getBrightness(handle, FIX2INT(index), &brightness));
+  return rb_float_new(brightness);
+}
+
+VALUE ph_led_set_brightness(VALUE self, VALUE index, VALUE brightness) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  ph_raise(CPhidgetLED_setBrightness(handle, FIX2INT(index), NUM2DBL(brightness)));
+  return Qnil;
+}
+
+VALUE ph_led_get_current_limit_indexed(VALUE self, VALUE index) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  double limit;
+  ph_raise(CPhidgetLED_getCurrentLimitIndexed(handle, FIX2INT(index), &limit));
+  return rb_float_new(limit);
+}
+
+VALUE ph_led_set_current_limit_indexed(VALUE self, VALUE index, VALUE limit) {
+  CPhidgetLEDHandle handle = (CPhidgetLEDHandle)get_ph_handle(self);
+  ph_raise(CPhidgetLED_setCurrentLimitIndexed(handle, FIX2INT(index), NUM2DBL(limit)));
+  return Qnil;
+}
+

data/ext/phidgets/phidgets_manager.c

@@ -0,0 +1,366 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_manager_allocate(VALUE klass);
+void  ph_manager_free(ph_data_t *ph);
+VALUE ph_manager_init(VALUE self);
+VALUE ph_manager_open(VALUE self);
+VALUE ph_manager_open_remote(VALUE self, VALUE server_id, VALUE password);
+VALUE ph_manager_open_remote_ip(VALUE self, VALUE address, VALUE port, VALUE password);
+VALUE ph_manager_close(VALUE self);
+VALUE ph_manager_get_server_id(VALUE self);
+VALUE ph_manager_get_server_address(VALUE self);
+VALUE ph_manager_get_server_status(VALUE self);
+VALUE ph_manager_get_attached_devices(VALUE self);
+VALUE ph_manager_instance_from_class(CPhidget_DeviceClass dev_class);
+
+#ifdef PH_CALLBACK
+VALUE ph_manager_set_on_attach_handler(VALUE self, VALUE handler);
+VALUE ph_manager_set_on_detach_handler(VALUE self, VALUE handler);
+VALUE ph_manager_set_on_server_connect_handler(VALUE self, VALUE handler);
+VALUE ph_manager_set_on_server_disconnect_handler(VALUE self, VALUE handler);
+int ph_manager_on_attach(CPhidgetHandle phid, void *userPtr);
+int ph_manager_on_detach(CPhidgetHandle phid, void *userPtr);
+int ph_manager_on_server_connect(CPhidgetManagerHandle phid, void *userPtr);
+int ph_manager_on_server_disconnect(CPhidgetManagerHandle phid, void *userPtr);
+#endif
+
+
+VALUE Init_phidgets_manager(VALUE ph_module) {
+  VALUE ph_manager = rb_define_class_under(ph_module, "Manager", rb_cObject);
+  rb_define_alloc_func(ph_manager, ph_manager_allocate);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget Manager object.
+   */
+  rb_define_method(ph_manager, "initialize", ph_manager_init, 0);
+  rb_define_private_method(ph_manager, "ext_open", ph_manager_open, 0);
+
+  /* Document-method: openRemote
+   * call-seq: openRemote(server_id, password)
+   *
+   * Opens a Phidget manager remotely by ServerID. Note that this requires Bonjour
+   * (mDNS) to be running on both the host and the server.
+   */
+  rb_define_method(ph_manager, "openRemote", ph_manager_open_remote, 2);
+
+  /* Document-method: openRemoteIP
+   * call-seq: openRemoteIP(address, port, password)
+   *
+   * Opens a Phidget manager remotely by address and port.
+   */
+  rb_define_method(ph_manager, "openRemoteIP", ph_manager_open_remote_ip, 3);
+
+  /* Document-method: close
+   * call-seq: close
+   *
+   * Closes a Phidget Manager.
+   */
+  rb_define_method(ph_manager, "close", ph_manager_close, 0);
+
+  /* Document-method: getServerID
+   * call-seq: getServerID -> server_id
+   *
+   * Gets the server ID of a remotely opened Phidget Manager. This will fail if the manager was opened locally.
+   */
+  rb_define_method(ph_manager, "getServerID", ph_manager_get_server_id, 0);
+
+  /* Document-method: getServerAddress
+   * call-seq: getServerAddress -> [address, port]
+   *
+   * Gets the address and port of a remotely opened Phidget Manager. This will fail if the manager was opened locally.
+   */
+  rb_define_method(ph_manager, "getServerAddress", ph_manager_get_server_address, 0);
+
+  /* Document-method: getServerStatus
+   * call-seq: getServerStatus -> status
+   *
+   * Gets the connected to server status of a remotely opened Phidget Manager. This will fail if the manager was opened locally.
+   */
+  rb_define_method(ph_manager, "getServerStatus", ph_manager_get_server_status, 0);
+
+  /* Document-method: getAttachedDevices
+   * call-seq: getAttachedDevices -> [devices]
+   *
+   * Gets an array of all currently attached Phidgets.
+   */
+  rb_define_method(ph_manager, "getAttachedDevices", ph_manager_get_attached_devices, 0);
+
+#ifdef PH_CALLBACK
+  rb_define_private_method(ph_manager, "ext_setOnAttachHandler", ph_manager_set_on_attach_handler, 1);
+  rb_define_private_method(ph_manager, "ext_setOnDetachHandler", ph_manager_set_on_detach_handler, 1);
+  rb_define_private_method(ph_manager, "ext_setOnServerConnectHandler", ph_manager_set_on_server_connect_handler, 1);
+  rb_define_private_method(ph_manager, "ext_setOnServerDisconnectHandler", ph_manager_set_on_server_disconnect_handler, 1);
+#endif
+
+  rb_define_alias(ph_manager, "open_remote", "openRemote");
+  rb_define_alias(ph_manager, "open_remote_ip", "openRemoteIP");
+  rb_define_alias(ph_manager, "server_id", "getServerID");
+  rb_define_alias(ph_manager, "server_address", "getServerAddress");
+  rb_define_alias(ph_manager, "server_status", "getServerStatus");
+  rb_define_alias(ph_manager, "attached_devices", "getAttachedDevices");
+
+  return ph_manager;
+}
+
+
+
+VALUE ph_manager_allocate(VALUE klass) {
+  ph_data_t *ph;
+  VALUE self = Data_Make_Struct(klass, ph_data_t, 0, ph_manager_free, ph);
+  memset(ph, 0, sizeof(ph_data_t));
+  return self;
+}
+
+void ph_manager_free(ph_data_t *ph) {
+  if (ph && ph->handle) {
+    CPhidgetManager_close((CPhidgetManagerHandle)ph->handle);
+    CPhidgetManager_delete((CPhidgetManagerHandle)ph->handle);
+    ph->handle = NULL;
+  }
+  if(ph) xfree(ph);
+}
+
+VALUE ph_manager_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetManager_create((CPhidgetManagerHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_manager_open(VALUE self) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  ph_raise(CPhidgetManager_open(handle));
+  return Qnil;
+}
+
+VALUE ph_manager_open_remote(VALUE self, VALUE server_id, VALUE password) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  ph_raise(CPhidgetManager_openRemote(handle, StringValueCStr(server_id), StringValueCStr(password)));
+  return Qnil;
+}
+
+VALUE ph_manager_open_remote_ip(VALUE self, VALUE address, VALUE port, VALUE password) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  ph_raise(CPhidgetManager_openRemoteIP(handle, StringValueCStr(address), FIX2INT(port), StringValueCStr(password)));
+  return Qnil;
+}
+
+VALUE ph_manager_close(VALUE self) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  ph_raise(CPhidgetManager_close(handle));
+  return Qnil;
+}
+
+VALUE ph_manager_get_server_id(VALUE self) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  const char *server_id;
+  ph_raise(CPhidgetManager_getServerID(handle, &server_id));
+  return rb_str_new2(server_id);
+}
+
+VALUE ph_manager_get_server_address(VALUE self) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  const char *address;
+  int port;
+  ph_raise(CPhidgetManager_getServerAddress(handle, &address, &port));
+  return rb_ary_new3(2, rb_str_new2(address), INT2FIX(port));
+}
+
+VALUE ph_manager_get_server_status(VALUE self) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  int server_status;
+  ph_raise(CPhidgetManager_getServerStatus(handle, &server_status));
+  return INT2FIX(server_status);
+}
+
+VALUE ph_manager_get_attached_devices(VALUE self) {
+  CPhidgetManagerHandle handle = (CPhidgetManagerHandle)get_ph_handle(self);
+  CPhidgetHandle *devices;
+  int count, i;
+  VALUE rb_hash = rb_hash_new();
+  ph_raise(CPhidgetManager_getAttachedDevices(handle, &devices, &count));
+  for(i=0; i<count; i++) {
+    int serial;
+    CPhidget_DeviceClass dev_class;
+    ph_raise(CPhidget_getSerialNumber(devices[i], &serial));
+    ph_raise(CPhidget_getDeviceClass(devices[i], &dev_class));
+    rb_hash_aset(rb_hash, INT2FIX(serial), ph_manager_instance_from_class(dev_class));
+  }
+  ph_raise(CPhidgetManager_freeAttachedDevicesArray(devices));
+  return rb_hash;
+}
+
+VALUE ph_manager_instance_from_class(CPhidget_DeviceClass dev_class) {
+  VALUE ph_module = rb_const_get(rb_cModule, rb_intern("Phidgets"));
+  VALUE klass;
+  VALUE argv[0];
+
+  switch( dev_class ) {
+    case PHIDCLASS_ACCELEROMETER:
+      klass = rb_const_get(ph_module, rb_intern("Accelerometer"));
+      break;
+    case PHIDCLASS_ADVANCEDSERVO:
+      klass = rb_const_get(ph_module, rb_intern("AdvancedServo"));
+      break;
+    case PHIDCLASS_ANALOG:
+      klass = rb_const_get(ph_module, rb_intern("Analog"));
+      break;
+    case PHIDCLASS_BRIDGE:
+      klass = rb_const_get(ph_module, rb_intern("Bridge"));
+      break;
+    case PHIDCLASS_ENCODER:
+      klass = rb_const_get(ph_module, rb_intern("Encoder"));
+      break;
+    case PHIDCLASS_FREQUENCYCOUNTER:
+      klass = rb_const_get(ph_module, rb_intern("FrequencyCounter"));
+      break;
+    case PHIDCLASS_GPS:
+      klass = rb_const_get(ph_module, rb_intern("GPS"));
+      break;
+    case PHIDCLASS_INTERFACEKIT:
+      klass = rb_const_get(ph_module, rb_intern("InterfaceKit"));
+      break;
+    case PHIDCLASS_IR:
+      klass = rb_const_get(ph_module, rb_intern("IR"));
+      break;
+    case PHIDCLASS_LED:
+      klass = rb_const_get(ph_module, rb_intern("LED"));
+      break;
+    case PHIDCLASS_MOTORCONTROL:
+      klass = rb_const_get(ph_module, rb_intern("MotorControl"));
+      break;
+    case PHIDCLASS_PHSENSOR:
+      klass = rb_const_get(ph_module, rb_intern("PhSensor"));
+      break;
+    case PHIDCLASS_RFID:
+      klass = rb_const_get(ph_module, rb_intern("RFID"));
+      break;
+    case PHIDCLASS_SERVO:
+      klass = rb_const_get(ph_module, rb_intern("Servo"));
+      break;
+    case PHIDCLASS_SPATIAL:
+      klass = rb_const_get(ph_module, rb_intern("Spatial"));
+      break;
+    case PHIDCLASS_STEPPER:
+      klass = rb_const_get(ph_module, rb_intern("Stepper"));
+      break;
+    case PHIDCLASS_TEMPERATURESENSOR:
+      klass = rb_const_get(ph_module, rb_intern("TemperatureSensor"));
+      break;
+    case PHIDCLASS_TEXTLCD:
+      klass = rb_const_get(ph_module, rb_intern("TextLCD"));
+      break;
+    case PHIDCLASS_TEXTLED:
+      klass = rb_const_get(ph_module, rb_intern("TextLED"));
+      break;
+    case PHIDCLASS_WEIGHTSENSOR:
+      klass = rb_const_get(ph_module, rb_intern("WeightSensor"));
+      break;
+    default:
+      klass = Qnil;
+  }
+
+  return rb_class_new_instance(0, argv, klass);
+}
+
+#ifdef PH_CALLBACK
+VALUE ph_manager_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->exit = true;
+    ph_raise(CPhidgetManager_set_OnAttach_Handler((CPhidgetManagerHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetManager_set_OnAttach_Handler((CPhidgetManagerHandle)ph->handle, ph_manager_on_attach, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+VALUE ph_manager_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->exit = true;
+    ph_raise(CPhidgetManager_set_OnDetach_Handler((CPhidgetManagerHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetManager_set_OnDetach_Handler((CPhidgetManagerHandle)ph->handle, ph_manager_on_detach, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+VALUE ph_manager_set_on_server_connect_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->server_connect_callback;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetManager_set_OnServerConnect_Handler((CPhidgetManagerHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetManager_set_OnServerConnect_Handler((CPhidgetManagerHandle)ph->handle, ph_manager_on_server_connect, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+VALUE ph_manager_set_on_server_disconnect_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->server_disconnect_callback;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetManager_set_OnServerDisconnect_Handler((CPhidgetManagerHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetManager_set_OnServerDisconnect_Handler((CPhidgetManagerHandle)ph->handle, ph_manager_on_server_disconnect, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+int ph_manager_on_attach(CPhidgetHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+
+int ph_manager_on_detach(CPhidgetHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+
+int ph_manager_on_server_connect(CPhidgetManagerHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+
+int ph_manager_on_server_disconnect(CPhidgetManagerHandle phid, void *userPtr) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+#endif
+