phidgets_native 0.1.0

data/ext/phidgets_native/gps_ruby.c

@@ -0,0 +1,212 @@
+#include "phidgets_native.h"
+
+/* 
+ * Document-class: PhidgetsNative::GPS < PhidgetsNative::Device
+ *
+ * This class provides functionality specific to the "GPS" device class. 
+ * Primarily, this includes reporting of latitude/longitude, velocity/heading 
+ * and time.
+ */
+
+void Init_phidgets_native_gps(VALUE m_Phidget) {
+  VALUE c_Device = rb_const_get(m_Phidget, rb_intern("Device"));
+
+  VALUE c_Gps = rb_define_class_under(m_Phidget,"GPS",c_Device);
+
+  /*
+   * Document-method: new
+   * call-seq:
+   *   new(serial_number)
+   *
+   * All phidget objects are created from the device serial number. Serial numbers
+   * are required to be Fixnums (aka "unsigned integers").
+   */
+  rb_define_method(c_Gps, "initialize", gps_initialize, 1);
+
+  /*
+   * Document-method: close
+   * call-seq:
+   *   close -> nil
+   *
+   * This method will unregister the phidget event handlers, and free up all
+   * API resources associated with the phidget. This is an optional, but useful
+   * way to remove the object's overhead before the GC kicks in and actually 
+   * frees the resource.
+   */
+  rb_define_method(c_Gps, "close", gps_close, 0);
+
+  /*
+   * Document-method: sample_rate
+   * call-seq:
+   *   sample_rate -> FixNum
+   *
+   * For most Phidgets, an event handler processes the device state changes at
+   * some regular interval. For these devices, this method will return the rate
+   * of state changes measured in Hz.
+   */
+  rb_define_method(c_Gps, "sample_rate", gps_sample_rate, 0);
+
+  /*
+   * Document-method: latitude
+   * call-seq:
+   *   latitude -> Float
+   *
+   * Returns the current latititude, as reported by the most recent gps update.
+   */
+  rb_define_method(c_Gps, "latitude", gps_latitude, 0);
+  
+  /*
+   * Document-method: longitude
+   * call-seq:
+   *   longitude -> Float
+   *
+   * Returns the current longitude, as reported by the most recent gps update.
+   */
+  rb_define_method(c_Gps, "longitude", gps_longitude, 0);
+
+  /*
+   * Document-method: altitude
+   * call-seq:
+   *   altitude -> Float
+   *
+   * Returns the current altitude in meters, as reported by the most recent gps update.
+   */
+  rb_define_method(c_Gps, "altitude", gps_altitude, 0);
+
+  /*
+   * Document-method: heading
+   * call-seq:
+   *   heading -> Float
+   *
+   * Returns the current heading in degrees, as reported by the most recent gps update.
+   */
+  rb_define_method(c_Gps, "heading", gps_heading, 0);
+
+  /*
+   * Document-method: velocity
+   * call-seq:
+   *   velocity -> Float
+   *
+   * Returns the current velocity in km/h, as reported by the most recent gps update.
+   */
+  rb_define_method(c_Gps, "velocity", gps_velocity, 0);
+
+  /*
+   * Document-method: is_fixed?
+   * call-seq:
+   *   is_fixed? -> Boolean
+   *
+   * Returns true or false, indicating whether the gps is fixed (aka "locked").
+   */
+  rb_define_method(c_Gps, "is_fixed?", gps_is_fixed, 0);
+
+  /*
+   * Document-method: now_at_utc
+   * call-seq:
+   *   now_at_utc -> Time
+   *
+   * Returns the GPS-reported time, in the UTC zone.
+   */
+  rb_define_method(c_Gps, "now_at_utc", gps_now_at_utc, 0);
+
+}
+
+VALUE gps_initialize(VALUE self, VALUE serial) {
+  PhidgetInfo *info = device_info(self);
+  
+  GpsInfo *gps_info = ALLOC(GpsInfo); 
+  memset(gps_info, 0, sizeof(GpsInfo));
+
+  gps_info->sample_rate = sample_create();
+
+  CPhidgetGPSHandle gps = 0;
+
+  ensure(CPhidgetGPS_create(&gps));
+
+  ensure(CPhidgetGPS_set_OnPositionChange_Handler( gps, gps_on_position_change, info));
+ 	ensure(CPhidgetGPS_set_OnPositionFixStatusChange_Handler(gps, gps_on_fix_change, info));
+
+  info->handle = (CPhidgetHandle)gps;
+  info->on_type_detach = gps_on_detach;
+  info->on_type_free = gps_on_free;
+  info->type_info = gps_info;
+
+  return rb_call_super(1, &serial);
+}
+
+VALUE gps_close(VALUE self) {
+  PhidgetInfo *info = device_info(self);
+
+  ensure(CPhidgetGPS_set_OnPositionChange_Handler((CPhidgetGPSHandle)info->handle, NULL, NULL));
+ 	ensure(CPhidgetGPS_set_OnPositionFixStatusChange_Handler((CPhidgetGPSHandle)info->handle, NULL, NULL));
+
+  return rb_call_super(0,NULL);
+}
+
+VALUE gps_sample_rate(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return INT2FIX(gps_info->sample_rate->in_hz);
+}
+
+VALUE gps_latitude(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return (gps_info->is_latitude_known) ? DBL2NUM(gps_info->latitude) : Qnil;
+}
+
+VALUE gps_longitude(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return (gps_info->is_longitude_known) ? DBL2NUM(gps_info->longitude) : Qnil;
+}
+
+VALUE gps_altitude(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return (gps_info->is_altitude_known) ? DBL2NUM(gps_info->altitude) : Qnil;
+}
+
+VALUE gps_heading(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return (gps_info->is_heading_known) ? DBL2NUM(gps_info->heading) : Qnil;
+}
+
+VALUE gps_velocity(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return (gps_info->is_velocity_known) ? DBL2NUM(gps_info->velocity) : Qnil;
+}
+
+VALUE gps_is_fixed(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  return (gps_info->is_fixed) ? Qtrue : Qfalse;
+}
+
+VALUE gps_now_at_utc(VALUE self) {
+  GpsInfo *gps_info = device_type_info(self);
+
+  if (!gps_info->is_now_at_utc_known) return Qnil;
+
+  VALUE c_Time = rb_const_get(rb_cObject, rb_intern("Time"));
+
+  char *now_as_string = ALLOC_N(char, 28);
+  sprintf(now_as_string, "%04d-%02d-%02d %02d:%02d:%02d.%03d UTC",
+    gps_info->now_at_utc.tm_year,
+    gps_info->now_at_utc.tm_mon,
+    gps_info->now_at_utc.tm_mday,
+    gps_info->now_at_utc.tm_hour,
+    gps_info->now_at_utc.tm_min,
+    gps_info->now_at_utc.tm_sec,
+    gps_info->now_at_utc_ms);
+
+  VALUE now = rb_funcall(c_Time, rb_intern("parse"), 2, 
+    rb_str_new2(now_as_string),
+    rb_str_new2("%Y-%m-%d %H:%M:%S.%3N") );
+ 
+  xfree(now_as_string);
+
+  return now;
+}

data/ext/phidgets_native/interfacekit.c

@@ -0,0 +1,203 @@
+#include "phidgets_native.h"
+
+int CCONV interfacekit_on_attach(CPhidgetHandle phid, void *userptr) {
+  PhidgetInfo *info = userptr;
+  InterfaceKitInfo *ifkit_info = info->type_info;
+  CPhidgetInterfaceKitHandle interfacekit = (CPhidgetInterfaceKitHandle) phid;
+
+  report(CPhidgetInterfaceKit_getInputCount(interfacekit, &ifkit_info->digital_input_count));
+  ifkit_info->is_digital_input_count_known = true;
+
+  report(CPhidgetInterfaceKit_getOutputCount(interfacekit, &ifkit_info->digital_output_count));
+  ifkit_info->is_digital_output_count_known = true;
+
+  report(CPhidgetInterfaceKit_getSensorCount(interfacekit, &ifkit_info->analog_input_count));
+  ifkit_info->is_analog_input_count_known = true;
+
+  // Allocate space for our state collections:
+  ifkit_info->digital_input_states = ALLOC_N(int, ifkit_info->digital_input_count); 
+  ifkit_info->analog_input_states = ALLOC_N(int, ifkit_info->analog_input_count); 
+
+  // Allocate our data_rate-related collections
+  if (ifkit_info->analog_input_count_prior != ifkit_info->analog_input_count) {
+    if(ifkit_info->data_rates) xfree(ifkit_info->data_rates);
+    if(ifkit_info->data_rates_max) xfree(ifkit_info->data_rates_max);
+    if(ifkit_info->data_rates_min) xfree(ifkit_info->data_rates_min);
+    if(ifkit_info->sensor_change_triggers) xfree(ifkit_info->sensor_change_triggers);
+    if(ifkit_info->digital_sample_rates) xfree(ifkit_info->digital_sample_rates);
+    if(ifkit_info->analog_sample_rates) xfree(ifkit_info->analog_sample_rates);
+    if(ifkit_info->digital_output_states) xfree(ifkit_info->digital_output_states);
+
+    ifkit_info->data_rates = ALLOC_N(int, ifkit_info->analog_input_count);
+    ifkit_info->data_rates_max = ALLOC_N(int, ifkit_info->analog_input_count);
+    ifkit_info->data_rates_min = ALLOC_N(int, ifkit_info->analog_input_count);
+    ifkit_info->sensor_change_triggers = ALLOC_N(int, ifkit_info->analog_input_count);
+    ifkit_info->digital_output_states = ALLOC_N(int, ifkit_info->digital_output_count); 
+
+    ifkit_info->digital_sample_rates = ALLOC_N(SampleRate, ifkit_info->digital_input_count); 
+    ifkit_info->analog_sample_rates = ALLOC_N(SampleRate, ifkit_info->analog_input_count); 
+
+    memset(ifkit_info->digital_output_states, 0, sizeof(int) * ifkit_info->digital_output_count);
+    memset(ifkit_info->digital_sample_rates, 0, sizeof(SampleRate) * ifkit_info->digital_input_count);
+    memset(ifkit_info->analog_sample_rates, 0, sizeof(SampleRate) * ifkit_info->analog_input_count);
+
+    for(int i=0;i<ifkit_info->analog_input_count;i++) {
+      ifkit_info->data_rates[i] = DEFAULT_INTERFACEKIT_DATA_RATE;
+      ifkit_info->sensor_change_triggers[i] = DEFAULT_INTERFACEKIT_CHANGE_TRIGGER;
+      
+      report(CPhidgetInterfaceKit_getDataRateMax(interfacekit, i, &ifkit_info->data_rates_max[i]));
+      report(CPhidgetInterfaceKit_getDataRateMin(interfacekit, i, &ifkit_info->data_rates_min[i]));
+    }
+
+    ifkit_info->is_data_rates_known = true;
+  }
+
+  // If the interfacekit isn't what we expect, we need to perform a change:
+  report(interfacekit_assert_ratiometric_state( info ));
+
+  // Set the data-rate/sensor-thresholds
+  for(int i=0;i<ifkit_info->analog_input_count;i++) {
+    if (ifkit_info->data_rates[i] > 0) {
+      report(CPhidgetInterfaceKit_setSensorChangeTrigger(interfacekit, i, 0));
+      report(CPhidgetInterfaceKit_setDataRate(interfacekit, i, ifkit_info->data_rates[i]));
+    } else {
+      report(CPhidgetInterfaceKit_setDataRate(interfacekit, i, 0));
+      report(CPhidgetInterfaceKit_setSensorChangeTrigger(interfacekit, i, ifkit_info->sensor_change_triggers[i]));
+    }
+  }
+
+  // Read in all of our initial input values:
+  for(int i=0; i<ifkit_info->digital_input_count; i++)
+    report(CPhidgetInterfaceKit_getInputState(interfacekit,i, &ifkit_info->digital_input_states[i]));
+
+  for(int i=0; i<ifkit_info->digital_output_count; i++)
+    report(CPhidgetInterfaceKit_setOutputState(interfacekit,i, ifkit_info->digital_output_states[i]));
+
+  for(int i=0; i<ifkit_info->analog_input_count; i++)
+    if (ifkit_info->rationmetric_changed_usec == 0) 
+      // We only read these in if we haven't recently been changed ratiometric status: 
+      report(CPhidgetInterfaceKit_getSensorValue(interfacekit,i, &ifkit_info->analog_input_states[i]));
+    else
+      ifkit_info->analog_input_states[i] = 0;
+
+  return 0;
+}
+
+int CCONV interfacekit_on_detach(CPhidgetHandle phid, void *userptr) {
+  PhidgetInfo *info = userptr;
+  InterfaceKitInfo *ifkit_info = info->type_info;
+  CPhidgetInterfaceKitHandle interfacekit = (CPhidgetInterfaceKitHandle)phid;
+
+  // This is used to determine whethere to preserve the allocated memory on reattach:
+  ifkit_info->analog_input_count_prior = ifkit_info->analog_input_count;
+
+  // Free the polled resources:
+  xfree(ifkit_info->digital_input_states);
+  ifkit_info->digital_input_states = NULL;
+
+  xfree(ifkit_info->analog_input_states);
+  ifkit_info->analog_input_states = NULL;
+ 
+  // Zero the sample trackers: 
+  memset(ifkit_info->digital_sample_rates, 0, sizeof(SampleRate) * ifkit_info->digital_input_count);
+  memset(ifkit_info->analog_sample_rates, 0, sizeof(SampleRate) * ifkit_info->analog_input_count);
+  
+  return 0;
+}
+
+void interfacekit_on_free(void *type_info) {
+  InterfaceKitInfo *ifkit_info = type_info;
+
+  if(ifkit_info->data_rates)
+    xfree(ifkit_info->data_rates);
+  if(ifkit_info->data_rates_min)
+    xfree(ifkit_info->data_rates_min);
+  if(ifkit_info->data_rates_max)
+    xfree(ifkit_info->data_rates_max);
+  if(ifkit_info->sensor_change_triggers)
+    xfree(ifkit_info->sensor_change_triggers);
+  if (ifkit_info->digital_input_states)
+    xfree(ifkit_info->digital_input_states);
+  if (ifkit_info->digital_output_states)
+    xfree(ifkit_info->digital_output_states);
+  if (ifkit_info->analog_input_states)
+    xfree(ifkit_info->analog_input_states);
+  if(ifkit_info->digital_sample_rates) 
+    xfree(ifkit_info->digital_sample_rates);
+  if(ifkit_info->analog_sample_rates) 
+    xfree(ifkit_info->analog_sample_rates);
+  if (ifkit_info)
+    xfree(ifkit_info);
+  return;
+}
+
+int interfacekit_on_digital_change(CPhidgetInterfaceKitHandle interfacekit, void *userptr, int index, int inputState) {
+  PhidgetInfo *info = userptr;
+  InterfaceKitInfo *ifkit_info = info->type_info;
+
+  sample_tick(&ifkit_info->digital_sample_rates[index], NULL);
+
+  if (ifkit_info->digital_input_states)
+    ifkit_info->digital_input_states[index] = inputState;
+
+  return 0;
+}
+
+int interfacekit_on_analog_change(CPhidgetInterfaceKitHandle interfacekit, void *userptr, int index, int sensorValue) {
+  PhidgetInfo *info = userptr;
+  InterfaceKitInfo *ifkit_info = info->type_info;
+
+  sample_tick(&ifkit_info->analog_sample_rates[index], NULL);
+
+  if (ifkit_info->analog_input_states) {
+    if (ifkit_info->rationmetric_changed_usec == 0) 
+      ifkit_info->analog_input_states[index] = sensorValue;
+    else {
+      // We need to wait 50 milliseconds before accepting values after a ratiometric
+      // state change. If we're in this path, it's TBD whether 50 ms has passed
+      int usec_difference;
+      struct timeval now;
+      gettimeofday(&now, NULL);
+
+      usec_difference = ( now.tv_usec + 
+        ( (now.tv_usec < ifkit_info->rationmetric_changed_usec)  ? 1000000 : 0) -
+        ifkit_info->rationmetric_changed_usec );
+         
+      // Did we wait long enough between a ratiometric status change:
+      if ( usec_difference > INTERFACEKIT_RATIOMETRIC_RESET_USECS ) {
+        ifkit_info->rationmetric_changed_usec = 0;
+        
+        // And sure, go ahead and accepti this value:
+        ifkit_info->analog_input_states[index] = sensorValue;
+      }
+    }
+  }
+
+  return 0;
+}
+
+int interfacekit_assert_ratiometric_state(PhidgetInfo *info) {
+  InterfaceKitInfo *ifkit_info = info->type_info;
+  CPhidgetInterfaceKitHandle interfacekit = (CPhidgetInterfaceKitHandle) info->handle;
+  int ret = 0;
+
+  int is_ratiometric_already;
+  ret = CPhidgetInterfaceKit_getRatiometric(interfacekit, &is_ratiometric_already);
+  if (ret != EPHIDGET_OK) return ret;
+
+  if (ifkit_info->is_ratiometric != (ifkit_info->is_ratiometric == PTRUE) ) {
+    ret = CPhidgetInterfaceKit_setRatiometric(interfacekit, (ifkit_info->is_ratiometric) ? PTRUE : PFALSE );
+    if (ret != EPHIDGET_OK) return ret;
+
+    // Zero-out the analog struct:
+    memset(ifkit_info->analog_input_states, 0, sizeof(int) * ifkit_info->analog_input_count);
+
+    // We need to wait 50ms after this change before we start to read in values:
+    struct timeval now;
+    gettimeofday(&now, NULL);
+
+    ifkit_info->rationmetric_changed_usec = (now.tv_usec == 0) ? 1 : now.tv_usec;
+  }
+
+  return EPHIDGET_OK;
+}