phidgets 0.0.5 → 0.1.0

data/ext/phidgets/phidgets_frequency_counter.c

@@ -0,0 +1,241 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_freq_init(VALUE self);
+VALUE ph_freq_get_frequency_input_count(VALUE self);
+VALUE ph_freq_reset(VALUE self, VALUE index);
+VALUE ph_freq_get_frequency(VALUE self, VALUE index);
+VALUE ph_freq_get_total_time(VALUE self, VALUE index);
+VALUE ph_freq_get_total_count(VALUE self, VALUE index);
+VALUE ph_freq_get_timeout(VALUE self, VALUE index);
+VALUE ph_freq_set_timeout(VALUE self, VALUE index, VALUE timeout);
+VALUE ph_freq_get_enabled(VALUE self, VALUE index);
+VALUE ph_freq_set_enabled(VALUE self, VALUE index, VALUE state);
+VALUE ph_freq_get_filter(VALUE self, VALUE index);
+VALUE ph_freq_set_filter(VALUE self, VALUE index, VALUE filter);
+
+#ifdef PH_CALLBACK
+VALUE ph_freq_set_on_count_handler(VALUE self, VALUE handler);
+int ph_freq_on_count(CPhidgetFrequencyCounterHandle phid, void *userPtr, int index, int time, int counts);
+#endif
+
+
+VALUE Init_phidgets_freq(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_freq = rb_define_class_under(ph_module, "FrequencyCounter", ph_common);
+
+  rb_define_const(ph_freq, "FILTERTYPE_ZERO_CROSSING", INT2FIX(PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_ZERO_CROSSING));
+  rb_define_const(ph_freq, "FILTERTYPE_LOGIC_LEVEL", INT2FIX(PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_LOGIC_LEVEL));
+  rb_define_const(ph_freq, "FILTERTYPE_UNKNOWN", INT2FIX(PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_UNKNOWN));
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget FrequencyCounter object.
+   */
+  rb_define_method(ph_freq, "initialize", ph_freq_init, 0);
+
+  /* Document-method: getFrequencyInputCount
+   * call-seq: getFrequencyInputCount -> count
+   *
+   * Gets the number of inputs supported by this phidget frequency counter.
+   */
+  rb_define_method(ph_freq, "getFrequencyInputCount", ph_freq_get_frequency_input_count, 0);
+
+  /* Document-method: reset
+   * call-seq: reset(index)
+   *
+   * Resets total count and total time for an input.
+   */
+  rb_define_method(ph_freq, "reset", ph_freq_reset, 1);
+
+  /* Document-method: getFrequency
+   * call-seq: getFrequency(index) -> frequency
+   *
+   * Gets the measured frequency of an input, in Hz.
+   */
+  rb_define_method(ph_freq, "getFrequency", ph_freq_get_frequency, 1);
+
+  /* Document-method: getTotalTime
+   * call-seq: getTotalTime(index) -> time
+   *
+   * Gets the total time that has passed since the last reset on this input, in microseconds.
+   */
+  rb_define_method(ph_freq, "getTotalTime", ph_freq_get_total_time, 1);
+
+  /* Document-method: getTotalCount
+   * call-seq: getTotalCount(index) -> count
+   *
+   * Gets the total number of ticks that have happened since the last reset on this input.
+   */
+  rb_define_method(ph_freq, "getTotalCount", ph_freq_get_total_count, 1);
+
+  /* Document-method: getTimeout
+   * call-seq: getTimeout(index) -> timeout
+   *
+   * Gets the timeout value for an input, in microseconds. This controls the lowest measurable frequency.
+   */
+  rb_define_method(ph_freq, "getTimeout", ph_freq_get_timeout, 1);
+
+  /* Document-method: setTimeout
+   * call-seq: setTimeout(index, timeout)
+   *
+   * Sets the timeout value for an input, in microseconds.
+   */
+  rb_define_method(ph_freq, "setTimeout", ph_freq_set_timeout, 2);
+
+  /* Document-method: getEnabled
+   * call-seq: getEnabled(index) -> true or false
+   *
+   * Gets the enabled state for an input.
+   */
+  rb_define_method(ph_freq, "getEnabled", ph_freq_get_enabled, 1);
+
+  /* Document-method: setEnabled
+   * call-seq: setEnabled(index, state)
+   *
+   * Sets the enabled state for an input.
+   */
+  rb_define_method(ph_freq, "setEnabled", ph_freq_set_enabled, 2);
+
+  /* Document-method: getFilter
+   * call-seq: getFilter(index) -> filter_type
+   *
+   * Gets the filter type for an input.
+   */
+  rb_define_method(ph_freq, "getFilter", ph_freq_get_filter, 1);
+
+  /* Document-method: setFilter
+   * call-seq: setFilter(index, filter_type)
+   *
+   * Sets the filter type for an input.
+   */
+  rb_define_method(ph_freq, "setFilter", ph_freq_set_filter, 2);
+
+#ifdef PH_CALLBACK
+  rb_define_private_method(ph_freq, "ext_setOnCountHandler", ph_freq_set_on_count_handler, 1);
+#endif
+
+  rb_define_alias(ph_freq, "frequency_input_count", "getFrequencyInputCount");
+  rb_define_alias(ph_freq, "frequency", "getFrequency");
+  rb_define_alias(ph_freq, "total_time", "getTotalTime");
+  rb_define_alias(ph_freq, "total_count", "getTotalCount");
+  rb_define_alias(ph_freq, "timeout", "getTimeout");
+  rb_define_alias(ph_freq, "set_timeout", "setTimeout");
+  rb_define_alias(ph_freq, "enabled?", "getEnabled");
+  rb_define_alias(ph_freq, "set_enabled", "setEnabled");
+  rb_define_alias(ph_freq, "filter", "getFilter");
+  rb_define_alias(ph_freq, "set_filter", "setFilter");
+
+  return ph_freq;
+}
+
+
+
+VALUE ph_freq_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetFrequencyCounter_create((CPhidgetFrequencyCounterHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_freq_get_frequency_input_count(VALUE self) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetFrequencyCounter_getFrequencyInputCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_freq_reset(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  ph_raise(CPhidgetFrequencyCounter_reset(handle, FIX2INT(index)));
+  return Qnil;
+}
+
+VALUE ph_freq_get_frequency(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  double freq;
+  ph_raise(CPhidgetFrequencyCounter_getFrequency(handle, FIX2INT(index), &freq));
+  return rb_float_new(freq);
+}
+
+VALUE ph_freq_get_total_time(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  __int64 time;
+  ph_raise(CPhidgetFrequencyCounter_getTotalTime(handle, FIX2INT(index), &time));
+  return INT2NUM(time);
+}
+
+VALUE ph_freq_get_total_count(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  __int64 count;
+  ph_raise(CPhidgetFrequencyCounter_getTotalCount(handle, FIX2INT(index), &count));
+  return INT2NUM(count);
+}
+
+VALUE ph_freq_get_timeout(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  int timeout;
+  ph_raise(CPhidgetFrequencyCounter_getTimeout(handle, FIX2INT(index), &timeout));
+  return INT2FIX(timeout);
+}
+
+VALUE ph_freq_set_timeout(VALUE self, VALUE index, VALUE timeout) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  ph_raise(CPhidgetFrequencyCounter_setTimeout(handle, FIX2INT(index), FIX2INT(timeout)));
+  return Qnil;
+}
+
+VALUE ph_freq_get_enabled(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  int state;
+  ph_raise(CPhidgetFrequencyCounter_getEnabled(handle, FIX2INT(index), &state));
+  return state == PTRUE ? Qtrue : Qfalse;
+}
+
+VALUE ph_freq_set_enabled(VALUE self, VALUE index, VALUE state) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  ph_raise(CPhidgetFrequencyCounter_setEnabled(handle, FIX2INT(index), TYPE(state) == T_TRUE ? PTRUE : PFALSE));
+  return Qnil;
+}
+
+VALUE ph_freq_get_filter(VALUE self, VALUE index) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  CPhidgetFrequencyCounter_FilterType filter;
+  ph_raise(CPhidgetFrequencyCounter_getFilter(handle, FIX2INT(index), &filter));
+  return INT2FIX(filter);
+}
+
+VALUE ph_freq_set_filter(VALUE self, VALUE index, VALUE filter) {
+  CPhidgetFrequencyCounterHandle handle = (CPhidgetFrequencyCounterHandle)get_ph_handle(self);
+  ph_raise(CPhidgetFrequencyCounter_setFilter(handle, FIX2INT(index), FIX2INT(filter)));
+  return Qnil;
+}
+
+
+#ifdef PH_CALLBACK
+VALUE ph_freq_set_on_count_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callback_1;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetFrequencyCounter_set_OnCount_Handler((CPhidgetFrequencyCounterHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetFrequencyCounter_set_OnCount_Handler((CPhidgetFrequencyCounterHandle)ph->handle, ph_freq_on_count, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+int ph_freq_on_count(CPhidgetFrequencyCounterHandle phid, void *userPtr, int index, int time, int counts) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+#endif
+

data/ext/phidgets/phidgets_gps.c

@@ -0,0 +1,235 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_gps_init(VALUE self);
+VALUE ph_gps_get_latitude(VALUE self);
+VALUE ph_gps_get_longitude(VALUE self);
+VALUE ph_gps_get_altitude(VALUE self);
+VALUE ph_gps_get_heading(VALUE self);
+VALUE ph_gps_get_velocity(VALUE self);
+VALUE ph_gps_get_time(VALUE self);
+VALUE ph_gps_get_date(VALUE self);
+VALUE ph_gps_get_position_fix_status(VALUE self);
+VALUE ph_gps_get_nmea_data(VALUE self);
+
+#ifdef PH_CALLBACK
+VALUE ph_gps_set_on_position_change_handler(VALUE self, VALUE handler);
+VALUE ph_gps_set_on_position_fix_status_change_handler(VALUE self, VALUE handler);
+int ph_gps_on_position_change(CPhidgetGPSHandle phid, void *userPtr, double latitude, double longitude, double altitude);
+int ph_gps_on_position_fix_status_change(CPhidgetGPSHandle phid, void *userPtr, int status);
+#endif
+
+
+VALUE Init_phidgets_gps(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_gps = rb_define_class_under(ph_module, "GPS", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget GPS object.
+   */
+  rb_define_method(ph_gps, "initialize", ph_gps_init, 0);
+
+  /* Document-method: getLatitude
+   * call-seq: getLatitude -> latitude
+   *
+   * Gets the current latitude.
+   */
+  rb_define_method(ph_gps, "getLatitude", ph_gps_get_latitude, 0);
+
+  /* Document-method: getLongitude
+   * call-seq: getLongitude -> longitude
+   *
+   * Gets the current longitude.
+   */
+  rb_define_method(ph_gps, "getLongitude", ph_gps_get_longitude, 0);
+
+  /* Document-method: getAltitude
+   * call-seq: getAltitude -> altitude
+   *
+   * Gets the current altitude, in meters.
+   */
+  rb_define_method(ph_gps, "getAltitude", ph_gps_get_altitude, 0);
+
+  /* Document-method: getHeading
+   * call-seq: getHeading -> heading
+   *
+   * Gets the current heading, in degrees.
+   */
+  rb_define_method(ph_gps, "getHeading", ph_gps_get_heading, 0);
+
+  /* Document-method: getVelocity
+   * call-seq: getVelocity -> velocity
+   *
+   * Gets the current velocity, in km/h.
+   */
+  rb_define_method(ph_gps, "getVelocity", ph_gps_get_velocity, 0);
+
+  /* Document-method: getTime
+   * call-seq: getTime -> time
+   *
+   * Gets the current GPS time, in UTC, as an array [hour, minute, second, millisecond].
+   */
+  rb_define_method(ph_gps, "getTime", ph_gps_get_time, 0);
+
+  /* Document-method: getDate
+   * call-seq: getDate -> date
+   *
+   * Gets the current GPS date, in UTC, as an array [year, month, day].
+   */
+  rb_define_method(ph_gps, "getDate", ph_gps_get_date, 0);
+
+  /* Document-method: getPositionFixStatus
+   * call-seq: getPositionFixStatus -> status
+   *
+   * Gets the position fix status.
+   */
+  rb_define_method(ph_gps, "getPositionFixStatus", ph_gps_get_position_fix_status, 0);
+
+  /* Document-method: getNMEAData
+   * call-seq: getNMEAData -> data
+   *
+   * ** NOT IMPLEMENTED **
+   */
+  rb_define_method(ph_gps, "getNMEAData", ph_gps_get_nmea_data, 0);
+#ifdef PH_CALLBACK
+  rb_define_private_method(ph_gps, "ext_setOnPositionChangeHandler", ph_gps_set_on_position_change_handler, 1);
+  rb_define_private_method(ph_gps, "ext_setOnPositionFixStatusChangeHandler", ph_gps_set_on_position_fix_status_change_handler, 1);
+#endif
+
+  rb_define_alias(ph_gps, "latitude", "getLatitude");
+  rb_define_alias(ph_gps, "longitude", "getLongitude");
+  rb_define_alias(ph_gps, "altitude", "getAltitude");
+  rb_define_alias(ph_gps, "heading", "getHeading");
+  rb_define_alias(ph_gps, "velocity", "getVelocity");
+  rb_define_alias(ph_gps, "time", "getTime");
+  rb_define_alias(ph_gps, "date", "getDate");
+  rb_define_alias(ph_gps, "position_fix_status", "getPositionFixStatus");
+  rb_define_alias(ph_gps, "nmea_data", "getNMEAData");
+
+  return ph_gps;
+}
+
+
+
+VALUE ph_gps_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetGPS_create((CPhidgetGPSHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_gps_get_latitude(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  double latitude;
+  ph_raise(CPhidgetGPS_getLatitude(handle, &latitude));
+  return rb_float_new(latitude);
+}
+
+VALUE ph_gps_get_longitude(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  double longitude;
+  ph_raise(CPhidgetGPS_getLongitude(handle, &longitude));
+  return rb_float_new(longitude);
+}
+
+VALUE ph_gps_get_altitude(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  double altitude;
+  ph_raise(CPhidgetGPS_getAltitude(handle, &altitude));
+  return rb_float_new(altitude);
+}
+
+VALUE ph_gps_get_heading(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  double heading;
+  ph_raise(CPhidgetGPS_getHeading(handle, &heading));
+  return rb_float_new(heading);
+}
+
+VALUE ph_gps_get_velocity(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  double velocity;
+  ph_raise(CPhidgetGPS_getVelocity(handle, &velocity));
+  return rb_float_new(velocity);
+}
+
+VALUE ph_gps_get_time(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  GPSTime time;
+  ph_raise(CPhidgetGPS_getTime(handle, &time));
+  return rb_ary_new3(4, INT2FIX(time.tm_hour), INT2FIX(time.tm_min), INT2FIX(time.tm_sec), INT2FIX(time.tm_ms));
+}
+
+VALUE ph_gps_get_date(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  GPSDate date;
+  ph_raise(CPhidgetGPS_getDate(handle, &date));
+  return rb_ary_new3(3, INT2FIX(date.tm_year), INT2FIX(date.tm_mon), INT2FIX(date.tm_mday));
+}
+
+VALUE ph_gps_get_position_fix_status(VALUE self) {
+  CPhidgetGPSHandle handle = (CPhidgetGPSHandle)get_ph_handle(self);
+  int state;
+  ph_raise(CPhidgetGPS_getPositionFixStatus(handle, &state));
+  return INT2FIX(state);
+}
+
+VALUE ph_gps_get_nmea_data(VALUE self) {
+  ph_raise(EPHIDGET_NOTIMPLEMENTED);
+  return Qnil;
+}
+
+
+#ifdef PH_CALLBACK
+VALUE ph_gps_set_on_position_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callback_1;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetGPS_set_OnPositionChange_Handler((CPhidgetGPSHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetGPS_set_OnPositionChange_Handler((CPhidgetGPSHandle)ph->handle, ph_gps_on_position_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+VALUE ph_gps_set_on_position_fix_status_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callback_2;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetGPS_set_OnPositionFixStatusChange_Handler((CPhidgetGPSHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetGPS_set_OnPositionFixStatusChange_Handler((CPhidgetGPSHandle)ph->handle, ph_gps_on_position_fix_status_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+int ph_gps_on_position_change(CPhidgetGPSHandle phid, void *userPtr, double latitude, double longitude, double altitude) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+
+int ph_gps_on_position_fix_status_change(CPhidgetGPSHandle phid, void *userPtr, int status) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+#endif
+