phidgets 0.1.3 → 1.0.0

data/ext/phidgets/phidgets_phsensor.c

@@ -1,22 +1,108 @@
 
 #include "phidgets.h"
 
+#define PH_CHANGE_CALLBACK  0
 
-VALUE ph_phsensor_init(VALUE self);
-VALUE ph_phsensor_get_ph(VALUE self);
-VALUE ph_phsensor_get_ph_min(VALUE self);
-VALUE ph_phsensor_get_ph_max(VALUE self);
-VALUE ph_phsensor_get_ph_change_trigger(VALUE self);
-VALUE ph_phsensor_set_ph_change_trigger(VALUE self, VALUE trigger);
-VALUE ph_phsensor_get_potential(VALUE self);
-VALUE ph_phsensor_get_potential_min(VALUE self);
-VALUE ph_phsensor_get_potential_max(VALUE self);
-VALUE ph_phsensor_set_temperature(VALUE self, VALUE temperature);
 
-#ifdef PH_CALLBACK
-VALUE ph_phsensor_set_on_ph_change_handler(VALUE self, VALUE handler);
-int ph_phsensor_on_ph_change(CPhidgetPHSensorHandle phid, void *userPtr, double ph);
-#endif
+
+VALUE ph_phsensor_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetPHSensor_create((PhidgetPHSensorHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_phsensor_get_correction_temperature(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getCorrectionTemperature);
+}
+
+VALUE ph_phsensor_set_correction_temperature(VALUE self, VALUE temperature) {
+  ph_raise(PhidgetPHSensor_setCorrectionTemperature((PhidgetPHSensorHandle)get_ph_handle(self), NUM2DBL(temperature)));
+  return Qnil;
+}
+
+VALUE ph_phsensor_get_min_correction_temperature(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getMinCorrectionTemperature);
+}
+
+VALUE ph_phsensor_get_max_correction_temperature(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getMaxCorrectionTemperature);
+}
+
+VALUE ph_phsensor_get_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetPHSensor_getDataInterval);
+}
+
+VALUE ph_phsensor_set_data_interval(VALUE self, VALUE interval) {
+  ph_raise(PhidgetPHSensor_setDataInterval((PhidgetPHSensorHandle)get_ph_handle(self), NUM2UINT(interval)));
+  return Qnil;
+}
+
+VALUE ph_phsensor_get_min_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetPHSensor_getMinDataInterval);
+}
+
+VALUE ph_phsensor_get_max_data_interval(VALUE self) {
+  return ph_get_uint(get_ph_handle(self), (phidget_get_uint_func)PhidgetPHSensor_getMaxDataInterval);
+}
+
+VALUE ph_phsensor_get_ph(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getPH);
+}
+
+VALUE ph_phsensor_get_min_ph(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getMinPH);
+}
+
+VALUE ph_phsensor_get_max_ph(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getMaxPH);
+}
+
+VALUE ph_phsensor_get_ph_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getPHChangeTrigger);
+}
+
+VALUE ph_phsensor_set_ph_change_trigger(VALUE self, VALUE trigger) {
+  ph_raise(PhidgetPHSensor_setPHChangeTrigger((PhidgetPHSensorHandle)get_ph_handle(self), NUM2DBL(trigger)));
+  return Qnil;
+}
+
+VALUE ph_phsensor_get_min_ph_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getMinPHChangeTrigger);
+}
+
+VALUE ph_phsensor_get_max_ph_change_trigger(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPHSensor_getMaxPHChangeTrigger);
+}
+
+
+void CCONV ph_phsensor_on_ph_change(PhidgetPHSensorHandle phid, void *userPtr, double ph) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  while(sem_wait(&callback_data->handler_ready)!=0) {};
+  callback_data->arg1 = DBL2NUM(ph);
+  callback_data->arg2 = Qnil;
+  callback_data->arg3 = Qnil;
+  callback_data->arg4 = Qnil;
+  sem_post(&callback_data->callback_called);
+}
+
+
+VALUE ph_phsensor_set_on_ph_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callbacks[PH_CHANGE_CALLBACK];
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->callback = T_NIL;
+    callback_data->exit = true;
+    ph_raise(PhidgetPHSensor_setOnPHChangeHandler((PhidgetPHSensorHandle)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(PhidgetPHSensor_setOnPHChangeHandler((PhidgetPHSensorHandle)ph->handle, ph_phsensor_on_ph_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
 
 
 void Init_ph_sensor() {
@@ -31,178 +117,140 @@ void Init_ph_sensor() {
    */
   rb_define_method(ph_phsensor, "initialize", ph_phsensor_init, 0);
 
-  /* Document-method: getPH
-   * call-seq: getPH -> ph
+  /* Document-method: getCorrectionTemperature
+   * call-seq: getCorrectionTemperature -> temperature
    *
-   * Gets the sensed PH.
+   * Set this property to the measured temperature of the solution to correct the slope of the pH conversion for temperature.
    */
-  rb_define_method(ph_phsensor, "getPH", ph_phsensor_get_ph, 0);
+  rb_define_method(ph_phsensor, "getCorrectionTemperature", ph_phsensor_get_correction_temperature, 0);
+  rb_define_alias(ph_phsensor, "correction_temperature", "getCorrectionTemperature");
 
-  /* Document-method: getPHMin
-   * call-seq: getPHMin -> ph
+  /* Document-method: setCorrectionTemperature
+   * call-seq: setCorrectionTemperature(temperature)
    *
-   * Gets the minimum PH that the sensor could report.
+   * Set this property to the measured temperature of the solution to correct the slope of the pH conversion for temperature.
    */
-  rb_define_method(ph_phsensor, "getPHMin", ph_phsensor_get_ph_min, 0);
+  rb_define_method(ph_phsensor, "setCorrectionTemperature", ph_phsensor_set_correction_temperature, 1);
+  rb_define_alias(ph_phsensor, "correction_temperature=", "setCorrectionTemperature");
 
-  /* Document-method: getPHMax
-   * call-seq: getPHMax -> ph
+  /* Document-method: getMinCorrectionTemperature
+   * call-seq: getMinCorrectionTemperature -> temperature
    *
-   * Gets the maximum PH that the sensor could report.
+   * The minimum value that CorrectionTemperature can be set to.
    */
-  rb_define_method(ph_phsensor, "getPHMax", ph_phsensor_get_ph_max, 0);
+  rb_define_method(ph_phsensor, "getMinCorrectionTemperature", ph_phsensor_get_min_correction_temperature, 0);
+  rb_define_alias(ph_phsensor, "min_correction_temperature", "getMinCorrectionTemperature");
 
-  /* Document-method: getPHChangeTrigger
-   * call-seq: getPHChangeTrigger -> trigger
+  /* Document-method: getMaxCorrectionTemperature
+   * call-seq: getMaxCorrectionTemperature -> temperature
    *
-   * Gets the PH change trigger.
+   * The maximum value that CorrectionTemperature can be set to.
    */
-  rb_define_method(ph_phsensor, "getPHChangeTrigger", ph_phsensor_get_ph_change_trigger, 0);
+  rb_define_method(ph_phsensor, "getMaxCorrectionTemperature", ph_phsensor_get_max_correction_temperature, 0);
+  rb_define_alias(ph_phsensor, "max_correction_temperature", "getMaxCorrectionTemperature");
 
-  /* Document-method: setPHChangeTrigger
-   * call-seq: setPHChangeTrigger(trigger)
+  /* Document-method: getDataInterval
+   * call-seq: getDataInterval -> data_interval
    *
-   * Sets the PH change trigger.
+   * The DataInterval is the time that must elapse before the channel will fire another PHChange event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between PHChange events can also affected by the PHChangeTrigger.
    */
-  rb_define_method(ph_phsensor, "setPHChangeTrigger", ph_phsensor_set_ph_change_trigger, 1);
+  rb_define_method(ph_phsensor, "getDataInterval", ph_phsensor_get_data_interval, 0);
+  rb_define_alias(ph_phsensor, "data_interval", "getDataInterval");
 
-  /* Document-method: getPotential
-   * call-seq: getPotential -> potential
+  /* Document-method: setDataInterval
+   * call-seq: setDataInterval(data_interval)
    *
-   * Gets the sensed potential.
+   * The DataInterval is the time that must elapse before the channel will fire another PHChange event.
+   * The data interval is bounded by MinDataInterval and MaxDataInterval.
+   * The timing between PHChange events can also affected by the PHChangeTrigger.
    */
-  rb_define_method(ph_phsensor, "getPotential", ph_phsensor_get_potential, 0);
+  rb_define_method(ph_phsensor, "setDataInterval", ph_phsensor_set_data_interval, 1);
+  rb_define_alias(ph_phsensor, "data_interval=", "setDataInterval");
 
-  /* Document-method: getPotentialMin
-   * call-seq: getPotentialMin -> potential
+  /* Document-method: getMinDataInterval
+   * call-seq: getMinDataInterval -> data_interval
    *
-   * Gets the minimum potential that can be sensed.
+   * The minimum value that DataInterval can be set to.
    */
-  rb_define_method(ph_phsensor, "getPotentialMin", ph_phsensor_get_potential_min, 0);
+  rb_define_method(ph_phsensor, "getMinDataInterval", ph_phsensor_get_min_data_interval, 0);
+  rb_define_alias(ph_phsensor, "min_data_interval", "getMinDataInterval");
 
-  /* Document-method: getPotentialMax
-   * call-seq: getPotentialMax -> potential
+  /* Document-method: getMaxDataInterval
+   * call-seq: getMaxDataInterval -> data_interval
    *
-   * Gets the maximum potential that can be sensed.
+   * The maximum value that DataInterval can be set to.
    */
-  rb_define_method(ph_phsensor, "getPotentialMax", ph_phsensor_get_potential_max, 0);
+  rb_define_method(ph_phsensor, "getMaxDataInterval", ph_phsensor_get_max_data_interval, 0);
+  rb_define_alias(ph_phsensor, "max_data_interval", "getMaxDataInterval");
 
-  /* Document-method: setTemperature
-   * call-seq: setTemperature(temperature)
+  /* Document-method: getPH
+   * call-seq: getPH -> ph
    *
-   * Sets the temperature to be used for PH calculations.
+   * The most recent pH value that the channel has reported.
+   * This value will always be between MinPH and MaxPH.
    */
-  rb_define_method(ph_phsensor, "setTemperature", ph_phsensor_set_temperature, 1);
-
-#ifdef PH_CALLBACK
-  rb_define_private_method(ph_phsensor, "ext_setOnPHChangeHandler", ph_phsensor_set_on_ph_change_handler, 1);
-#endif
-
+  rb_define_method(ph_phsensor, "getPH", ph_phsensor_get_ph, 0);
   rb_define_alias(ph_phsensor, "ph", "getPH");
-  rb_define_alias(ph_phsensor, "ph_min", "getPHMin");
-  rb_define_alias(ph_phsensor, "ph_max", "getPHMax");
-  rb_define_alias(ph_phsensor, "ph_change_trigger", "getPHChangeTrigger");
-  rb_define_alias(ph_phsensor, "ph_change_trigger=", "setPHChangeTrigger");
-  rb_define_alias(ph_phsensor, "potential", "getPotential");
-  rb_define_alias(ph_phsensor, "potential_min", "getPotentialMin");
-  rb_define_alias(ph_phsensor, "potential_max", "getPotentialMax");
-  rb_define_alias(ph_phsensor, "temperature=", "setTemperature");
-}
-
-
-
-VALUE ph_phsensor_init(VALUE self) {
-  ph_data_t *ph = get_ph_data(self);
-  ph_raise(CPhidgetPHSensor_create((CPhidgetPHSensorHandle *)(&(ph->handle))));
-  return self;
-}
-
-VALUE ph_phsensor_get_ph(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double ph;
-  ph_raise(CPhidgetPHSensor_getPH(handle, &ph));
-  return rb_float_new(ph);
-}
 
-VALUE ph_phsensor_get_ph_min(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double ph;
-  ph_raise(CPhidgetPHSensor_getPHMin(handle, &ph));
-  return rb_float_new(ph);
-}
-
-VALUE ph_phsensor_get_ph_max(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double ph;
-  ph_raise(CPhidgetPHSensor_getPHMax(handle, &ph));
-  return rb_float_new(ph);
-}
-
-VALUE ph_phsensor_get_ph_change_trigger(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double trigger;
-  ph_raise(CPhidgetPHSensor_getPHChangeTrigger(handle, &trigger));
-  return rb_float_new(trigger);
-}
-
-VALUE ph_phsensor_set_ph_change_trigger(VALUE self, VALUE trigger) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  ph_raise(CPhidgetPHSensor_setPHChangeTrigger(handle, NUM2DBL(trigger)));
-  return Qnil;
-}
-
-VALUE ph_phsensor_get_potential(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double potential;
-  ph_raise(CPhidgetPHSensor_getPotential(handle, &potential));
-  return rb_float_new(potential);
-}
+  /* Document-method: getMinPH
+   * call-seq: getMinPH -> ph
+   *
+   * The minimum value the PHChange event will report.
+   */
+  rb_define_method(ph_phsensor, "getMinPH", ph_phsensor_get_min_ph, 0);
+  rb_define_alias(ph_phsensor, "min_ph", "getMinPH");
 
-VALUE ph_phsensor_get_potential_min(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double potential;
-  ph_raise(CPhidgetPHSensor_getPotentialMin(handle, &potential));
-  return rb_float_new(potential);
-}
+  /* Document-method: getMaxPH
+   * call-seq: getMaxPH -> ph
+   *
+   * The maximum value the PHChange event will report.
+   */
+  rb_define_method(ph_phsensor, "getMaxPH", ph_phsensor_get_max_ph, 0);
+  rb_define_alias(ph_phsensor, "max_ph", "getMaxPH");
 
-VALUE ph_phsensor_get_potential_max(VALUE self) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  double potential;
-  ph_raise(CPhidgetPHSensor_getPotentialMax(handle, &potential));
-  return rb_float_new(potential);
-}
+  /* Document-method: getPHChangeTrigger
+   * call-seq: getPHChangeTrigger -> trigger
+   *
+   * The channel will not issue a PHChange event until the pH value has changed by the amount specified by the PHChangeTrigger.
+   * Setting the PHChangeTrigger 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_phsensor, "getPHChangeTrigger", ph_phsensor_get_ph_change_trigger, 0);
+  rb_define_alias(ph_phsensor, "ph_change_trigger", "getPHChangeTrigger");
 
-VALUE ph_phsensor_set_temperature(VALUE self, VALUE temperature) {
-  CPhidgetPHSensorHandle handle = (CPhidgetPHSensorHandle)get_ph_handle(self);
-  ph_raise(CPhidgetPHSensor_setTemperature(handle, NUM2DBL(temperature)));
-  return Qnil;
-}
+  /* Document-method: setPHChangeTrigger
+   * call-seq: setPHChangeTrigger(trigger)
+   *
+   * The channel will not issue a PHChange event until the pH value has changed by the amount specified by the PHChangeTrigger.
+   * Setting the PHChangeTrigger 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_phsensor, "setPHChangeTrigger", ph_phsensor_set_ph_change_trigger, 1);
+  rb_define_alias(ph_phsensor, "ph_change_trigger=", "setPHChangeTrigger");
 
+  /* Document-method: getMinPHChangeTrigger
+   * call-seq: getMinPHChangeTrigger -> trigger
+   *
+   * The channel will not issue a PHChange event until the pH value has changed by the amount specified by the PHChangeTrigger.
+   * Setting the PHChangeTrigger 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_phsensor, "getMinPHChangeTrigger", ph_phsensor_get_min_ph_change_trigger, 0);
+  rb_define_alias(ph_phsensor, "min_ph_change_trigger", "getMinPHChangeTrigger");
 
-#ifdef PH_CALLBACK
-VALUE ph_phsensor_set_on_ph_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(CPhidgetPHSensor_set_OnPHChange_Handler((CPhidgetPHSensorHandle)ph->handle, NULL, (void *)NULL));
-  } else {
-    callback_data->called = false;
-    callback_data->exit = false;
-    callback_data->phidget = self;
-    callback_data->callback = handler;
-    ph_raise(CPhidgetPHSensor_set_OnPHChange_Handler((CPhidgetPHSensorHandle)ph->handle, ph_phsensor_on_ph_change, (void *)callback_data));
-    ph_callback_thread(callback_data);
-  }
-  return Qnil;
-}
+  /* Document-method: getMaxPHChangeTrigger
+   * call-seq: getMaxPHChangeTrigger -> trigger
+   *
+   * The channel will not issue a PHChange event until the pH value has changed by the amount specified by the PHChangeTrigger.
+   * Setting the PHChangeTrigger 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_phsensor, "getMaxPHChangeTrigger", ph_phsensor_get_max_ph_change_trigger, 0);
+  rb_define_alias(ph_phsensor, "max_ph_change_trigger", "getMaxPHChangeTrigger");
 
 
-int ph_phsensor_on_ph_change(CPhidgetPHSensorHandle phid, void *userPtr, double ph) {
-  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
-  callback_data->called = true;
-  return EPHIDGET_OK;
+  rb_define_private_method(ph_phsensor, "ext_setOnPHChangeHandler", ph_phsensor_set_on_ph_change_handler, 1);
 }
 
-#endif
-

data/ext/phidgets/phidgets_power_guard.c

@@ -0,0 +1,144 @@
+
+#include "phidgets.h"
+
+
+
+VALUE ph_power_guard_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(PhidgetPowerGuard_create((PhidgetPowerGuardHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_power_guard_get_fan_mode(VALUE self) {
+  return ph_get_int(get_ph_handle(self), (phidget_get_int_func)PhidgetPowerGuard_getFanMode);
+}
+
+VALUE ph_power_guard_set_fan_mode(VALUE self, VALUE mode) {
+  ph_raise(PhidgetPowerGuard_setFanMode((PhidgetPowerGuardHandle)get_ph_handle(self), NUM2INT(mode)));
+  return Qnil;
+}
+
+VALUE ph_power_guard_get_over_voltage(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPowerGuard_getOverVoltage);
+}
+
+VALUE ph_power_guard_set_over_voltage(VALUE self, VALUE over_voltage) {
+  ph_raise(PhidgetPowerGuard_setOverVoltage((PhidgetPowerGuardHandle)get_ph_handle(self), NUM2DBL(over_voltage)));
+  return Qnil;
+}
+
+VALUE ph_power_guard_get_min_over_voltage(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPowerGuard_getMinOverVoltage);
+}
+
+VALUE ph_power_guard_get_max_over_voltage(VALUE self) {
+  return ph_get_double(get_ph_handle(self), (phidget_get_double_func)PhidgetPowerGuard_getMaxOverVoltage);
+}
+
+VALUE ph_power_guard_get_power_enabled(VALUE self) {
+  return ph_get_bool(get_ph_handle(self), (phidget_get_bool_func)PhidgetPowerGuard_getPowerEnabled);
+}
+
+VALUE ph_power_guard_set_power_enabled(VALUE self, VALUE enabled) {
+  ph_raise(PhidgetPowerGuard_setPowerEnabled((PhidgetPowerGuardHandle)get_ph_handle(self), TYPE(enabled) == T_TRUE ? PTRUE : PFALSE));
+  return Qnil;
+}
+
+
+void Init_power_guard() {
+  VALUE ph_module = rb_const_get(rb_cObject, rb_intern("Phidgets"));
+  VALUE ph_common = rb_const_get(ph_module, rb_intern("Common"));
+  VALUE ph_power_guard = rb_define_class_under(ph_module, "PowerGuard", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget PowerGuard object.
+   */
+  rb_define_method(ph_power_guard, "initialize", ph_power_guard_init, 0);
+
+  /* Document-method: getFanMode
+   * call-seq: getFanMode -> fan_mode
+   *
+   * The FanMode dictates the operating condition of the fan.
+   * Choose between on, off, or automatic (based on temperature).
+   * If the FanMode is set to automatic, the fan will turn on when the temperature reaches 70°C and it will remain on until the temperature falls below 55°C.
+   * If the FanMode is off, the device will still turn on the fan if the temperature reaches 85°C and it will remain on until it falls below 70°C.
+   */
+  rb_define_method(ph_power_guard, "getFanMode", ph_power_guard_get_fan_mode, 0);
+  rb_define_alias(ph_power_guard, "fan_mode", "getFanMode");
+
+  /* Document-method: setFanMode
+   * call-seq: setFanMode(fan_mode)
+   *
+   * The FanMode dictates the operating condition of the fan.
+   * Choose between on, off, or automatic (based on temperature).
+   * If the FanMode is set to automatic, the fan will turn on when the temperature reaches 70°C and it will remain on until the temperature falls below 55°C.
+   * If the FanMode is off, the device will still turn on the fan if the temperature reaches 85°C and it will remain on until it falls below 70°C.
+   */
+  rb_define_method(ph_power_guard, "setFanMode", ph_power_guard_set_fan_mode, 1);
+  rb_define_alias(ph_power_guard, "fan_mode=", "setFanMode");
+
+  /* Document-method: getOverVoltage
+   * call-seq: getOverVoltage -> over_voltage
+   *
+   * The device constantly monitors the output voltage, and if it exceeds the OverVoltage value, it will disconnect the input from the output.
+   * This functionality is critical for protecting power supplies from regenerated voltage coming from motors. Many power supplies assume that
+   * a higher than output expected voltage is related to an internal failure to the power supply, and will permanently disable themselves to protect
+   * the system. A typical safe value is to set OverVoltage to 1-2 volts higher than the output voltage of the supply. For instance, a 12V supply
+   * would be protected by setting OverVoltage to 13V.
+   * The device will connect the input to the output again when the voltage drops to (OverVoltage - 1V).
+   */
+  rb_define_method(ph_power_guard, "getOverVoltage", ph_power_guard_get_over_voltage, 0);
+  rb_define_alias(ph_power_guard, "over_voltage", "getOverVoltage");
+
+  /* Document-method: setOverVoltage
+   * call-seq: setOverVoltage(over_voltage)
+   *
+   * The device constantly monitors the output voltage, and if it exceeds the OverVoltage value, it will disconnect the input from the output.
+   * This functionality is critical for protecting power supplies from regenerated voltage coming from motors. Many power supplies assume that
+   * a higher than output expected voltage is related to an internal failure to the power supply, and will permanently disable themselves to protect
+   * the system. A typical safe value is to set OverVoltage to 1-2 volts higher than the output voltage of the supply. For instance, a 12V supply
+   * would be protected by setting OverVoltage to 13V.
+   * The device will connect the input to the output again when the voltage drops to (OverVoltage - 1V).
+   */
+  rb_define_method(ph_power_guard, "setOverVoltage", ph_power_guard_set_over_voltage, 1);
+  rb_define_alias(ph_power_guard, "over_voltage=", "setOverVoltage");
+
+  /* Document-method: getMinOverVoltage
+   * call-seq: getMinOverVoltage -> over_voltage
+   *
+   * The minimum value that OverVoltage can be set to.
+   */
+  rb_define_method(ph_power_guard, "getMinOverVoltage", ph_power_guard_get_min_over_voltage, 0);
+  rb_define_alias(ph_power_guard, "min_over_voltage", "getMinOverVoltage");
+
+  /* Document-method: getMaxOverVoltage
+   * call-seq: getMaxOverVoltage -> over_voltage
+   *
+   * The maximum value that OverVoltage can be set to.
+   */
+  rb_define_method(ph_power_guard, "getMaxOverVoltage", ph_power_guard_get_max_over_voltage, 0);
+  rb_define_alias(ph_power_guard, "max_over_voltage", "getMaxOverVoltage");
+
+  /* Document-method: getPowerEnabled
+   * call-seq: getPowerEnabled -> true or false
+   *
+   * When PowerEnabled is true, the device will connect the input to the output and begin monitoring.
+   * The output voltage is constantly monitored and will be automatically disconnected from the input when the output exceeds the OverVoltage value.
+   * PowerEnabled allows the device to operate as a Solid State Relay, powering on or off all devices connected to the output.
+   */
+  rb_define_method(ph_power_guard, "getPowerEnabled", ph_power_guard_get_power_enabled, 0);
+  rb_define_alias(ph_power_guard, "power_enabled", "getPowerEnabled");
+
+  /* Document-method: setPowerEnabled
+   * call-seq: setPowerEnabled(power_enabled)
+   *
+   * When PowerEnabled is true, the device will connect the input to the output and begin monitoring.
+   * The output voltage is constantly monitored and will be automatically disconnected from the input when the output exceeds the OverVoltage value.
+   * PowerEnabled allows the device to operate as a Solid State Relay, powering on or off all devices connected to the output.
+   */
+  rb_define_method(ph_power_guard, "setPowerEnabled", ph_power_guard_set_power_enabled, 1);
+  rb_define_alias(ph_power_guard, "power_enabled=", "setPowerEnabled");
+}
+