phidgets_native 0.1.0

data/ext/phidgets_native/phidgets_native.c

@@ -0,0 +1,197 @@
+#include "phidgets_native.h"
+
+/* This converts an array of doubles into a ruby array of numbers, or into
+ * nil for the case of an invalid dbl_array
+ */
+VALUE double_array_to_rb(double *dbl_array, int length) {
+  if (!dbl_array) return Qnil;
+  VALUE rb_ary = rb_ary_new2(length);
+  for(int i=0; i<length; i++) rb_ary_store(rb_ary, i, DBL2NUM(dbl_array[i]));
+  return rb_ary;
+}
+
+/* This converts an array of ints into a ruby array of fixnums, or into
+ * nil for the case of an invalid int_array
+ */
+VALUE int_array_to_rb(int *int_array, int length) {
+  if (!int_array) return Qnil;
+  VALUE rb_ary = rb_ary_new2(length);
+  for(int i=0; i<length; i++) rb_ary_store(rb_ary, i, INT2NUM(int_array[i]));
+  return rb_ary;
+}
+
+/* This converts an array of ints into a ruby array of fixnums. If an element
+ * of the array is 0, this converts to Qnil. nil is returned for the case of an 
+ * invalid int_array.
+ */
+VALUE int_array_zeronils_to_rb(int *int_array, int length) {
+  if (!int_array) return Qnil;
+  VALUE rb_ary = rb_ary_new2(length);
+  for(int i=0; i<length; i++) 
+    rb_ary_store(rb_ary, i, (int_array[i] == 0) ? Qnil : INT2NUM(int_array[i]));
+  return rb_ary;
+}
+
+/* This converts an array of phidget bools into a ruby array of booleans. If an 
+ * element of the array is 0, this converts to Qnil. nil is returned for the case 
+ * of an invalid bool_array.
+ */
+VALUE phidgetbool_array_to_rb(int *bool_array, int length) {
+  if (!bool_array) return Qnil;
+  VALUE rb_ary = rb_ary_new2(length);
+  for(int i=0; i<length; i++) 
+    rb_ary_store(rb_ary, i, (bool_array[i] == PTRUE) ? Qtrue : Qfalse);
+  return rb_ary;
+}
+
+// The name is ambiguous, but the main purpose here is dry things out a bit
+// and let us do a better job of reporting errors to ruby
+int ensure(int result) {
+  if ( result == EPHIDGET_OK ) return 0;
+
+  const char *exception_name;
+
+  switch(result) {
+    case EPHIDGET_NOTFOUND:
+      exception_name = "NotFoundError";
+      break;
+    case EPHIDGET_NOMEMORY:
+      exception_name = "NoMemoryError";
+      break;
+    case EPHIDGET_UNEXPECTED:
+      exception_name = "UnexpectedError";
+      break;
+    case EPHIDGET_INVALIDARG:
+      exception_name = "InvalidArgError";
+      break;
+    case EPHIDGET_NOTATTACHED:
+      exception_name = "NotAttachedError";
+      break;
+    case EPHIDGET_INTERRUPTED:
+      exception_name = "InterruptedError";
+      break;
+    case EPHIDGET_INVALID:
+      exception_name = "InvalidError";
+      break;
+    case EPHIDGET_NETWORK:
+      exception_name = "NetworkError";
+      break;
+    case EPHIDGET_UNKNOWNVAL:
+      exception_name = "UnknownValError";
+      break;
+    case EPHIDGET_BADPASSWORD:
+      exception_name = "BadPasswordError";
+      break;
+    case EPHIDGET_UNSUPPORTED:
+      exception_name = "UnsupportedError";
+      break;
+    case EPHIDGET_DUPLICATE:
+      exception_name = "DuplicateError";
+      break;
+    case EPHIDGET_TIMEOUT:
+      exception_name = "TimeoutError";
+      break;
+    case EPHIDGET_OUTOFBOUNDS:
+      exception_name = "OutOfBoundsError";
+      break;
+    case EPHIDGET_EVENT:
+      exception_name = "EventError";
+      break;
+    case EPHIDGET_NETWORK_NOTCONNECTED:
+      exception_name = "NetworkNotConnectedError";
+      break;
+    case EPHIDGET_WRONGDEVICE:
+      exception_name = "WrongDeviceError";
+      break;
+    case EPHIDGET_CLOSED:
+      exception_name = "ClosedError";
+      break;
+    case EPHIDGET_BADVERSION:
+      exception_name = "BadVersionError";
+      break;
+    default:
+      exception_name = "UnhandledError";
+      break;
+  }
+
+  const char *description;
+  CPhidget_getErrorDescription(result, &description);
+
+  VALUE m_Phidget = rb_const_get(rb_cObject, rb_intern("PhidgetsNative"));  
+  VALUE c_Exception = rb_const_get(m_Phidget, rb_intern(exception_name));
+
+  rb_raise(c_Exception, "%s", description);
+
+  return result;
+}
+
+// The name is ambiguous, but the main purpose here is dry things out a bit
+// and let us do a better job of reporting errors albeit not halting.
+// This is necessary in the threaded callbacks where access to the interpreter 
+// is unavailable:
+int report(int result) {
+  if (result == EPHIDGET_OK) return result;
+
+  const char *description;
+  CPhidget_getErrorDescription(result, &description);
+
+  CPhidget_log(PHIDGET_LOG_ERROR, "N/A", "PhidgetNative report error: %s", description);
+
+  return result;
+}
+
+SampleRate *sample_create() {
+  SampleRate *ret = ALLOC(SampleRate); 
+  if (ret)
+    sample_zero(ret);
+
+  return ret;
+}
+
+int sample_zero(SampleRate *sample_rate) {
+  memset(sample_rate, 0, sizeof(SampleRate));
+
+  return 0;
+}
+
+int sample_free(SampleRate *sample_rate) {
+  xfree(sample_rate);
+  sample_rate = 0;
+  return 0;
+}
+
+/*
+ * The first time this is called, we're a little inadequate. Mostly this is because
+ * we're not including microseconds. If we included microseconds, then we could
+ * process a block if the seconds component were different than the last, and our
+ * microseconds were greater than the starting microsecond amount.
+ */
+int sample_tick(SampleRate *sample_rate, CPhidget_Timestamp *ts) {
+  unsigned long now_seconds;
+
+  sample_rate->samples_in_second++;
+
+  if (ts == NULL) {
+    // We can pull this ourself using the system times:
+    struct timeval now;
+    gettimeofday(&now, NULL);
+
+    now_seconds = (unsigned long) now.tv_sec;
+  } else
+    // Seems like the module has a timestamp for us to use:
+    now_seconds = (unsigned long) ts->seconds;
+
+  // Sample tracking
+  // We need the > 0 for the case of the first time we've ever entered this loop
+  if (sample_rate->last_second == 0)
+   sample_rate->last_second = now_seconds;
+  else if (sample_rate->last_second != now_seconds ) {
+   sample_rate->in_hz = (double)sample_rate->samples_in_second / 
+        (double) (now_seconds -sample_rate->last_second);
+   sample_rate->samples_in_second = 0;
+   sample_rate->last_second = now_seconds;
+  }
+
+  return 0;
+}
+

data/ext/phidgets_native/phidgets_native.h

@@ -0,0 +1,320 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <math.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <ruby.h>
+#include <phidget21.h>
+
+// We needed a define here since some compilers won't let you set an array size
+// via a const.
+#define COMPASS_CORRECTION_LENGTH 13
+
+static double const MICROSECONDS_IN_SECOND = 1000000.0;
+static int const DEGREES_IN_CIRCLE = 360;
+static int const DEFAULT_SPATIAL_DATA_RATE = 16;
+
+// Make sure one of these is non-zero and the other is 0
+static int const DEFAULT_INTERFACEKIT_DATA_RATE = 8;
+static int const DEFAULT_INTERFACEKIT_CHANGE_TRIGGER = 0;
+// /Make-sure
+
+// 50 milliseconds:
+static int const INTERFACEKIT_RATIOMETRIC_RESET_USECS = 50000;
+
+typedef struct sample_rate {
+  int in_hz;             // This is really the finished product
+  int samples_in_second; // A counter which resets when the second changes
+
+  // This is used for calculating the deltas 
+  unsigned long last_second;
+} SampleRate;
+
+typedef struct phidget_info {
+  CPhidgetHandle handle;
+  int  serial;
+  const char *type;
+  const char *name;
+  const char *label;
+  int version;
+  CPhidget_DeviceClass device_class;
+  CPhidget_DeviceID device_id;
+
+  // Attachment Tracking:
+  bool is_attached;
+
+  // This is expressed in the number of seconds and microseconds since the epoch:
+  struct timeval attached_at;
+  struct timezone attached_at_tz;
+
+  // Used by the device drivers to track state:
+  void *type_info;
+
+  // Event Handlers
+  int (*on_type_attach)(CPhidgetHandle phid, void *userptr);
+  int (*on_type_detach)(CPhidgetHandle phid, void *userptr);
+  void (*on_type_free)(void *type_info);
+
+} PhidgetInfo;
+
+typedef struct spatial_info {
+  // Compass Correction Params:
+  bool is_compass_correction_known;
+  double compass_correction[COMPASS_CORRECTION_LENGTH];
+
+  SampleRate *sample_rate;
+
+  // Poll interval
+  int data_rate;
+
+  // Device limits:
+  int accelerometer_axes;
+  int compass_axes;
+  int gyro_axes;
+  int data_rate_max;
+  int data_rate_min;
+  double *acceleration_min;
+  double *acceleration_max;
+  double *compass_min;
+  double *compass_max;
+  double *gyroscope_min;
+  double *gyroscope_max;
+
+  // Runtime Values
+  bool is_acceleration_known;
+  double *acceleration;
+
+  bool is_compass_known;
+  double *compass;
+
+  bool is_gyroscope_known;
+  double *gyroscope;
+
+  // This is used by the gyro:
+  double last_microsecond;
+} SpatialInfo;
+
+typedef struct gps_info {
+  SampleRate *sample_rate;
+
+  bool is_fixed;
+
+  bool is_latitude_known;
+  double latitude;
+
+  bool is_longitude_known;
+  double longitude;
+
+  bool is_altitude_known;
+  double altitude;
+
+  bool is_heading_known;
+  double heading;
+
+  bool is_velocity_known;
+  double velocity;
+ 
+  bool is_now_at_utc_known;
+	struct tm now_at_utc;
+  short now_at_utc_ms;
+
+} GpsInfo;
+
+typedef struct interfacekit_info {
+  // For the inputs:
+  SampleRate *analog_sample_rates;
+  SampleRate *digital_sample_rates;
+
+  bool is_digital_input_count_known;
+  int digital_input_count;
+
+  bool is_digital_output_count_known;
+  int digital_output_count;
+
+  bool is_analog_input_count_known;
+  int analog_input_count;
+
+  // This is kind of a weird thing to track, probably it will never be needed.
+  // I use it to determine whether the input counts have changed between device
+  // plug events.
+  int analog_input_count_prior;
+
+  bool is_ratiometric;
+  int rationmetric_changed_usec;
+
+
+  // This flag works for all of the below properties
+  bool is_data_rates_known;
+  int *data_rates_max;
+  int *data_rates_min;
+  int *sensor_change_triggers;
+  int *data_rates;
+  // /is_data_rates_known
+
+  int *digital_input_states;
+  int *digital_output_states;
+  int *analog_input_states;
+
+} InterfaceKitInfo;
+
+void Init_phidgets_native();
+void Init_phidgets_native_module();
+void Init_phidgets_native_device(VALUE m_Phidget);
+void Init_phidgets_native_accelerometer(VALUE m_Phidget);
+void Init_phidgets_native_advancedservo(VALUE m_Phidget);
+void Init_phidgets_native_analog(VALUE m_Phidget);
+void Init_phidgets_native_bridge(VALUE m_Phidget);
+void Init_phidgets_native_encoder(VALUE m_Phidget);
+void Init_phidgets_native_frequencycounter(VALUE m_Phidget);
+void Init_phidgets_native_gps(VALUE m_Phidget);
+void Init_phidgets_native_interfacekit(VALUE m_Phidget);
+void Init_phidgets_native_ir(VALUE m_Phidget);
+void Init_phidgets_native_led(VALUE m_Phidget);
+void Init_phidgets_native_motorcontrol(VALUE m_Phidget);
+void Init_phidgets_native_phsensor(VALUE m_Phidget);
+void Init_phidgets_native_rfid(VALUE m_Phidget);
+void Init_phidgets_native_servo(VALUE m_Phidget);
+void Init_phidgets_native_spatial(VALUE m_Phidget);
+void Init_phidgets_native_stepper(VALUE m_Phidget);
+void Init_phidgets_native_temperaturesensor(VALUE m_Phidget);
+void Init_phidgets_native_textlcd(VALUE m_Phidget);
+void Init_phidgets_native_textled(VALUE m_Phidget);
+void Init_phidgets_native_weightsensor(VALUE m_Phidget);
+
+// Common:
+VALUE double_array_to_rb(double *dbl_array, int length);
+VALUE int_array_to_rb(int *int_array, int length);
+VALUE int_array_zeronils_to_rb(int *int_array, int length);
+VALUE phidgetbool_array_to_rb(int *bool_array, int length);
+int ensure(int result);
+int report(int result);
+SampleRate *sample_create();
+int sample_free(SampleRate *sample_rate);
+int sample_zero(SampleRate *sample_rate);
+int sample_tick(SampleRate *sample_rate, CPhidget_Timestamp *ts);
+
+// Phidget Module
+VALUE phidget_enable_logging(int argc, VALUE *argv, VALUE class);
+VALUE phidget_disable_logging(VALUE class);
+VALUE phidget_log(VALUE class, VALUE log_level, VALUE message);
+VALUE phidget_all(VALUE class);
+
+// Phidget::Device
+PhidgetInfo *device_info(VALUE self);
+void *device_type_info(VALUE self);
+void device_free(PhidgetInfo *info);
+int CCONV device_on_attach(CPhidgetHandle phid, void *userptr);
+int CCONV device_on_detach(CPhidgetHandle phid, void *userptr);
+int CCONV device_on_error(CPhidgetHandle phid, void *userptr, int ErrorCode, const char *unknown);
+
+VALUE device_allocate(VALUE class);
+VALUE device_initialize(VALUE self, VALUE serial);
+VALUE device_close(VALUE self);
+VALUE device_wait_for_attachment(VALUE self, VALUE timeout);
+VALUE device_is_attached(VALUE self);
+VALUE device_device_class(VALUE self);
+VALUE device_device_id(VALUE self);
+VALUE device_type(VALUE self);
+VALUE device_name(VALUE self);
+VALUE device_label(VALUE self);
+VALUE device_serial_number(VALUE self);
+VALUE device_version(VALUE self);
+
+// Phidget::Spatial
+void spatial_on_free(void *type_info);
+int CCONV spatial_on_attach(CPhidgetHandle phid, void *userptr);
+int CCONV spatial_on_detach(CPhidgetHandle phid, void *userptr);
+int CCONV spatial_on_data(CPhidgetSpatialHandle spatial, void *userptr, CPhidgetSpatial_SpatialEventDataHandle *data, int count);
+int spatial_set_compass_correction_by_array(CPhidgetSpatialHandle phid, double *correction);
+VALUE spatial_initialize(VALUE self, VALUE serial);
+VALUE spatial_close(VALUE self);
+VALUE spatial_sample_rate(VALUE self);
+VALUE spatial_accelerometer_axes(VALUE self);
+VALUE spatial_compass_axes(VALUE self);
+VALUE spatial_gyro_axes(VALUE self);
+
+VALUE spatial_accelerometer_min(VALUE self);
+VALUE spatial_accelerometer_max(VALUE self);
+VALUE spatial_compass_min(VALUE self);
+VALUE spatial_compass_max(VALUE self);
+VALUE spatial_gyro_min(VALUE self);
+VALUE spatial_gyro_max(VALUE self);
+
+VALUE spatial_accelerometer(VALUE self);
+VALUE spatial_compass(VALUE self);
+VALUE spatial_gyro(VALUE self);
+
+VALUE spatial_zero_gyro(VALUE self);
+VALUE spatial_compass_correction_set(VALUE self, VALUE compass_correction);
+VALUE spatial_compass_correction_get(VALUE self);
+VALUE spatial_reset_compass_correction(VALUE self);
+
+VALUE spatial_data_rate_min(VALUE self);
+VALUE spatial_data_rate_max(VALUE self);
+VALUE spatial_data_rate_set(VALUE self, VALUE data_rate);
+VALUE spatial_data_rate_get(VALUE self);
+
+// Phidget::InterfaceKit
+void interfacekit_on_free(void *type_info);
+int CCONV interfacekit_on_attach(CPhidgetHandle phid, void *userptr);
+int CCONV interfacekit_on_detach(CPhidgetHandle phid, void *userptr);
+int interfacekit_on_digital_change(CPhidgetInterfaceKitHandle interfacekit, void *userptr, int index, int inputState);
+int interfacekit_on_analog_change(CPhidgetInterfaceKitHandle interfacekit, void *userptr, int index, int sensorValue);
+int interfacekit_assert_ratiometric_state(PhidgetInfo *info);
+VALUE interfacekit_initialize(VALUE self, VALUE serial);
+VALUE interfacekit_close(VALUE self);
+VALUE interfacekit_sensor_sample_rates(VALUE self);
+VALUE interfacekit_input_sample_rates(VALUE self);
+VALUE interfacekit_input_count(VALUE self);
+VALUE interfacekit_output_count(VALUE self);
+VALUE interfacekit_sensor_count(VALUE self);
+VALUE interfacekit_is_ratiometric(VALUE self);
+VALUE interfacekit_ratiometric_set(VALUE self, VALUE is_ratiometric);
+VALUE interfacekit_data_rates_max(VALUE self);
+VALUE interfacekit_data_rates_min(VALUE self);
+VALUE interfacekit_data_rates(VALUE self);
+VALUE interfacekit_change_triggers(VALUE self);
+VALUE interfacekit_inputs(VALUE self);
+VALUE interfacekit_outputs(VALUE self);
+VALUE interfacekit_sensors(VALUE self);
+VALUE interfacekit_sensor_raw(VALUE self, VALUE index);
+VALUE interfacekit_output_set(VALUE self, VALUE index, VALUE is_on);
+VALUE interfacekit_data_rate_set(VALUE self, VALUE index, VALUE rate);
+VALUE interfacekit_change_trigger_set(VALUE self, VALUE index, VALUE rate_thresh);
+
+// Phidget::Gps
+void gps_on_free(void *type_info);
+int CCONV gps_on_attach(CPhidgetHandle phid, void *userptr);
+int CCONV gps_on_detach(CPhidgetHandle phidget, void *userptr);
+int CCONV gps_on_position_change(CPhidgetGPSHandle gps, void *userptr, double latitude, double longitude, double altitude);
+int CCONV gps_on_fix_change(CPhidgetGPSHandle gps, void *userptr, int status);
+VALUE gps_initialize(VALUE self, VALUE serial);
+VALUE gps_close(VALUE self);
+VALUE gps_sample_rate(VALUE self);
+VALUE gps_latitude(VALUE self);
+VALUE gps_longitude(VALUE self);
+VALUE gps_altitude(VALUE self);
+VALUE gps_heading(VALUE self);
+VALUE gps_velocity(VALUE self);
+VALUE gps_is_fixed(VALUE self);
+VALUE gps_now_at_utc(VALUE self);
+
+// Stub initializers:
+VALUE accelerometer_initialize(VALUE self, VALUE serial);
+VALUE advancedservo_initialize(VALUE self, VALUE serial);
+VALUE encoder_initialize(VALUE self, VALUE serial);
+VALUE ir_initialize(VALUE self, VALUE serial);
+VALUE led_initialize(VALUE self, VALUE serial);
+VALUE motorcontrol_initialize(VALUE self, VALUE serial);
+VALUE phsensor_initialize(VALUE self, VALUE serial);
+VALUE rfid_initialize(VALUE self, VALUE serial);
+VALUE servo_initialize(VALUE self, VALUE serial);
+VALUE stepper_initialize(VALUE self, VALUE serial);
+VALUE temperaturesensor_initialize(VALUE self, VALUE serial);
+VALUE textlcd_initialize(VALUE self, VALUE serial);
+VALUE textled_initialize(VALUE self, VALUE serial);
+VALUE weightsensor_initialize(VALUE self, VALUE serial);
+VALUE analog_initialize(VALUE self, VALUE serial);
+VALUE bridge_initialize(VALUE self, VALUE serial);
+VALUE frequencycounter_initialize(VALUE self, VALUE serial);