phidgets 0.1.3 → 1.0.0

data/ext/phidgets/phidgets_light_sensor.c

@@ -0,0 +1,200 @@
+
+#include "phidgets.h"
+
+#define LIGHT_SENSOR_ILLUMINANCE_CHANGE_CALLBACK    0
+
+
+VALUE ph_light_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetLightSensor_create((PhidgetLightSensorHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_light_get_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetLightSensor_getDataInterval);
+}
+
+VALUE ph_light_set_data_interval(VALUE self, VALUE interval) {
+  ph_raise(PhidgetLightSensor_setDataInterval((PhidgetLightSensorHandle)get_ph_handle(self), NUM2UINT(interval)));
+  return Qnil;
+}
+
+VALUE ph_light_get_min_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetLightSensor_getMinDataInterval);
+}
+
+VALUE ph_light_get_max_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetLightSensor_getMaxDataInterval);
+}
+
+VALUE ph_light_get_illuminance(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetLightSensor_getIlluminance);
+}
+
+VALUE ph_light_get_min_illuminance(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetLightSensor_getMinIlluminance);
+}
+
+VALUE ph_light_get_max_illuminance(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetLightSensor_getMaxIlluminance);
+}
+
+VALUE ph_light_get_illuminance_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetLightSensor_getIlluminanceChangeTrigger);
+}
+
+VALUE ph_light_set_illuminance_change_trigger(VALUE self, VALUE change_trigger) {
+  ph_raise(PhidgetLightSensor_setIlluminanceChangeTrigger((PhidgetLightSensorHandle)get_ph_handle(self), NUM2DBL(change_trigger)));
+  return Qnil;
+}
+
+VALUE ph_light_get_min_illuminance_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetLightSensor_getMinIlluminanceChangeTrigger);
+}
+
+VALUE ph_light_get_max_illuminance_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetLightSensor_getMaxIlluminanceChangeTrigger);
+}
+
+
+void CCONV ph_light_on_illuminance_change(PhidgetLightSensorHandle phid, void *userPtr, double illuminance) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = DBL2NUM(illuminance);
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
+}
+
+
+VALUE ph_light_set_on_illuminance_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[LIGHT_SENSOR_ILLUMINANCE_CHANGE_CALLBACK];
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
+    callback_data->exit = true;
+    ph_raise(PhidgetLightSensor_setOnIlluminanceChangeHandler((PhidgetLightSensorHandle)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(PhidgetLightSensor_setOnIlluminanceChangeHandler((PhidgetLightSensorHandle)ph->handle, ph_light_on_illuminance_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+void Init_light() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_light = rb_define_class_under(ph_module, "LightSensor", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget LightSensor object.
+   */
+  rb_define_method(ph_light, "initialize", ph_light_init, 0);
+
+  /* Document-method: getDataInterval
+   * call-seq: getDataInterval -> interval
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another IlluminanceChange event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between IlluminanceChange events can also affected by the IlluminanceChangeTrigger.
+   */
+  rb_define_method(ph_light, "getDataInterval", ph_light_get_data_interval, 0);
+  rb_define_alias(ph_light, "data_interval", "getDataInterval");
+
+  /* Document-method: setDataInterval
+   * call-seq: setDataInterval(interval)
+   *
+   * The DataInterval is the time that must elapse before the channel will fire another IlluminanceChange event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between IlluminanceChange events can also affected by the IlluminanceChangeTrigger.
+   */
+  rb_define_method(ph_light, "setDataInterval", ph_light_set_data_interval, 1);
+  rb_define_alias(ph_light, "data_interval=", "setDataInterval");
+
+  /* Document-method: getMinDataInterval
+   * call-seq: getMinDataInterval -> interval
+   *
+   * The minimum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_light, "getMinDataInterval", ph_light_get_min_data_interval, 0);
+  rb_define_alias(ph_light, "min_data_interval", "getMinDataInterval");
+
+  /* Document-method: getMaxDataInterval
+   * call-seq: getMaxDataInterval -> interval
+   *
+   * The maximum value that DataInterval can be set to.
+   */
+  rb_define_method(ph_light, "getMaxDataInterval", ph_light_get_max_data_interval, 0);
+  rb_define_alias(ph_light, "max_data_interval", "getMaxDataInterval");
+
+  /* Document-method: getIlluminance
+   * call-seq: getIlluminance -> illuminance
+   *
+   * The most recent illuminance value that the channel has reported.
+   * This value will always be between MinIlluminance and MaxIlluminance.
+   */
+  rb_define_method(ph_light, "getIlluminance", ph_light_get_illuminance, 0);
+  rb_define_alias(ph_light, "illuminance", "getIlluminance");
+
+  /* Document-method: getMinIlluminance
+   * call-seq: getMinIlluminance -> illuminance
+   *
+   * The minimum value that the IlluminanceChange event will report.
+   */
+  rb_define_method(ph_light, "getMinIlluminance", ph_light_get_min_illuminance, 0);
+  rb_define_alias(ph_light, "min_illuminance", "getMinIlluminance");
+
+  /* Document-method: getMaxIlluminance
+   * call-seq: getMaxIlluminance -> illuminance
+   *
+   * The maximum value that the IlluminanceChange event will report.
+   */
+  rb_define_method(ph_light, "getMaxIlluminance", ph_light_get_max_illuminance, 0);
+  rb_define_alias(ph_light, "max_illuminance", "getMaxIlluminance");
+
+  /* Document-method: getIlluminanceChangeTrigger
+   * call-seq: getIlluminanceChangeTrigger -> change_trigger
+   *
+   * The channel will not issue a IlluminanceChange event until the illuminance value has changed by the amount specified by the IlluminanceChangeTrigger.
+   * Setting the IlluminanceChangeTrigger 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_light, "getIlluminanceChangeTrigger", ph_light_get_illuminance_change_trigger, 0);
+  rb_define_alias(ph_light, "illuminance_change_trigger", "getIlluminanceChangeTrigger");
+
+  /* Document-method: setIlluminanceChangeTrigger
+   * call-seq: setIlluminanceChangeTrigger(change_trigger)
+   *
+   * The channel will not issue a IlluminanceChange event until the illuminance value has changed by the amount specified by the IlluminanceChangeTrigger.
+   * Setting the IlluminanceChangeTrigger 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_light, "setIlluminanceChangeTrigger", ph_light_set_illuminance_change_trigger, 1);
+  rb_define_alias(ph_light, "illuminance_change_trigger=", "setIlluminanceChangeTrigger");
+
+  /* Document-method: getMinIlluminanceChangeTrigger
+   * call-seq: getMinIlluminanceChangeTrigger -> change_trigger
+   *
+   * The minimum value that IlluminanceChangeTrigger can be set to.
+   */
+  rb_define_method(ph_light, "getMinIlluminanceChangeTrigger", ph_light_get_min_illuminance_change_trigger, 0);
+  rb_define_alias(ph_light, "min_illuminance_change_trigger", "getMinIlluminanceChangeTrigger");
+
+  /* Document-method: getMaxIlluminanceChangeTrigger
+   * call-seq: getMaxIlluminanceChangeTrigger -> change_trigger
+   *
+   * The maximum value that IlluminanceChangeTrigger can be set to.
+   */
+  rb_define_method(ph_light, "getMaxIlluminanceChangeTrigger", ph_light_get_max_illuminance_change_trigger, 0);
+  rb_define_alias(ph_light, "max_illuminance_change_trigger", "getMaxIlluminanceChangeTrigger");
+
+
+  rb_define_private_method(ph_light, "ext_setOnIlluminanceChangeHandler", ph_light_set_on_illuminance_change_handler, 1);
+}
+

data/ext/phidgets/phidgets_log.c

@@ -0,0 +1,263 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_log_enable(VALUE self, VALUE level, VALUE output_file);
+VALUE ph_log_disable(VALUE self);
+VALUE ph_log_get_level(VALUE self);
+VALUE ph_log_set_level(VALUE self, VALUE level);
+VALUE ph_log_log(VALUE self, VALUE level, VALUE message);
+VALUE ph_log_loge(VALUE self, VALUE file, VALUE line, VALUE function, VALUE source, VALUE level, VALUE message);
+VALUE ph_log_rotate(VALUE self);
+VALUE ph_log_is_rotating(VALUE self);
+VALUE ph_log_get_rotating(VALUE self);
+VALUE ph_log_set_rotating(VALUE self, VALUE size, VALUE keep_count);
+VALUE ph_log_enable_rotating(VALUE self);
+VALUE ph_log_disable_rotating(VALUE self);
+VALUE ph_log_add_source(VALUE self, VALUE source, VALUE level);
+VALUE ph_log_get_source_level(VALUE self, VALUE source);
+VALUE ph_log_set_source_level(VALUE self, VALUE source, VALUE level);
+VALUE ph_log_get_sources(VALUE self);
+
+
+void Init_logging() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_log = rb_define_class_under(ph_module, "Log", rb_cObject);
+
+  rb_define_const(ph_log, "CRITICAL", INT2FIX(PHIDGET_LOG_CRITICAL));
+  rb_define_const(ph_log, "ERROR", INT2FIX(PHIDGET_LOG_ERROR));
+  rb_define_const(ph_log, "WARNING", INT2FIX(PHIDGET_LOG_WARNING));
+  rb_define_const(ph_log, "DEBUG", INT2FIX(PHIDGET_LOG_DEBUG));
+  rb_define_const(ph_log, "INFO", INT2FIX(PHIDGET_LOG_INFO));
+  rb_define_const(ph_log, "VERBOSE", INT2FIX(PHIDGET_LOG_VERBOSE));
+
+  /*
+   * Document-method: enable
+   * call-seq: enable(log_level, output_file)
+   *
+   * Enables logging.
+   */
+  rb_define_singleton_method(ph_log, "enable", ph_log_enable, 2);
+
+  /*
+   * Document-method: disable
+   * call-seq: disable
+   *
+   * Disables logging.
+   */
+  rb_define_singleton_method(ph_log, "disable", ph_log_disable, 0);
+
+  /*
+   * Document-method: getLevel
+   * call-seq: getLevel
+   *
+   * Gets the log level for the phidget22 source.
+   */
+  rb_define_singleton_method(ph_log, "getLevel", ph_log_get_level, 0);
+
+  /*
+   * Document-method: setLevel
+   * call-seq: setLevel
+   *
+   * Sets the log level for all sources not prefaced with _phidget22.
+   */
+  rb_define_singleton_method(ph_log, "setLevel", ph_log_set_level, 1);
+
+  /*
+   * Document-method: log
+   * call-seq: log(log_level, msg)
+   *
+   * Appends a message to the log.
+   */
+  rb_define_singleton_method(ph_log, "log", ph_log_log, 2);
+
+  /*
+   * Document-method: loge
+   * call-seq: loge(file, line, function, source, log_level, msg)
+   *
+   * Writes a message to the Phidget library log from a specified source.
+   */
+  rb_define_singleton_method(ph_log, "loge", ph_log_loge, 6);
+
+  /*
+   * Document-method: rotate
+   * call-seq: rotate
+   *
+   * Manually rotate the log file. This will only have an effect if automatic rotation is disabled and the log file is larger than the specified maximum file size.
+   */
+  rb_define_singleton_method(ph_log, "rotate", ph_log_rotate, 0);
+
+  /*
+   * Document-method: isRotating
+   * call-seq: isRotating
+   *
+   * Determines if the library is automatically rotating the log file.
+   */
+  rb_define_singleton_method(ph_log, "isRotating", ph_log_is_rotating, 0);
+
+  /*
+   * Document-method: getRotating
+   * call-seq: getRotating
+   *
+   * Gets the current log rotation parameters.
+   */
+  rb_define_singleton_method(ph_log, "getRotating", ph_log_get_rotating, 0);
+
+  /*
+   * Document-method: setRotating
+   * call-seq: setRotating(size, keep_count)
+   *
+   * Sets log rotation parameters.
+   */
+  rb_define_singleton_method(ph_log, "setRotating", ph_log_set_rotating, 2);
+
+  /*
+   * Document-method: enableRotating
+   * call-seq: enableRotating
+   *
+   * Enables automatic rotation of the log file (the default).
+   */
+  rb_define_singleton_method(ph_log, "enableRotating", ph_log_enable_rotating, 0);
+
+  /*
+   * Document-method: disableRotating
+   * call-seq: disableRotating
+   *
+   * Disables automatic rotation of the log file.
+   */
+  rb_define_singleton_method(ph_log, "disableRotating", ph_log_disable_rotating, 0);
+
+  /*
+   * Document-method: addSource
+   * call-seq: addSource(source, level)
+   *
+   * Adds a source to the Phidget logging system. This is useful for declaring a source and setting its log level before sending any messages.
+   */
+  rb_define_singleton_method(ph_log, "addSource", ph_log_add_source, 2);
+
+  /*
+   * Document-method: getSourceLevel
+   * call-seq: getSourceLevel(source)
+   *
+   * Gets the log level of the specified log source.
+   */
+  rb_define_singleton_method(ph_log, "getSourceLevel", ph_log_get_source_level, 1);
+
+  /*
+   * Document-method: setSourceLevel
+   * call-seq: setSourceLevel(source, level)
+   *
+   * Sets the log level of the specified log source.
+   */
+  rb_define_singleton_method(ph_log, "setSourceLevel", ph_log_set_source_level, 2);
+
+  /*
+   * Document-method: getSources
+   * call-seq: getSources
+   *
+   * Gets an array of log sources in the system.
+   */
+  rb_define_singleton_method(ph_log, "getSources", ph_log_get_sources, 0);
+}
+
+
+VALUE ph_log_enable(VALUE self, VALUE level, VALUE output_file) {
+  ph_raise(PhidgetLog_enable(NUM2INT(level), StringValueCStr(output_file)));
+  return Qnil;
+}
+
+VALUE ph_log_disable(VALUE self) {
+  ph_raise(PhidgetLog_disable());
+  return Qnil;
+}
+
+VALUE ph_log_get_level(VALUE self) {
+  Phidget_LogLevel level;
+  ph_raise(PhidgetLog_getLevel(&level));
+  return INT2NUM(level);
+}
+
+VALUE ph_log_set_level(VALUE self, VALUE level) {
+  ph_raise(PhidgetLog_setLevel(NUM2INT(level)));
+  return Qnil;
+}
+
+VALUE ph_log_log(VALUE self, VALUE level, VALUE message) {
+  ph_raise(PhidgetLog_log(NUM2INT(level), StringValueCStr(message)));
+  return Qnil;
+}
+
+VALUE ph_log_loge(VALUE self, VALUE file, VALUE line, VALUE function, VALUE source, VALUE level, VALUE message) {
+  ph_raise(PhidgetLog_loge( StringValueCStr(file),  NUM2INT(line), StringValueCStr(function),  StringValueCStr(source), NUM2INT(level), StringValueCStr(message)));
+  return Qnil;
+}
+
+VALUE ph_log_rotate(VALUE self) {
+  ph_raise(PhidgetLog_rotate());
+  return Qnil;
+}
+
+VALUE ph_log_is_rotating(VALUE self) {
+  int rotating;
+  ph_raise(PhidgetLog_isRotating(&rotating));
+  return rotating == PTRUE ? Qtrue : Qfalse;
+}
+
+VALUE ph_log_get_rotating(VALUE self) {
+  uint64_t size;
+  int count;
+  ph_raise(PhidgetLog_getRotating(&size, &count));
+  return rb_ary_new3(2, ULL2NUM(size), INT2NUM(count));
+}
+
+VALUE ph_log_set_rotating(VALUE self, VALUE size, VALUE keep_count) {
+  ph_raise(PhidgetLog_setRotating(NUM2ULL(size), NUM2INT(keep_count)));
+  return Qnil;
+}
+
+VALUE ph_log_enable_rotating(VALUE self) {
+  ph_raise(PhidgetLog_enableRotating());
+  return Qnil;
+}
+
+VALUE ph_log_disable_rotating(VALUE self) {
+  ph_raise(PhidgetLog_disableRotating());
+  return Qnil;
+}
+
+VALUE ph_log_add_source(VALUE self, VALUE source, VALUE level) {
+  ph_raise(PhidgetLog_addSource(StringValueCStr(source), NUM2INT(level)));
+  return Qnil;
+}
+
+VALUE ph_log_get_source_level(VALUE self, VALUE source) {
+  Phidget_LogLevel level;
+  ph_raise(PhidgetLog_getSourceLevel(StringValueCStr(source), &level));
+  return INT2NUM(level);
+}
+
+VALUE ph_log_set_source_level(VALUE self, VALUE source, VALUE level) {
+  ph_raise(PhidgetLog_setSourceLevel(StringValueCStr(source), NUM2INT(level)));
+  return Qnil;
+}
+
+VALUE ph_log_get_sources(VALUE self) {
+  PhidgetReturnCode rc;
+  const char **sources;
+  uint32_t count;
+  VALUE ary = rb_ary_new();
+
+  ph_raise(PhidgetLog_getSources(NULL, &count));
+  sources = malloc(sizeof(const char *) * count);
+
+  rc = PhidgetLog_getSources(sources, &count);
+  if( rc != EPHIDGET_OK ) {
+    free(sources);
+    ph_raise(rc);
+  }
+
+  for(uint32_t i=0; i<count; i++) rb_ary_push(ary, rb_str_new2(sources[i]));
+  free(sources);
+  return ary;
+}
+