phidgets 0.1.3 → 1.0.0

data/ext/phidgets/phidgets_gyroscope.c

@@ -0,0 +1,195 @@
+
+#include "phidgets.h"
+
+#define GYROSCOPE_ANGULAR_RATE_UPDATE_CALLBACK  0
+
+
+VALUE ph_gyroscope_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetGyroscope_create((PhidgetGyroscopeHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_gyroscope_get_angular_rate(VALUE self) {
+  double angular_rate[3];
+  ph_raise(PhidgetGyroscope_getAngularRate((PhidgetGyroscopeHandle)get_ph_handle(self), &angular_rate));
+  return rb_ary_new3(3, DBL2NUM(angular_rate[0]), DBL2NUM(angular_rate[1]), DBL2NUM(angular_rate[2]));
+}
+
+VALUE ph_gyroscope_get_min_angular_rate(VALUE self) {
+  double angular_rate[3];
+  ph_raise(PhidgetGyroscope_getMinAngularRate((PhidgetGyroscopeHandle)get_ph_handle(self), &angular_rate));
+  return rb_ary_new3(3, DBL2NUM(angular_rate[0]), DBL2NUM(angular_rate[1]), DBL2NUM(angular_rate[2]));
+}
+
+VALUE ph_gyroscope_get_max_angular_rate(VALUE self) {
+  double angular_rate[3];
+  ph_raise(PhidgetGyroscope_getMaxAngularRate((PhidgetGyroscopeHandle)get_ph_handle(self), &angular_rate));
+  return rb_ary_new3(3, DBL2NUM(angular_rate[0]), DBL2NUM(angular_rate[1]), DBL2NUM(angular_rate[2]));
+}
+
+VALUE ph_gyroscope_get_axis_count(VALUE self) {
+  return ph_get_int(get_ph_handle(self), (phidget_get_int_func)PhidgetGyroscope_getAxisCount);
+}
+
+VALUE ph_gyroscope_get_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetGyroscope_getDataInterval);
+}
+
+VALUE ph_gyroscope_set_data_interval(VALUE self, VALUE interval) {
+  ph_raise(PhidgetGyroscope_setDataInterval((PhidgetGyroscopeHandle)get_ph_handle(self), NUM2UINT(interval)));
+  return Qnil;
+}
+
+VALUE ph_gyroscope_get_min_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetGyroscope_getMinDataInterval);
+}
+
+VALUE ph_gyroscope_get_max_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetGyroscope_getMaxDataInterval);
+}
+
+VALUE ph_gyroscope_get_timestamp(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetGyroscope_getTimestamp);
+}
+
+VALUE ph_gyroscope_zero(VALUE self) {
+  ph_raise(PhidgetGyroscope_zero((PhidgetGyroscopeHandle)get_ph_handle(self)));
+  return Qnil;
+}
+
+
+void CCONV ph_gyroscope_on_angular_rate_update(PhidgetGyroscopeHandle phid, void *userPtr, const double angularRate[3], double timestamp) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = rb_ary_new3(3, DBL2NUM(angularRate[0]), DBL2NUM(angularRate[1]), DBL2NUM(angularRate[2]));
+  callback_data->arg2 = DBL2NUM(timestamp);
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
+}
+
+
+VALUE ph_gyroscope_set_on_angular_rate_update_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[GYROSCOPE_ANGULAR_RATE_UPDATE_CALLBACK];
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
+    callback_data->exit = true;
+    ph_raise(PhidgetGyroscope_setOnAngularRateUpdateHandler((PhidgetGyroscopeHandle)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(PhidgetGyroscope_setOnAngularRateUpdateHandler((PhidgetGyroscopeHandle)ph->handle, ph_gyroscope_on_angular_rate_update, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+void Init_gyroscope() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_gyroscope = rb_define_class_under(ph_module, "Gyroscope", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget Gyroscope object.
+   */
+  rb_define_method(ph_gyroscope, "initialize", ph_gyroscope_init, 0);
+
+  /* Document-method: getAngularRate
+   * call-seq: getAngularRate -> angular_rate
+   *
+   * The most recent angular rate value that the channel has reported.
+   * This value will always be between MinAngularRate and MaxAngularRate.
+   */
+  rb_define_method(ph_gyroscope, "getAngularRate", ph_gyroscope_get_angular_rate, 0);
+  rb_define_alias(ph_gyroscope, "angular_rate", "getAngularRate");
+
+  /* Document-method: getMinAngularRate
+   * call-seq: getMinAngularRate -> angular_rate
+   *
+   * The minimum value the AngularRateUpdate event will report.
+   */
+  rb_define_method(ph_gyroscope, "getMinAngularRate", ph_gyroscope_get_min_angular_rate, 0);
+  rb_define_alias(ph_gyroscope, "min_angular_rate", "getMinAngularRate");
+
+  /* Document-method: getMaxAngularRate
+   * call-seq: getMaxAngularRate -> angular_rate
+   *
+   * The maximum value the AngularRateUpdate event will report.
+   */
+  rb_define_method(ph_gyroscope, "getMaxAngularRate", ph_gyroscope_get_max_angular_rate, 0);
+  rb_define_alias(ph_gyroscope, "max_angular_rate", "getMaxAngularRate");
+
+  /* Document-method: getAxisCount
+   * call-seq: getAxisCount -> axis_count
+   *
+   * The number of axes the channel can measure angular rate on.
+   * See your device's User Guide for more information about the number of axes and their orientation.
+   */
+  rb_define_method(ph_gyroscope, "getAxisCount", ph_gyroscope_get_axis_count, 0);
+  rb_define_alias(ph_gyroscope, "axis_count", "getAxisCount");
+
+  /* Document-method: getDataInterval
+   * call-seq: getDataInterval -> interval
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another AngularRateUpdate event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   */
+  rb_define_method(ph_gyroscope, "getDataInterval", ph_gyroscope_get_data_interval, 0);
+  rb_define_alias(ph_gyroscope, "data_interval", "getDataInterval");
+
+  /* Document-method: setDataInterval
+   * call-seq: setDataInterval(interval)
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another AngularRateUpdate event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   */
+  rb_define_method(ph_gyroscope, "setDataInterval", ph_gyroscope_set_data_interval, 1);
+  rb_define_alias(ph_gyroscope, "data_interval=", "setDataInterval");
+
+  /* Document-method: getMinDataInterval
+   * call-seq: getMinDataInterval -> interval
+   *
+   * The minimum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_gyroscope, "getMinDataInterval", ph_gyroscope_get_min_data_interval, 0);
+  rb_define_alias(ph_gyroscope, "min_data_interval", "getMinDataInterval");
+
+  /* Document-method: getMaxDataInterval
+   * call-seq: getMaxDataInterval -> interval
+   *
+   * The maximum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_gyroscope, "getMaxDataInterval", ph_gyroscope_get_max_data_interval, 0);
+  rb_define_alias(ph_gyroscope, "max_data_interval", "getMaxDataInterval");
+
+  /* Document-method: getTimestamp
+   * call-seq: getTimestamp -> timestamp
+   *
+   * The most recent timestamp value that the channel has reported. This is an extremely accurate time measurement streamed from the device.
+   * If your application requires a time measurement, you should use this value over a local software timestamp.
+   */
+  rb_define_method(ph_gyroscope, "getTimestamp", ph_gyroscope_get_timestamp, 0);
+  rb_define_alias(ph_gyroscope, "timestamp", "getTimestamp");
+
+  /* Document-method: zero
+   * call-seq: zero
+   *
+   * Re-zeros the gyroscope in 1-2 seconds.
+   * The device must be stationary when zeroing.
+   * The angular rate will be reported as 0.0°/s while zeroing.
+   * Zeroing the gyroscope is a method of compensating for the drift that is inherent to all gyroscopes. See your device's User Guide for more information on dealing with drift.
+   */
+  rb_define_method(ph_gyroscope, "zero", ph_gyroscope_zero, 0);
+  rb_define_alias(ph_gyroscope, "zero", "zero");
+
+
+  rb_define_private_method(ph_gyroscope, "ext_setOnAngularRateUpdateHandler", ph_gyroscope_set_on_angular_rate_update_handler, 1);
+}
+

data/ext/phidgets/phidgets_hub.c

@@ -0,0 +1,39 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_hub_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetHub_create((PhidgetHubHandle *)(&(ph->handle))));
+  return self;
+}
+
+
+VALUE ph_hub_set_port_power(VALUE self, VALUE port, VALUE state) {
+  ph_raise(PhidgetHub_setPortPower((PhidgetHubHandle)get_ph_handle(self), NUM2INT(port), TYPE(state) == T_TRUE ? PTRUE : PFALSE));
+  return Qnil;
+}
+
+
+
+void Init_hub() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_hub = rb_define_class_under(ph_module, "Hub", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget Hub object.
+   */
+  rb_define_method(ph_hub, "initialize", ph_hub_init, 0);
+
+  /* Document-method: setPortPower
+   * call-seq: setPortPower(port, state)
+   *
+   * Controls power to the VINT Hub Ports.
+   */
+  rb_define_method(ph_hub, "setPortPower", ph_hub_set_port_power, 2);
+  rb_define_alias(ph_hub, "set_port_power", "setPortPower");
+}
+

data/ext/phidgets/phidgets_humidity_sensor.c

@@ -0,0 +1,200 @@
+
+#include "phidgets.h"
+
+#define HUMIDITY_SENSOR_HUMIDITY_CHANGE_CALLBACK    0
+
+
+VALUE ph_humidity_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetHumiditySensor_create((PhidgetHumiditySensorHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_humidity_get_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetHumiditySensor_getDataInterval);
+}
+
+VALUE ph_humidity_set_data_interval(VALUE self, VALUE interval) {
+  ph_raise(PhidgetHumiditySensor_setDataInterval((PhidgetHumiditySensorHandle)get_ph_handle(self), NUM2UINT(interval)));
+  return Qnil;
+}
+
+VALUE ph_humidity_get_min_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetHumiditySensor_getMinDataInterval);
+}
+
+VALUE ph_humidity_get_max_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetHumiditySensor_getMaxDataInterval);
+}
+
+VALUE ph_humidity_get_humidity(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetHumiditySensor_getHumidity);
+}
+
+VALUE ph_humidity_get_min_humidity(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetHumiditySensor_getMinHumidity);
+}
+
+VALUE ph_humidity_get_max_humidity(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetHumiditySensor_getMaxHumidity);
+}
+
+VALUE ph_humidity_get_humidity_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetHumiditySensor_getHumidityChangeTrigger);
+}
+
+VALUE ph_humidity_set_humidity_change_trigger(VALUE self, VALUE change_trigger) {
+  ph_raise(PhidgetHumiditySensor_setHumidityChangeTrigger((PhidgetHumiditySensorHandle)get_ph_handle(self), NUM2DBL(change_trigger)));
+  return Qnil;
+}
+
+VALUE ph_humidity_get_min_humidity_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetHumiditySensor_getMinHumidityChangeTrigger);
+}
+
+VALUE ph_humidity_get_max_humidity_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetHumiditySensor_getMaxHumidityChangeTrigger);
+}
+
+
+void CCONV ph_humidity_on_humidity_change(PhidgetHumiditySensorHandle phid, void *userPtr, double humidity) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = DBL2NUM(humidity);
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
+}
+
+
+VALUE ph_humidity_set_on_humidity_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[HUMIDITY_SENSOR_HUMIDITY_CHANGE_CALLBACK];
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
+    callback_data->exit = true;
+    ph_raise(PhidgetHumiditySensor_setOnHumidityChangeHandler((PhidgetHumiditySensorHandle)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(PhidgetHumiditySensor_setOnHumidityChangeHandler((PhidgetHumiditySensorHandle)ph->handle, ph_humidity_on_humidity_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+void Init_humidity() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_humidity = rb_define_class_under(ph_module, "HumiditySensor", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget HumiditySensor object.
+   */
+  rb_define_method(ph_humidity, "initialize", ph_humidity_init, 0);
+
+  /* Document-method: getDataInterval
+   * call-seq: getDataInterval -> interval
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another HumidityChange event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between HumidityChange events can also affected by the HumidityChangeTrigger.
+   */
+  rb_define_method(ph_humidity, "getDataInterval", ph_humidity_get_data_interval, 0);
+  rb_define_alias(ph_humidity, "data_interval", "getDataInterval");
+
+  /* Document-method: setDataInterval
+   * call-seq: setDataInterval(interval)
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another HumidityChange event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between HumidityChange events can also affected by the HumidityChangeTrigger.
+   */
+  rb_define_method(ph_humidity, "setDataInterval", ph_humidity_set_data_interval, 1);
+  rb_define_alias(ph_humidity, "data_interval=", "setDataInterval");
+
+  /* Document-method: getMinDataInterval
+   * call-seq: getMinDataInterval -> interval
+   *
+   * The minimum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_humidity, "getMinDataInterval", ph_humidity_get_min_data_interval, 0);
+  rb_define_alias(ph_humidity, "min_data_interval", "getMinDataInterval");
+
+  /* Document-method: getMaxDataInterval
+   * call-seq: getMaxDataInterval -> interval
+   *
+   * The maximum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_humidity, "getMaxDataInterval", ph_humidity_get_max_data_interval, 0);
+  rb_define_alias(ph_humidity, "max_data_interval", "getMaxDataInterval");
+
+  /* Document-method: getHumidity
+   * call-seq: getHumidity -> humidity
+   *
+   * The most recent humidity value that the channel has reported.
+   * This value will always be between MinHumidity and MaxHumidity.
+   */
+  rb_define_method(ph_humidity, "getHumidity", ph_humidity_get_humidity, 0);
+  rb_define_alias(ph_humidity, "humidity", "getHumidity");
+
+  /* Document-method: getMinHumidity
+   * call-seq: getMinHumidity -> humidity
+   *
+   * The minimum value that the HumidityChange event will report.
+   */
+  rb_define_method(ph_humidity, "getMinHumidity", ph_humidity_get_min_humidity, 0);
+  rb_define_alias(ph_humidity, "min_humidity", "getMinHumidity");
+
+  /* Document-method: getMaxHumidity
+   * call-seq: getMaxHumidity -> humidity
+   *
+   * The maximum value that the HumidityChange event will report.
+   */
+  rb_define_method(ph_humidity, "getMaxHumidity", ph_humidity_get_max_humidity, 0);
+  rb_define_alias(ph_humidity, "max_humidity", "getMaxHumidity");
+
+  /* Document-method: getHumidityChangeTrigger
+   * call-seq: getHumidityChangeTrigger -> change_trigger
+   *
+   * The channel will not issue a HumidityChange event until the humidity value has changed by the amount specified by the HumidityChangeTrigger.
+   * Setting the HumidityChangeTrigger 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_humidity, "getHumidityChangeTrigger", ph_humidity_get_humidity_change_trigger, 0);
+  rb_define_alias(ph_humidity, "humidity_change_trigger", "getHumidityChangeTrigger");
+
+  /* Document-method: setHumidityChangeTrigger
+   * call-seq: setHumidityChangeTrigger(change_trigger)
+   *
+   * The channel will not issue a HumidityChange event until the humidity value has changed by the amount specified by the HumidityChangeTrigger.
+   * Setting the HumidityChangeTrigger 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_humidity, "setHumidityChangeTrigger", ph_humidity_set_humidity_change_trigger, 1);
+  rb_define_alias(ph_humidity, "humidity_change_trigger=", "setHumidityChangeTrigger");
+
+  /* Document-method: getMinHumidityChangeTrigger
+   * call-seq: getMinHumidityChangeTrigger -> change_trigger
+   *
+   * The minimum value that HumidityChangeTrigger can be set to.
+   */
+  rb_define_method(ph_humidity, "getMinHumidityChangeTrigger", ph_humidity_get_min_humidity_change_trigger, 0);
+  rb_define_alias(ph_humidity, "min_humidity_change_trigger", "getMinHumidityChangeTrigger");
+
+  /* Document-method: getMaxHumidityChangeTrigger
+   * call-seq: getMaxHumidityChangeTrigger -> change_trigger
+   *
+   * The maximum value that HumidityChangeTrigger can be set to.
+   */
+  rb_define_method(ph_humidity, "getMaxHumidityChangeTrigger", ph_humidity_get_max_humidity_change_trigger, 0);
+  rb_define_alias(ph_humidity, "max_humidity_change_trigger", "getMaxHumidityChangeTrigger");
+
+
+  rb_define_private_method(ph_humidity, "ext_setOnHumidityChangeHandler", ph_humidity_set_on_humidity_change_handler, 1);
+}
+

data/ext/phidgets/phidgets_ir.c

@@ -1,251 +1,291 @@
 
 #include "phidgets.h"
 
-
-VALUE ph_ir_init(VALUE self);
-VALUE ph_ir_transmit(VALUE self, VALUE data, VALUE code_info);
-VALUE ph_ir_transmit_repeat(VALUE self);
-VALUE ph_ir_transmit_raw(VALUE self, VALUE data, VALUE carrier_freq, VALUE duty_cycle, VALUE gap);
-VALUE ph_ir_get_raw_data(VALUE self, VALUE length);
-VALUE ph_ir_get_last_code(VALUE self);
-VALUE ph_ir_get_last_learned_code(VALUE self);
-
-#ifdef PH_CALLBACK
-VALUE ph_ir_set_on_code_handler(VALUE self, VALUE handler);
-VALUE ph_ir_set_on_learn_handler(VALUE self, VALUE handler);
-VALUE ph_ir_set_on_raw_data_handler(VALUE self, VALUE handler);
-int ph_ir_on_code(CPhidgetIRHandle phid, void *userPtr, unsigned char *data, int dataLength, int bitCount, int repeat);
-int ph_ir_on_learn(CPhidgetIRHandle phid, void *userPtr, unsigned char *data, int dataLength, CPhidgetIR_CodeInfoHandle codeInfo);
-int ph_ir_on_raw_data(CPhidgetIRHandle phid, void *userPtr, int *data, int dataLength);
-#endif
-
-
-void Init_ir() {
-  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
-  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
-  VALUE ph_ir = rb_define_class_under(ph_module, "IR", ph_common);
-
-  /* Unknown - the default value */
-  rb_define_const(ph_ir, "ENCODING_UNKNOWN", INT2FIX(PHIDGET_IR_ENCODING_UNKNOWN));
-  /* Space encoding, or Pulse Distance Modulation */
-  rb_define_const(ph_ir, "ENCODING_SPACE", INT2FIX(PHIDGET_IR_ENCODING_SPACE));
-  /* Pulse encoding, or Pulse Width Modulation */
-  rb_define_const(ph_ir, "ENCODING_PULSE", INT2FIX(PHIDGET_IR_ENCODING_PULSE));
-  /* Bi-Phase, or Manchester encoding */
-  rb_define_const(ph_ir, "ENCODING_BIPHASE", INT2FIX(PHIDGET_IR_ENCODING_BIPHASE));
-  /* RC5 - a type of Bi-Phase encoding */
-  rb_define_const(ph_ir, "ENCODING_RC5", INT2FIX(PHIDGET_IR_ENCODING_RC5));
-  /* RC6 - a type of Bi-Phase encoding */
-  rb_define_const(ph_ir, "ENCODING_RC6", INT2FIX(PHIDGET_IR_ENCODING_RC6));
-
-  /* Unknown - the default value */
-  rb_define_const(ph_ir, "LENGTH_UNKNOWN", INT2FIX(PHIDGET_IR_LENGTH_UNKNOWN));
-  /* Constant - the bitstream + gap length is constant */
-  rb_define_const(ph_ir, "LENGTH_CONSTANT", INT2FIX(PHIDGET_IR_LENGTH_CONSTANT));
-  /* Variable - the bitstream has a variable length with a constant gap */
-  rb_define_const(ph_ir, "LENGTH_VARIABLE", INT2FIX(PHIDGET_IR_LENGTH_VARIABLE));
-
-  /* Document-method: new
-   * call-seq: new
-   *
-   * Creates a Phidget IR object.
-   */
-  rb_define_method(ph_ir, "initialize", ph_ir_init, 0);
-
-  /* Document-method: transmit
-   * call-seq: transmit(data, code_info)
-   *
-   * ** NOT IMPLEMENTED **
-   */
-  rb_define_method(ph_ir, "transmit", ph_ir_transmit, 2);
-
-  /* Document-method: transmitRepeat
-   * call-seq: transmitRepeat
-   *
-   * Transmits a repeat of the last transmited code. Depending of the CodeInfo structure,
-   * this may be a retransmission of the code itself, or there may be a special repeat code.
-   */
-  rb_define_method(ph_ir, "transmitRepeat", ph_ir_transmit_repeat, 0);
-
-  /* Document-method: transmitRaw
-   * call-seq: transmitRaw(data, carrier_frequency, duty_cycle, gap)
-   *
-   * Transmits RAW data as a series of pulses and spaces.
-   */
-  rb_define_method(ph_ir, "transmitRaw", ph_ir_transmit_raw, 4);
-
-  /* Document-method: getRawData
-   * call-seq: getRawData(max_length) -> raw_data
-   *
-   * Read any available raw data. This should be polled continuously (every 20ms) to avoid missing data.
-   * Read data always starts with a space and ends with a pulse.
-   */
-  rb_define_method(ph_ir, "getRawData", ph_ir_get_raw_data, 1);
-
-  /* Document-method: getLastCode
-   * call-seq: getLastCode -> code
-   *
-   * ** NOT IMPLEMENTED **
-   */
-  rb_define_method(ph_ir, "getLastCode", ph_ir_get_last_code, 0);
-
-  /* Document-method: getLastLearnedCode
-   * call-seq: getLastLearnedCode -> code
-   *
-   * ** NOT IMPLEMENTED **
-   */
-  rb_define_method(ph_ir, "getLastLearnedCode", ph_ir_get_last_learned_code, 0);
-
-#ifdef PH_CALLBACK
-  rb_define_private_method(ph_ir, "ext_setOnCodeHandler", ph_ir_set_on_code_handler, 1);
-  rb_define_private_method(ph_ir, "ext_setOnLearnHandler", ph_ir_set_on_learn_handler, 1);
-  rb_define_private_method(ph_ir, "ext_setOnRawDataHandler", ph_ir_set_on_raw_data_handler, 1);
-#endif
-
-  rb_define_alias(ph_ir, "transmit_repeat", "transmitRepeat");
-  rb_define_alias(ph_ir, "transmit_raw", "transmitRaw");
-  rb_define_alias(ph_ir, "raw_data", "getRawData");
-  rb_define_alias(ph_ir, "last_code", "getLastCode");
-  rb_define_alias(ph_ir, "last_learned_code", "getLastLearnedCode");
-}
+#define IR_CODE_CALLBACK      0
+#define IR_LEARN_CALLBACK     1
+#define IR_RAW_DATA_CALLBACK  2
 
 
 
 VALUE ph_ir_init(VALUE self) {
   ph_data_t *ph = get_ph_data(self);
-  ph_raise(CPhidgetIR_create((CPhidgetIRHandle *)(&(ph->handle))));
+  ph_raise(PhidgetIR_create((PhidgetIRHandle *)(&(ph->handle))));
   return self;
 }
 
-VALUE ph_ir_transmit(VALUE self, VALUE data, VALUE code_info) {
-  ph_raise(EPHIDGET_NOTIMPLEMENTED);
+
+VALUE ph_ir_transmit(VALUE self, VALUE code, VALUE code_info) {
+  PhidgetIRHandle handle = (PhidgetIRHandle)get_ph_handle(self);
+  PhidgetIR_CodeInfo info;
+  int i;
+
+  if(! RB_TYPE_P(code, T_STRING)) ph_raise(EPHIDGET_INVALIDARG);
+  if(! RB_TYPE_P(code_info, T_HASH)) ph_raise(EPHIDGET_INVALIDARG);
+
+  info.bitCount = NUM2UINT(rb_hash_aref(code_info, rb_str_new2("bitCount")));
+  info.encoding = NUM2INT(rb_hash_aref(code_info, rb_str_new2("encoding")));
+  info.length = NUM2INT(rb_hash_aref(code_info, rb_str_new2("length")));
+  info.gap = NUM2UINT(rb_hash_aref(code_info, rb_str_new2("gap")));
+  info.trail = NUM2UINT(rb_hash_aref(code_info, rb_str_new2("trail")));
+  for(i=0; i<2; i++) { info.header[i] = NUM2UINT(rb_ary_entry(rb_hash_aref(code_info, rb_str_new2("header")), i)); }
+  for(i=0; i<2; i++) { info.one[i] = NUM2UINT(rb_ary_entry(rb_hash_aref(code_info, rb_str_new2("one")), i)); }
+  for(i=0; i<2; i++) { info.zero[i] = NUM2UINT(rb_ary_entry(rb_hash_aref(code_info, rb_str_new2("zero")), i)); }
+  for(i=0; i<26; i++) { info.repeat[i] = NUM2UINT(rb_ary_entry(rb_hash_aref(code_info, rb_str_new2("repeat")), i)); }
+  info.minRepeat = NUM2UINT(rb_hash_aref(code_info, rb_str_new2("minRepeat")));
+  info.dutyCycle = NUM2DBL(rb_hash_aref(code_info, rb_str_new2("dutyCycle")));
+  info.carrierFrequency = NUM2UINT(rb_hash_aref(code_info, rb_str_new2("carrierFrequency")));
+  for(i=0; i<33; i++) { info.toggleMask[i] = NUM2CHR(rb_ary_entry(rb_hash_aref(code_info, rb_str_new2("toggleMask")), i)); }
+
+  ph_raise(PhidgetIR_transmit(handle, StringValuePtr(code), &info));
   return Qnil;
 }
 
+
 VALUE ph_ir_transmit_repeat(VALUE self) {
-  CPhidgetIRHandle handle = (CPhidgetIRHandle)get_ph_handle(self);
-  ph_raise(CPhidgetIR_TransmitRepeat(handle));
+  ph_raise(PhidgetIR_transmitRepeat((PhidgetIRHandle)get_ph_handle(self)));
   return Qnil;
 }
 
+
 VALUE ph_ir_transmit_raw(VALUE self, VALUE data, VALUE carrier_freq, VALUE duty_cycle, VALUE gap) {
-  CPhidgetIRHandle handle = (CPhidgetIRHandle)get_ph_handle(self);
-  int data_length = RARRAY_LEN(data);
-  int *int_data = (int *)malloc(data_length * sizeof(int));
-  int i;
+  PhidgetIRHandle handle = (PhidgetIRHandle)get_ph_handle(self);
+  size_t data_length = RARRAY_LEN(data);
+  uint32_t raw_data[200];
+  size_t i;
 
-  for(i=0; i<data_length; i++) {
-    int_data[i] = NUM2INT(rb_ary_entry(data, i));
-  }
+  for(i=0; i<data_length; i++) { raw_data[i] = NUM2UINT(rb_ary_entry(data, i)); }
+  ph_raise(PhidgetIR_transmitRaw(handle, raw_data, data_length, NUM2UINT(carrier_freq), NUM2DBL(duty_cycle), NUM2UINT(gap)));
+  return Qnil;
+}
 
-  ph_raise(CPhidgetIR_TransmitRaw(handle, int_data, data_length, FIX2INT(carrier_freq), FIX2INT(duty_cycle), FIX2INT(gap)));
 
-  free(int_data);
-  return Qnil;
+VALUE ph_ir_get_last_code(VALUE self) {
+  PhidgetIRHandle handle = (PhidgetIRHandle)get_ph_handle(self);
+  char code[IR_MAX_CODE_STR_LENGTH];
+  uint32_t bitCount;
+  VALUE rb_code_data = rb_hash_new();
+
+  ph_raise(PhidgetIR_getLastCode(handle, code, IR_MAX_CODE_STR_LENGTH, &bitCount));
+  rb_hash_aset(rb_code_data, rb_str_new2("code"), rb_str_new2(code));
+  rb_hash_aset(rb_code_data, rb_str_new2("bitCount"), UINT2NUM(bitCount));
+  return rb_code_data;
 }
 
-VALUE ph_ir_get_raw_data(VALUE self, VALUE length) {
-  CPhidgetIRHandle handle = (CPhidgetIRHandle)get_ph_handle(self);
-  int data_length = FIX2INT(length);
-  int *raw_data = (int *)malloc(data_length * sizeof(int));
-  VALUE rb_data;
-  int i;
 
-  ph_raise(CPhidgetIR_getRawData(handle, raw_data, &data_length));
+VALUE ph_ir_get_last_learned_code(VALUE self) {
+  PhidgetIRHandle handle = (PhidgetIRHandle)get_ph_handle(self);
+  char code[IR_MAX_CODE_STR_LENGTH];
+  PhidgetIR_CodeInfo info;
+  VALUE rb_code_data = rb_hash_new();
+  VALUE rb_code_info = rb_hash_new();
+  VALUE rb_info_header = rb_ary_new();
+  VALUE rb_info_one = rb_ary_new();
+  VALUE rb_info_zero = rb_ary_new();
+  VALUE rb_info_repeat = rb_ary_new();
+  VALUE rb_info_toggle_mask = rb_ary_new();
+  int i;
 
-  rb_data = rb_ary_new();
-  for(i=0; i<data_length; i++) {
-    rb_ary_push(rb_data, INT2NUM(raw_data[i]));
-  }
-  free(raw_data);
-  return Qnil;
+  ph_raise(PhidgetIR_getLastLearnedCode(handle, code, IR_MAX_CODE_STR_LENGTH, &info));
+
+  rb_hash_aset(rb_code_info, rb_str_new2("bitCount"), UINT2NUM(info.bitCount));
+  rb_hash_aset(rb_code_info, rb_str_new2("encoding"), INT2NUM(info.encoding));
+  rb_hash_aset(rb_code_info, rb_str_new2("length"), INT2NUM(info.length));
+  rb_hash_aset(rb_code_info, rb_str_new2("gap"), UINT2NUM(info.gap));
+  rb_hash_aset(rb_code_info, rb_str_new2("trail"), UINT2NUM(info.trail));
+  for(i=0; i<2; i++) { rb_ary_push(rb_info_header, UINT2NUM(info.header[i])); }
+  rb_hash_aset(rb_code_info, rb_str_new2("header"), rb_info_header);
+  for(i=0; i<2; i++) { rb_ary_push(rb_info_one, UINT2NUM(info.one[i])); }
+  rb_hash_aset(rb_code_info, rb_str_new2("one"), rb_info_one);
+  for(i=0; i<2; i++) { rb_ary_push(rb_info_zero, UINT2NUM(info.zero[i])); }
+  rb_hash_aset(rb_code_info, rb_str_new2("zero"), rb_info_zero);
+  for(i=0; i<26; i++) { rb_ary_push(rb_info_repeat, UINT2NUM(info.repeat[i])); }
+  rb_hash_aset(rb_code_info, rb_str_new2("repeat"), rb_info_repeat);
+  rb_hash_aset(rb_code_info, rb_str_new2("minRepeat"), UINT2NUM(info.minRepeat));
+  rb_hash_aset(rb_code_info, rb_str_new2("dutyCycle"), DBL2NUM(info.dutyCycle));
+  rb_hash_aset(rb_code_info, rb_str_new2("carrierFrequency"), UINT2NUM(info.carrierFrequency));
+  for(i=0; i<33; i++) { rb_ary_push(rb_info_toggle_mask, INT2NUM(info.toggleMask[i])); }
+  rb_hash_aset(rb_code_info, rb_str_new2("toggleMask"), rb_info_toggle_mask);
+
+  rb_hash_aset(rb_code_data, rb_str_new2("code"), rb_str_new2(code));
+  rb_hash_aset(rb_code_data, rb_str_new2("codeInfo"), rb_code_info);
+  return rb_code_data;
 }
 
-VALUE ph_ir_get_last_code(VALUE self) {
-  ph_raise(EPHIDGET_NOTIMPLEMENTED);
-  return Qnil;
-}
 
-VALUE ph_ir_get_last_learned_code(VALUE self) {
-  ph_raise(EPHIDGET_NOTIMPLEMENTED);
-  return Qnil;
+void CCONV ph_ir_on_code(PhidgetIRHandle phid, void *userPtr, const char *code, uint32_t bitCount, int repeat) {
+  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(code);
+  callback_data->arg2 = UINT2NUM(bitCount);
+  callback_data->arg3 = INT2NUM(repeat);
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
 }
 
 
-#ifdef PH_CALLBACK
 VALUE ph_ir_set_on_code_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
-  ph_callback_data_t *callback_data = &ph->dev_callback_1;
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[IR_CODE_CALLBACK];
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidgetIR_set_OnCode_Handler((CPhidgetIRHandle)ph->handle, NULL, (void *)NULL));
+    ph_raise(PhidgetIR_setOnCodeHandler((PhidgetIRHandle)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(CPhidgetIR_set_OnCode_Handler((CPhidgetIRHandle)ph->handle, ph_ir_on_code, (void *)callback_data));
+    ph_raise(PhidgetIR_setOnCodeHandler((PhidgetIRHandle)ph->handle, ph_ir_on_code, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
 }
 
 
+void CCONV ph_ir_on_learn(PhidgetIRHandle phid, void *userPtr, const char *code, PhidgetIR_CodeInfo *codeInfo) {
+  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_ir_set_on_learn_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
-  ph_callback_data_t *callback_data = &ph->dev_callback_2;
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[IR_LEARN_CALLBACK];
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidgetIR_set_OnLearn_Handler((CPhidgetIRHandle)ph->handle, NULL, (void *)NULL));
+    ph_raise(PhidgetIR_setOnLearnHandler((PhidgetIRHandle)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(CPhidgetIR_set_OnLearn_Handler((CPhidgetIRHandle)ph->handle, ph_ir_on_learn, (void *)callback_data));
+    ph_raise(PhidgetIR_setOnLearnHandler((PhidgetIRHandle)ph->handle, ph_ir_on_learn, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
 }
 
 
+void CCONV ph_ir_on_raw_data(PhidgetIRHandle phid, void *userPtr, const uint32_t *data, size_t dataLen) {
+  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_ir_set_on_raw_data_handler(VALUE self, VALUE handler) {
   ph_data_t *ph = get_ph_data(self);
-  ph_callback_data_t *callback_data = &ph->dev_callback_3;
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[IR_RAW_DATA_CALLBACK];
   if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
     callback_data->exit = true;
-    ph_raise(CPhidgetIR_set_OnRawData_Handler((CPhidgetIRHandle)ph->handle, NULL, (void *)NULL));
+    ph_raise(PhidgetIR_setOnRawDataHandler((PhidgetIRHandle)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(CPhidgetIR_set_OnRawData_Handler((CPhidgetIRHandle)ph->handle, ph_ir_on_raw_data, (void *)callback_data));
+    ph_raise(PhidgetIR_setOnRawDataHandler((PhidgetIRHandle)ph->handle, ph_ir_on_raw_data, (void *)callback_data));
     ph_callback_thread(callback_data);
   }
   return Qnil;
 }
 
 
-int ph_ir_on_code(CPhidgetIRHandle phid, void *userPtr, unsigned char *data, int dataLength, int bitCount, int repeat) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
-}
+void Init_ir() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_ir = rb_define_class_under(ph_module, "IR", ph_common);
 
+  rb_define_const(ph_ir, "ENCODING_UNKNOWN", INT2NUM(IR_ENCODING_UNKNOWN));
+  rb_define_const(ph_ir, "ENCODING_SPACE", INT2NUM(IR_ENCODING_SPACE));
+  rb_define_const(ph_ir, "ENCODING_PULSE", INT2NUM(IR_ENCODING_PULSE));
+  rb_define_const(ph_ir, "ENCODING_BIPHASE", INT2NUM(IR_ENCODING_BIPHASE));
+  rb_define_const(ph_ir, "ENCODING_RC5", INT2NUM(IR_ENCODING_RC5));
+  rb_define_const(ph_ir, "ENCODING_RC6", INT2NUM(IR_ENCODING_RC6));
 
-int ph_ir_on_learn(CPhidgetIRHandle phid, void *userPtr, unsigned char *data, int dataLength, CPhidgetIR_CodeInfoHandle codeInfo) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
-}
+  rb_define_const(ph_ir, "LENGTH_UNKNOWN", INT2NUM(IR_LENGTH_UNKNOWN));
+  rb_define_const(ph_ir, "LENGTH_CONSTANT", INT2NUM(IR_LENGTH_CONSTANT));
+  rb_define_const(ph_ir, "LENGTH_VARIABLE", INT2NUM(IR_LENGTH_VARIABLE));
 
 
-int ph_ir_on_raw_data(CPhidgetIRHandle phid, void *userPtr, int *data, int dataLength) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
-}
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget IR object.
+   */
+  rb_define_method(ph_ir, "initialize", ph_ir_init, 0);
 
-#endif
+  /* Document-method: transmit
+   * call-seq: transmit(code, code_info)
+   *
+   * Transmits a code
+   * code data is transmitted MSBit first.
+   * MSByte is in array index 0 of code
+   * LSBit is right justified, therefore, MSBit may be in bit position 0-7 (of array index 0) depending on the bit count
+   */
+  rb_define_method(ph_ir, "transmit", ph_ir_transmit, 2);
+
+  /* Document-method: transmitRepeat
+   * call-seq: transmitRepeat
+   *
+   * Transmits a repeat of the last transmited code.
+   * Depending on the CodeInfo structure, this may be a retransmission of the code itself, or there may be a special repeat code.
+   */
+  rb_define_method(ph_ir, "transmitRepeat", ph_ir_transmit_repeat, 0);
+  rb_define_alias(ph_ir, "transmit_repeat", "transmitRepeat");
+
+  /* Document-method: transmitRaw
+   * call-seq: transmitRaw(data, carrier_frequency, duty_cycle, gap)
+   *
+   * Transmits raw data as a series of pulses and spaces.
+   * data must start and end with a pulse.
+   *   Each element is a positive time in μs
+   * dataLength has a maximum length of 200, however, streams should be kept must shorter than this (less than 100ms between gaps).
+   *   dataLength must be an odd number
+   * Leave carrierFrequency as 0 for default.
+   *   carrierFrequency has a range of 10kHz - 1MHz
+   * Leave dutyCycle as 0 for default
+   *   dutyCycle can have a value between 0.1 and 0.5
+   * Specifying a gap will guarantee a gap time (no transmitting) after data is sent.
+   *   gap time is in μs
+   *   gap time can be set to 0
+   */
+  rb_define_method(ph_ir, "transmitRaw", ph_ir_transmit_raw, 4);
+  rb_define_alias(ph_ir, "transmit_raw", "transmitRaw");
+
+  /* Document-method: getLastCode
+   * call-seq: getLastCode -> code
+   *
+   * The last code the channel has received.
+   * The code is represented by a hexadecimal string (array of bytes)
+   */
+  rb_define_method(ph_ir, "getLastCode", ph_ir_get_last_code, 0);
+  rb_define_alias(ph_ir, "last_code", "getLastCode");
+
+  /* Document-method: getLastLearnedCode
+   * call-seq: getLastLearnedCode -> code
+   *
+   * The last code the channel has learned.
+   * The code is represented by a hexadecimal string (array of bytes).
+   * The codeInfo structure holds data that describes the learned code
+   */
+  rb_define_method(ph_ir, "getLastLearnedCode", ph_ir_get_last_learned_code, 0);
+  rb_define_alias(ph_ir, "last_learned_code", "getLastLearnedCode");
+
+
+  rb_define_private_method(ph_ir, "ext_setOnCodeHandler", ph_ir_set_on_code_handler, 1);
+  rb_define_private_method(ph_ir, "ext_setOnLearnHandler", ph_ir_set_on_learn_handler, 1);
+  rb_define_private_method(ph_ir, "ext_setOnRawDataHandler", ph_ir_set_on_raw_data_handler, 1);
+}