lmsensors 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6e1c703203fcebc6433c02baeb8e27d25cdc94acd25937c1a22291fec0b7031
-  data.tar.gz: 8cb6984cff4359a059566c16f4c7674cf170a9a4564ccc848922da6825b64692
+  metadata.gz: 858f04b62fbb7681a9c3359a9a896b2000ef7ed46ccfd1c2c8ecb18ed80fe3e8
+  data.tar.gz: b1ece2b715f45c8b0a31a750d618bf8d98fcee82981e36238054797296436e19
 SHA512:
-  metadata.gz: c90e178a106a429a89f887c960568424af6860a834b441dc3292ca5225fa775a42d25d78a8cf7c5f9b4bbe18fe02af35843bfaa636d4326a22631660bd77eb84
-  data.tar.gz: 63a5335b4c7c4814162591921771935b6c17f4bdb5dbb699375f693cff88a622734b5f71084380432d0c95db1fd563878b3513fa56c921e7d8582638295c2b14
+  metadata.gz: bd44fd770fddaad0dbb16c386b60ad0834151c93660d41b58fc0859c1f9cbba127633558d3801e4c29adddf0639e0735a61a8b27b05b203a00063d1614e30069
+  data.tar.gz: f494c372bba145664b5cad4e8f04ab98586ae6104c5e0534409b5afd8f5813d2822a5d03c5e5797e94152ad034b9ba8e87ed7cb4e8ff8584a88be4362d64addb

data/CHANGELOG.md

@@ -1,2 +1,5 @@
 ### CHANGELOG -- (Ruby LmSensors) ###
-1) 0.1.0, unreleased: 2021-May-26 -- Several major changes to the API access functionality. Massive levels of abstraction, per use cases noted from the Ruby programming server. [t. Edelweiss]
+1) 0.1.0, unreleased: 2021-May-26 -- Several major changes to the API access functionality. Massive levels of abstraction, per use cases noted from the Ruby programming server. [t. Edelweiss]
+1) 0.1.1, [CRITICAL PATCH] immediate pre-release: 2021-Jul-22 -- **CRITICAL PATCH (but does not change interface) -- please read** ``changes/0.1.1-critical.md`` **for information.** [t. Edelweiss]
+1) 0.1.1, immediate pre-release: 2021-Jul-22 -- The default formatting has been fixed, because some sensors do not report the values requested. As such, they will not output a formatted value, if one does not exist -- this came to me on testing with my NAS, where the iGPU on my Ryzen APU does not report voltage, but as "N/A", so it shows as ``nil`` to Ruby. [t. Edelweiss]
+1) 0.1.1, immediate pre-release: 2021-Jul-22 -- Fixed the README, as there was a typo. Also added the necessary above-mentioned critical change file. [t. Edelweiss]

data/README.md

@@ -52,7 +52,7 @@ s.reset_fmap # Reset it back to the default
 # Sensor object to sobj.
 sobj = items[:idx]
 sobj.name # Name of Sensor
-sobj.adapater # Adapter of Sensor
+sobj.adapter # Adapter of Sensor
 sobj.path # Path of Sensor
 sobj.info # Return the name, adapter, and path of a Sensor
 sobj.read # Raw data from the :stat part of the Sensor

data/Rakefile

@@ -0,0 +1,8 @@
+# Rakefile
+require "rake/extensiontask"
+
+# Build the LmSensors extension
+Rake::ExtensionTask.new "lmsensors_base" do |ext|
+  ext.lib_dir = "ext/lmsensors_base"
+  ext.source_pattern = "*.{c,h}"
+end # End build on LmSensors

data/ext/lmsensors_base/extconf.rb

@@ -6,4 +6,4 @@ $LFLAGS = '-lsensors'
 $FLAGS = 'clean'
 have_library("sensors")
 have_header("sensors/sensors.h")
-create_makefile("lmsensors_base/lmsensors_base")
+create_makefile("lmsensors_base")

data/ext/lmsensors_base/lmsensors_base.c

@@ -0,0 +1,315 @@
+// ext/lmsensors_base/lmsensors_base.c
+/* Last backed-up version: < 2021-May-21 @ 22:18:35 */
+#include "lmsensors_base.h"
+
+#define LMSLOADER sensors_obj* sensor; TypedData_Get_Struct(self, sensors_obj, &sensors_type, sensor);
+
+#define LMSVALIDATE if (!LMS_OPEN) {\
+return rb_str_new2(\
+"ERROR: Sensors were not configured! Run `LmSensors.init [filename|nil]`"); }
+
+// ---------------------------
+// LMSENSORS MODULE METHODS BELOW
+// ---------------------------
+
+/*
+ * sensors_init works ACROSS different sensor objects and
+ * should, therefore, be handled by the module.
+ */
+VALUE lmsensors_init(VALUE self, VALUE filename) {
+  // First, check if the sensors were already initialized
+  if (LMS_OPEN) {
+    return LMS_OPEN;
+  } // End init check
+  
+  // Inheriting class should override this with either NULL of value
+  FILE *input = NULL;
+  // If no file is chosen, just pass NULL -- usually is NULL
+  if (RB_TYPE_P(filename, T_STRING)) {
+    FILE *input = fopen(StringValueCStr(filename), "r");
+  } // Otherwise, don't try to open, leave NULL
+  
+  int err = 0; // Errors are stored here
+  err = sensors_init(input);
+  if (err) { return LMS_OPEN; } // There was an error -- return Qfalse
+  else {
+    LMS_OPEN = Qtrue;
+    return LMS_OPEN;
+  } // No error -- initialized
+} // End module init
+
+/* 
+ * Document-method: pro_cleanup
+ *  
+ *  (LmSensors::SensorsBase lmsensors_cleanup)
+ *  
+ *  Cleans up the resources used by the LmSensors module
+ */
+// Cleanup sensors
+VALUE lmsensors_cleanup() {
+  LMS_OPEN = Qfalse;
+  sensors_cleanup();
+  return LMS_OPEN;
+} // End module cleanup
+
+// ---------------------------
+// SENSORS METHODS BELOW
+// ---------------------------
+
+/*
+ * The sensors_obj struct stores
+ * iterable constant fields to be used 
+ * when accessing available chips, as well
+ * as their features and subfeatures.
+ * 
+ * Despite being const, they are actually altered by
+ * pointer to their internal structure, as per the
+ * lmsensors API.
+ * 
+ * The previous chip_name_str was abstracted to the Ruby side.
+ */
+typedef struct {
+  const sensors_chip_name *chip_ptr;
+  const sensors_feature *feat_ptr;
+  const sensors_subfeature *subfeat_ptr;
+} sensors_obj; // End sensors object struct
+
+// Free the data in the sensors object
+void sensors_free(void* data) {
+  free(data);
+} // End sensors free
+
+// Get the size of the sensors object
+size_t sensors_size(const void* data) {
+  return sizeof(data);
+} // End size getter
+
+// Encapsulate the sensors object for use with
+// Ruby's side of the code
+static const rb_data_type_t sensors_type = {
+  .wrap_struct_name = "sensors_obj",
+  .function = {
+    .dmark = NULL,
+    .dfree = sensors_free,
+    .dsize = sensors_size,
+  },
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+}; // End encapsulation
+
+// Allocate space for the object
+VALUE sensors_obj_alloc(VALUE self) {
+  // Allocate memory for object
+  sensors_obj* sensor = malloc(sizeof(sensors_obj));
+  // Wrap it within a sensors type struct
+  return TypedData_Wrap_Struct(self, &sensors_type, sensor);
+} // End memory allocation
+
+// Constructor
+VALUE method_sensors_initialize(VALUE self) {
+  // Create the pointers
+  sensors_chip_name *chip;
+  sensors_feature *feat;
+  sensors_subfeature *subfeat;
+  
+  // Attach them to struct
+  sensors_obj s = {
+    .chip_ptr = chip,
+    .feat_ptr = feat,
+    .subfeat_ptr = subfeat,
+  };
+  
+  LMSLOADER; // Shorthand load sensor
+  *sensor = s; // Bind the struct
+  return self;
+} // End constructor
+
+/* 
+ * Get the subfeature data for each chip's features.
+ */
+VALUE method_sensors_get_subfeatures(VALUE self) {
+  LMSLOADER; // Shorthand load sensor
+  LMSVALIDATE; // Shorthand early return, if not loaded
+  int snr = 0;
+  int err = 0;
+  double value;
+  VALUE subfeatures = rb_hash_new();
+  // On Ruby side, will determine feature unit type
+  // from the type.
+  rb_hash_aset(subfeatures, rb_id2sym(rb_intern("type")), 
+    INT2NUM(sensor->feat_ptr->type));
+  
+  // Loop through all the features
+  while ((sensor->subfeat_ptr = sensors_get_all_subfeatures(
+    sensor->chip_ptr, sensor->feat_ptr, &snr))) {
+    // Set the core values for the card, such as ID
+    VALUE sf = rb_hash_new();
+  
+    VALUE sf_name = rb_str_new2(sensor->subfeat_ptr->name);
+    
+    // Set the main keys
+    // Name of the subfeature
+    rb_hash_aset(sf, rb_id2sym(rb_intern("name")), sf_name);
+    // This is included, because it will usually be put in
+    // the subfeature, anyway, and it's faster to do in C
+    rb_hash_aset(sf, rb_id2sym(rb_intern("type")), 
+      INT2NUM(sensor->feat_ptr->type));
+    // This is the subfeature type
+    rb_hash_aset(sf, rb_id2sym(rb_intern("subtype")), 
+      INT2NUM(sensor->subfeat_ptr->type));
+    // Number of the subfeature
+    rb_hash_aset(sf, rb_id2sym(rb_intern("number")),
+      INT2NUM(sensor->subfeat_ptr->number));
+    // Number of the feature the subfeature is mapped to
+    rb_hash_aset(sf, rb_id2sym(rb_intern("mapping")),
+      INT2NUM(sensor->subfeat_ptr->mapping));
+    // RWX flags
+    rb_hash_aset(sf, rb_id2sym(rb_intern("flags")),
+      INT2NUM(sensor->subfeat_ptr->flags));
+    
+    // Set the value, if it can be found
+    err = sensors_get_value(sensor->chip_ptr, (snr - 1), &value);
+    if (!err) {
+      rb_hash_aset(sf, rb_id2sym(rb_intern("value")),
+        DBL2NUM(value));
+    } // End value setter
+    
+    // Attach the individual subfeature
+    rb_hash_aset(subfeatures, rb_id2sym(rb_intern(StringValueCStr(sf_name))), sf);
+  } // End feature loop
+  return subfeatures;
+} // End subfeatures getter
+
+/* 
+ * Get a list of features for a chip.
+ */
+VALUE method_sensors_get_features(VALUE self) {
+  LMSLOADER; // Shorthand load sensor
+  LMSVALIDATE; // Shorthand early return, if not loaded
+  int nr = 0;
+  VALUE features = rb_hash_new();
+  
+  // Loop through all the features
+  while ((sensor->feat_ptr = sensors_get_features(sensor->chip_ptr, &nr))) {
+    char *label = sensors_get_label(sensor->chip_ptr, sensor->feat_ptr);
+    rb_hash_aset(features, rb_id2sym(rb_intern(label)),
+      method_sensors_get_subfeatures(self));
+    free(label);
+  } // End feature loop
+  
+  return features;
+} // End features getter
+
+/* 
+ * Enumerate all the chips that can be read from.
+ * 
+ * If a chip name is set, only read chips of that type.
+ * 
+ * If show_data is true, stat each chip of that type.
+ * 
+ * The different way to call this should be abstracted
+ * into the Ruby side wrapping this.
+ */
+VALUE method_sensors_enumerate_chips(VALUE self, VALUE show_data, VALUE name) {
+  LMSLOADER; // Shorthand load sensor
+  int chip_nr = 0;
+  int cnt = 0;
+  int err = 0;
+  int success = 0;
+  
+  // Create temporary buffer for data
+  char buffer[BUFSIZE];
+  size_t size = BUFSIZE;
+  
+  LMSVALIDATE; // Shorthand early return, if not loaded
+  
+  // Intermediary chip item
+  sensors_chip_name chip_raw;
+  const sensors_chip_name *chip = NULL;
+  
+  if (RB_TYPE_P(name, T_STRING)) {
+    err = sensors_parse_chip_name(StringValueCStr(name), &chip_raw);
+    if (err) { return rb_str_new2("Failed to load requested chip"); }
+    else { chip = &chip_raw; }
+  } else { chip = sensor->chip_ptr; }
+  
+  // If not early return, sensors are valid
+  VALUE data = rb_hash_new();
+  while ((sensor->chip_ptr = sensors_get_detected_chips(chip, &chip_nr))) {
+    // Make sure the chip data can be collected
+    err = sensors_do_chip_sets(sensor->chip_ptr);
+    if (err) { // If anything but 0, it can't load
+      rb_hash_aset(data, rb_id2sym(rb_intern("fatal_err")), rb_str_new2(
+        "Cannot load chip sets. Have you already done 'sensors-detect?'"));
+      break;
+    } else {
+      VALUE idx = rb_sprintf("item%d", cnt);
+      const char *adapter = sensors_get_adapter_name(&sensor->chip_ptr->bus);
+      success = sensors_snprintf_chip_name(buffer, size, sensor->chip_ptr);
+      if (success > 0) {
+        // Create a new chip entry
+        VALUE curr_chip = rb_hash_new();
+        rb_hash_aset(curr_chip, rb_id2sym(rb_intern("adapter")),
+          rb_str_new2(adapter)); // Attach the adapter
+        // Attach the name of the chip
+        rb_hash_aset(curr_chip, rb_id2sym(rb_intern("name")), rb_str_new2(buffer));
+        // Get the chip path
+        VALUE path = rb_str_new2(sensor->chip_ptr->path);
+        rb_hash_aset(curr_chip, rb_id2sym(rb_intern("path")), path);
+        
+        /* 
+         * Stat the features for the card, if set
+         * Had to double-check against NIL, b/c doesn't
+         * fail the same way as in Ruby.
+         */
+        if (show_data && !NIL_P(show_data)) {
+          rb_hash_aset(curr_chip, rb_id2sym(rb_intern("stat")),
+            method_sensors_get_features(self)); }
+            
+          // Add the chip entry to the list
+          rb_hash_aset(data, path, curr_chip);
+      } else {
+        rb_hash_aset(data, rb_id2sym(rb_intern("chip_error")), idx);
+        break;
+      }
+    }
+    cnt++; // Update the count of available chips
+  }
+  chip = NULL; // Disconnect the chip placeholder
+  return data;
+} // End enumerate method
+
+/*
+ * Initialize the LmSensors wrapper
+ */
+void Init_lmsensors_base() {
+  LmSensors = rb_define_module("LmSensors"); // Module
+  
+  /* 
+   * Document-class: LmSensors::SensorsBase
+   * 
+   * This is an abstract representation of a sensor chip struct used
+   * by the lm-sensors library (https://github.com/lm-sensors/lm-sensors).
+   * 
+   * This class directly interacts with the C-side of the code, and it should
+   * not be instantiated on its own. It is abstracted in LmSensors::AbsSensor
+   * and its subclasses. If you wish to used this, you should inherit from
+   * the AbsSensor class.
+   */
+  Sensors = rb_define_class_under(LmSensors, "SensorsBase", rb_cData); // Main class
+  
+  // Define the globals
+  VALUE dec = declare_globals(LmSensors);
+  rb_global_variable(&LMS_OPEN);
+  
+  // Module methods
+  rb_define_module_function(LmSensors, "pro_init", lmsensors_init, 1);
+  rb_define_module_function(LmSensors, "pro_cleanup", lmsensors_cleanup, 0);
+  
+  // Sensors methods
+  rb_define_alloc_func(Sensors, sensors_obj_alloc);
+  rb_define_protected_method(Sensors, "pro_initialize", method_sensors_initialize, 0);
+  rb_define_protected_method(Sensors, "pro_enum", method_sensors_enumerate_chips, 2);
+  rb_define_protected_method(Sensors, "pro_features", method_sensors_get_features, 0);
+  rb_define_protected_method(Sensors, "pro_subfeatures", method_sensors_get_subfeatures, 0);
+} // End module and class initialization

data/ext/lmsensors_base/lmsensors_base.h

@@ -0,0 +1,271 @@
+// ext/lmsensors_base/lmsensors_base.h
+#include <ruby.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sensors/sensors.h>
+
+#define BUFSIZE 1024
+
+VALUE LmSensors = Qnil;
+VALUE Sensors = Qnil;
+VALUE LMS_OPEN = Qfalse;
+
+/* 
+ * Declare all the global mapping constants
+ */
+VALUE declare_globals(VALUE mod) {
+  // Map-exporting constants
+  /*  Voltage input */
+  rb_define_const(mod, "SF_IN", INT2NUM(SENSORS_FEATURE_IN));
+  /* Fan speeds in RPM */
+  rb_define_const(mod, "SF_FAN", INT2NUM(SENSORS_FEATURE_FAN));
+  /* Temperature in degrees Celsius */
+  rb_define_const(mod, "SF_TEMP", INT2NUM(SENSORS_FEATURE_TEMP));
+  /* Power (Watts) */
+  rb_define_const(mod, "SF_POWER", INT2NUM(SENSORS_FEATURE_POWER));
+  /* Energy (Joules) */
+  rb_define_const(mod, "SF_ENERGY", INT2NUM(SENSORS_FEATURE_ENERGY));
+  /* Current (Amps) */
+  rb_define_const(mod, "SF_CURR", INT2NUM(SENSORS_FEATURE_CURR));
+  /* Relative humidity (% RH) */
+  rb_define_const(mod, "SF_HUMIDITY", INT2NUM(SENSORS_FEATURE_HUMIDITY));
+  /* Video type (also measured in Volts) */
+  rb_define_const(mod, "SF_VID", INT2NUM(SENSORS_FEATURE_VID));
+  /* Intrusion alarm for the case */
+  rb_define_const(mod, "SF_INTRUSION", INT2NUM(SENSORS_FEATURE_INTRUSION));
+  /* Whether case beeper / pcspkr is enabled */
+  rb_define_const(mod, "SF_BEEP_ENABLE", INT2NUM(SENSORS_FEATURE_BEEP_ENABLE));
+  /* Unknown feature placeholder */
+  rb_define_const(mod, "SF_UNKNOWN", INT2NUM(SENSORS_FEATURE_UNKNOWN));
+  
+  // Unclear features
+  /* SENSORS_FEATURE_MAX_MAIN */
+  rb_define_const(mod, "SF_MAX_MAIN", INT2NUM(SENSORS_FEATURE_MAX_MAIN));
+  /* SENSORS_FEATURE_MAX_OTHER */
+  rb_define_const(mod, "SF_MAX_OTHER", INT2NUM(SENSORS_FEATURE_MAX_OTHER));
+  /* SENSORS_FEATURE_MAX */
+  rb_define_const(mod, "SF_MAX", INT2NUM(SENSORS_FEATURE_MAX));
+  
+  // Map-exporting limit types, for analysis
+  // ex.: critical, critical low, input, max, min
+  // Voltage
+  /* Present voltage */
+  rb_define_const(mod, "SSF_IN_INPUT", INT2NUM(SENSORS_SUBFEATURE_IN_INPUT));
+  /* Minimum allowed voltage */
+  rb_define_const(mod, "SSF_IN_MIN", INT2NUM(SENSORS_SUBFEATURE_IN_MIN));
+  /* Maximum allowed voltage */
+  rb_define_const(mod, "SSF_IN_MAX", INT2NUM(SENSORS_SUBFEATURE_IN_MAX));
+  /* Critical low voltage */
+  rb_define_const(mod, "SSF_IN_LCRIT", INT2NUM(SENSORS_SUBFEATURE_IN_LCRIT));
+  /* Critical high voltage */
+  rb_define_const(mod, "SSF_IN_CRIT", INT2NUM(SENSORS_SUBFEATURE_IN_CRIT));
+  /* Average voltage */
+  rb_define_const(mod, "SSF_IN_AVG", INT2NUM(SENSORS_SUBFEATURE_IN_AVERAGE));
+  /* Lowest detected voltage input */
+  rb_define_const(mod, "SSF_IN_LOW", INT2NUM(SENSORS_SUBFEATURE_IN_LOWEST));
+  /* Highest detected voltage input */
+  rb_define_const(mod, "SSF_IN_HIGH", INT2NUM(SENSORS_SUBFEATURE_IN_HIGHEST));
+  
+  // Voltage alarms
+  /* Voltage alarm */
+  rb_define_const(mod, "SSF_IN_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_ALARM));
+  /* Voltage alarm for minimum voltage */
+  rb_define_const(mod, "SSF_IN_MIN_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_MIN_ALARM));
+  /* Voltage alarm for max voltage */
+  rb_define_const(mod, "SSF_IN_MAX_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_MAX_ALARM));
+  /* Beep for voltage alarms */
+  rb_define_const(mod, "SSF_IN_BEEP", INT2NUM(SENSORS_SUBFEATURE_IN_BEEP));
+  /* Critical low voltage alarm */
+  rb_define_const(mod, "SSF_IN_LCRIT_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_LCRIT_ALARM));
+  /* Critical high voltage alarm */
+  rb_define_const(mod, "SSF_IN_CRIT_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_CRIT_ALARM));
+  
+  // Current
+  /* Present current input */
+  rb_define_const(mod, "SSF_CURR_INPUT", INT2NUM(SENSORS_SUBFEATURE_CURR_INPUT));
+  /* Minimum allowed current */
+  rb_define_const(mod, "SSF_CURR_MIN", INT2NUM(SENSORS_SUBFEATURE_CURR_MIN));
+  /* Maximum allowed current */
+  rb_define_const(mod, "SSF_CURR_MAX", INT2NUM(SENSORS_SUBFEATURE_CURR_MAX));
+  /* Critical low current */
+  rb_define_const(mod, "SSF_CURR_LCRIT", INT2NUM(SENSORS_SUBFEATURE_CURR_LCRIT));
+  /* Critical high current */
+  rb_define_const(mod, "SSF_CURR_CRIT", INT2NUM(SENSORS_SUBFEATURE_CURR_CRIT));
+  /* Average current */
+  rb_define_const(mod, "SSF_CURR_AVG",INT2NUM(SENSORS_SUBFEATURE_CURR_AVERAGE));
+  /* Lowest current detected */
+  rb_define_const(mod, "SSF_CURR_LOW", INT2NUM(SENSORS_SUBFEATURE_CURR_LOWEST));
+  /* Highest current detected */
+  rb_define_const(mod, "SSF_CURR_HIGH", INT2NUM(SENSORS_SUBFEATURE_CURR_HIGHEST));
+  
+  // Current alarms
+  /* Current alarm */
+  rb_define_const(mod, "SSF_CURR_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_ALARM));
+  /* Current alarm for minimum current */
+  rb_define_const(mod, "SSF_CURR_MIN_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_MIN_ALARM));
+  /* Current alarm for max current */
+  rb_define_const(mod, "SSF_CURR_MAX_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_MAX_ALARM));
+  /* Beep for current alarms */
+  rb_define_const(mod, "SSF_CURR_BEEP", INT2NUM(SENSORS_SUBFEATURE_IN_BEEP));
+  /* Critical low current alarm */
+  rb_define_const(mod, "SSF_CURR_LCRIT_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_LCRIT_ALARM));
+  /* Critical high current alarm */
+  rb_define_const(mod, "SSF_CURR_CRIT_ALARM", INT2NUM(SENSORS_SUBFEATURE_IN_CRIT_ALARM));
+  
+  // Power
+  /* Average power */
+  rb_define_const(mod, "SSF_POWER_AVG", INT2NUM(SENSORS_SUBFEATURE_POWER_AVERAGE));
+  rb_define_const(mod, "SSF_POWER_AVG_HIGH",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_AVERAGE_HIGHEST));
+  rb_define_const(mod, "SSF_POWER_AVG_LOW",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_AVERAGE_LOWEST));
+  /* 
+   * Present power input, but this seems to be usually handled by
+   * SSF_POWER_AVG, at least for my devices.
+   */
+  rb_define_const(mod, "SSF_POWER_INPUT", INT2NUM(SENSORS_SUBFEATURE_POWER_INPUT));
+  /* Highest detected power input */
+  rb_define_const(mod, "SSF_POWER_INPUT_HIGH",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_INPUT_HIGHEST));
+  /* Lowest detected power input */
+  rb_define_const(mod, "SSF_POWER_INPUT_LOW",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_INPUT_LOWEST));
+  /* User- or system- defined limit on power consumption */
+  rb_define_const(mod, "SSF_POWER_CAP", INT2NUM(SENSORS_SUBFEATURE_POWER_CAP));
+  rb_define_const(mod, "SSF_POWER_CAP_HYST",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_CAP_HYST));
+  /* Power maximum usage level */
+  rb_define_const(mod, "SSF_POWER_MAX", INT2NUM(SENSORS_SUBFEATURE_POWER_MAX));
+  /* Power critical usage level */
+  rb_define_const(mod, "SSF_POWER_CRIT", INT2NUM(SENSORS_SUBFEATURE_POWER_CRIT));
+  /* Power minimum usage level */
+  rb_define_const(mod, "SSF_POWER_MIN", INT2NUM(SENSORS_SUBFEATURE_POWER_MIN));
+  /* Power critical low level */
+  rb_define_const(mod, "SSF_POWER_LCRIT", INT2NUM(SENSORS_SUBFEATURE_POWER_LCRIT));
+  /* Interval used by this power sensor to generate averages */
+  rb_define_const(mod, "SSF_POWER_AVG_INTERVAL",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_AVERAGE_INTERVAL));
+  
+  // Power alarms
+  /* Alarm for power */
+  rb_define_const(mod, "SSF_POWER_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_ALARM));
+  /* Alarm if power is approaching the defined cap */
+  rb_define_const(mod, "SSF_POWER_CAP_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_CAP_ALARM));
+  /* Alarm if power usage is nearing max */
+  rb_define_const(mod, "SSF_POWER_MAX_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_MAX_ALARM));
+  /* Alarm if power usage is critical */
+  rb_define_const(mod, "SSF_POWER_CRIT_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_CRIT_ALARM));
+  /* Alarm if power usage is too low */
+  rb_define_const(mod, "SSF_POWER_MIN_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_MIN_ALARM));
+  /* Alarm if power usage is nearing critical low */
+  rb_define_const(mod, "SSF_POWER_LCRIT_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_POWER_LCRIT_ALARM));
+  
+  // Temps
+  /* Present temperature input */
+  rb_define_const(mod, "SSF_TEMP_INPUT", INT2NUM(SENSORS_SUBFEATURE_TEMP_INPUT));
+  /* Maximum temperature allowed */
+  rb_define_const(mod, "SSF_TEMP_MAX", INT2NUM(SENSORS_SUBFEATURE_TEMP_MAX));
+  rb_define_const(mod, "SSF_TEMP_MAX_HYST", INT2NUM(SENSORS_SUBFEATURE_TEMP_MAX_HYST));
+  /* Minimum temperature allowed */
+  rb_define_const(mod, "SSF_TEMP_MIN", INT2NUM(SENSORS_SUBFEATURE_TEMP_MIN));
+  /* Critical high temperature */
+  rb_define_const(mod, "SSF_TEMP_CRIT", INT2NUM(SENSORS_SUBFEATURE_TEMP_CRIT));
+  rb_define_const(mod, "SSF_TEMP_CRIT_HYST", INT2NUM(SENSORS_SUBFEATURE_TEMP_CRIT_HYST));
+  /* Critical low temperature */
+  rb_define_const(mod, "SSF_TEMP_LCRIT", INT2NUM(SENSORS_SUBFEATURE_TEMP_LCRIT));
+  /* Emergency-level high temperature */
+  rb_define_const(mod, "SSF_TEMP_EMERG", INT2NUM(SENSORS_SUBFEATURE_TEMP_EMERGENCY));
+  rb_define_const(mod, "SSF_TEMP_EMERG_HYST",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_EMERGENCY_HYST));
+  /* Lowest detected temperature */
+  rb_define_const(mod, "SSF_TEMP_LOW", INT2NUM(SENSORS_SUBFEATURE_TEMP_LOWEST));
+  /* Highest detected temperature */
+  rb_define_const(mod, "SSF_TEMP_HIGH", INT2NUM(SENSORS_SUBFEATURE_TEMP_HIGHEST));
+  rb_define_const(mod, "SSF_TEMP_MIN_HYST", INT2NUM(SENSORS_SUBFEATURE_TEMP_MIN_HYST));
+  rb_define_const(mod, "SSF_TEMP_LCRIT_HYST",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_LCRIT_HYST));
+  
+  // Other temp subfeatures
+  /* Type of the temperature feature */
+  rb_define_const(mod, "SSF_TEMP_TYPE", INT2NUM(SENSORS_SUBFEATURE_TEMP_TYPE));
+  /* Temperature feature reading offset */
+  rb_define_const(mod, "SSF_TEMP_OFFSET", INT2NUM(SENSORS_SUBFEATURE_TEMP_OFFSET));
+  
+  // Temperature alarm and error subfeatures
+  /* Temperature alarm */
+  rb_define_const(mod, "SSF_TEMP_ALARM", INT2NUM(SENSORS_SUBFEATURE_TEMP_ALARM));
+  /* Alarm when temperature is nearing max */
+  rb_define_const(mod, "SSF_TEMP_MAX_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_MAX_ALARM));
+  /* Alarm when temperature is nearing min */
+  rb_define_const(mod, "SSF_TEMP_MIN_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_MIN_ALARM));
+  /* Alarm when temperature is critical */
+  rb_define_const(mod, "SSF_TEMP_CRIT_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM));
+  /* Beep for temperature alarms */
+  rb_define_const(mod, "SSF_TEMP_BEEP", INT2NUM(SENSORS_SUBFEATURE_TEMP_BEEP));
+  /* If the temperature sensors has faulted or detected fault */
+  rb_define_const(mod, "SSF_TEMP_FAULT", INT2NUM(SENSORS_SUBFEATURE_TEMP_FAULT));
+  /* Alarm for when temperature is at emergency-level */
+  rb_define_const(mod, "SSF_TEMP_EMERGENCY_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_EMERGENCY_ALARM));
+  /* Alarm for when temperature approaches critical low */
+  rb_define_const(mod, "SSF_TEMP_LCRIT_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_TEMP_LCRIT_ALARM));
+  
+  // Fans
+  /* Present fan input speed */
+  rb_define_const(mod, "SSF_FAN_INPUT", INT2NUM(SENSORS_SUBFEATURE_FAN_INPUT));
+  /* Minimum fan speed */
+  rb_define_const(mod, "SSF_FAN_MIN", INT2NUM(SENSORS_SUBFEATURE_FAN_MIN));
+  /* Maximum fan speed */
+  rb_define_const(mod, "SSF_FAN_MAX", INT2NUM(SENSORS_SUBFEATURE_FAN_MAX));
+  
+  // Additional fan feature exports
+  /* Alarm for fan */
+  rb_define_const(mod, "SSF_FAN_ALARM", INT2NUM(SENSORS_SUBFEATURE_FAN_ALARM));
+  /* Whether fan sensor has detected fault */
+  rb_define_const(mod, "SSF_FAN_FAULT", INT2NUM(SENSORS_SUBFEATURE_FAN_FAULT));
+  rb_define_const(mod, "SSF_FAN_DIV", INT2NUM(SENSORS_SUBFEATURE_FAN_DIV));
+  /* Beep for fan alarms */
+  rb_define_const(mod, "SSF_FAN_BEEP", INT2NUM(SENSORS_SUBFEATURE_FAN_BEEP));
+  /* PWM / pulse settings for fan */
+  rb_define_const(mod, "SSF_FAN_PULSES", INT2NUM(SENSORS_SUBFEATURE_FAN_PULSES));
+  /* Alarm if fans approach minimum-allowed speed */
+  rb_define_const(mod, "SSF_FAN_MIN_ALARM", INT2NUM(SENSORS_SUBFEATURE_FAN_MIN_ALARM));
+  /* Alarm if fans approach maximum-allowed speed */
+  rb_define_const(mod, "SSF_FAN_MAX_ALARM", INT2NUM(SENSORS_SUBFEATURE_FAN_MAX_ALARM));
+  
+  // Alarms
+  /* Intrusion alarm subtype */
+  rb_define_const(mod, "SSF_INTRUDE_ALARM",
+    INT2NUM(SENSORS_SUBFEATURE_INTRUSION_ALARM));
+  /* Intrusion beep subtype */
+  rb_define_const(mod, "SSF_INTRUDE_BEEP",
+    INT2NUM(SENSORS_SUBFEATURE_INTRUSION_BEEP));
+  
+  // Other exports, which only have 1 subtype, exported for convenience ONLY
+  /* Energy input subtype */
+  rb_define_const(mod, "SSF_ENERGY_INPUT",
+    INT2NUM(SENSORS_SUBFEATURE_ENERGY_INPUT));
+  /* Beep enable subtype */
+  rb_define_const(mod, "SSF_BEEP_ENABLE",
+    INT2NUM(SENSORS_SUBFEATURE_BEEP_ENABLE));
+  /* Video input subfeature */
+  rb_define_const(mod, "SSF_VID", INT2NUM(SENSORS_SUBFEATURE_VID));
+  /* Humidity input subfeature */
+  rb_define_const(mod, "SSF_HUMIDITY_INPUT",
+    INT2NUM(SENSORS_SUBFEATURE_HUMIDITY_INPUT));
+  /* Currently-unknown subfeature */
+  rb_define_const(mod, "SSF_UNKNOWN", INT2NUM(SENSORS_SUBFEATURE_UNKNOWN));
+  
+  // Return complete
+  return Qtrue;
+}

data/lib/lmsensors/features/alarm.rb

@@ -22,7 +22,7 @@ module LmSensors
         # Only check is alarm is enabled.
         # The other option SSF_INTRUDE_BEEP
         # is not formatted in the normal sensor program
-        if v[:subtype] == SSF_INTRUDE_ALARM then
+        if v[:value] and (v[:subtype] == SSF_INTRUDE_ALARM) then
           out[k] = unit.call(v[:value]) end
       end # End value mapper for alarm
       out

data/lib/lmsensors/features/beep.rb

@@ -18,7 +18,7 @@ module LmSensors
       
       # Format the outputs
       feature.subfs.map do |k, v|
-        out[k] = unit.call(v[:value])
+        if v[:value] then out[k] = unit.call(v[:value]) end
       end # End value mapper for beep
       out
     end # End default beep formatter

data/lib/lmsensors/features/current.rb

@@ -19,22 +19,24 @@ module LmSensors
       # Format the outputs
       # Strip each, in case the unit is empty
       feature.subfs.values.map do |v|
-        case v[:subtype]
-        when SSF_CURR_INPUT
-          tmp[:input] = v[:value]
-          out[:input] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_CURR_MAX
-          if v[:value] != 0 then
-            tmp[:max] = v[:value]
-            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+        if v[:value] then
+          case v[:subtype]
+          when SSF_CURR_INPUT
+            tmp[:input] = v[:value]
+            out[:input] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_CURR_MAX
+            if v[:value] != 0 then
+              tmp[:max] = v[:value]
+              out[:max] = "#{v[:value].round(2)} #{unit}".strip
+            end
+          when SSF_CURR_CRIT
+            if v[:value] != 0 then
+              tmp[:crit] = v[:value]
+              out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+            end
+          when SSF_CURR_MIN
+            if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
           end
-        when SSF_CURR_CRIT
-          if v[:value] != 0 then
-            tmp[:crit] = v[:value]
-            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
-          end
-        when SSF_CURR_MIN
-          if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
         end
       end # End value mapper for fan
       

data/lib/lmsensors/features/fan.rb

@@ -20,15 +20,17 @@ module LmSensors
       # Format the outputs
       # Strip each, in case the unit is empty
       feature.subfs.values.map do |v|
-        case v[:subtype]
-        when SSF_FAN_INPUT
-          tmp[:input] = v[:value]
-          out[:input] = "#{v[:value]} #{unit}".strip
-        when SSF_FAN_MAX
-          tmp[:max] = v[:value]
-          out[:max] = "#{v[:value]} #{unit}".strip
-        when SSF_FAN_MIN
-          out[:min] = "#{v[:value]} #{unit}".strip
+        if v[:value] then
+          case v[:subtype]
+          when SSF_FAN_INPUT
+            tmp[:input] = v[:value]
+            out[:input] = "#{v[:value]} #{unit}".strip
+          when SSF_FAN_MAX
+            tmp[:max] = v[:value]
+            out[:max] = "#{v[:value]} #{unit}".strip
+          when SSF_FAN_MIN
+            out[:min] = "#{v[:value]} #{unit}".strip
+          end
         end
       end # End value mapper for fan
       

data/lib/lmsensors/features/humidity.rb

@@ -20,7 +20,7 @@ module LmSensors
       
       # Format the outputs
       feature.subfs.map do |k, v|
-        out[k] = "#{v[:value].round(2)}#{unit}"
+        if v[:value] then out[k] = "#{v[:value].round(2)}#{unit}" end
       end # End value mapper for humidity
       out
     end # End humidity proc

data/lib/lmsensors/features/power.rb

@@ -19,23 +19,25 @@ module LmSensors
       # Format the outputs
       # Strip each, in case the unit is empty
       feature.subfs.values.map do |v|
-        case v[:subtype]
-        when SSF_POWER_INPUT
-          out[:input] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_POWER_AVG
-          tmp[:average] = v[:value]
-          out[:average] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_POWER_MAX
-          tmp[:max] = v[:value]
-          out[:max] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_POWER_CRIT
-          tmp[:crit] = v[:value]
-          out[:crit] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_POWER_CAP
-          tmp[:cap] = v[:value]
-          out[:cap] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_POWER_MIN
-          out[:min] = "#{v[:value].round(2)} #{unit}".strip
+        if v[:value] then
+          case v[:subtype]
+          when SSF_POWER_INPUT
+            out[:input] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_POWER_AVG
+            tmp[:average] = v[:value]
+            out[:average] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_POWER_MAX
+            tmp[:max] = v[:value]
+            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_POWER_CRIT
+            tmp[:crit] = v[:value]
+            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_POWER_CAP
+            tmp[:cap] = v[:value]
+            out[:cap] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_POWER_MIN
+            out[:min] = "#{v[:value].round(2)} #{unit}".strip
+          end
         end
       end # End value mapper for fan
       

data/lib/lmsensors/features/temp.rb

@@ -19,22 +19,24 @@ module LmSensors
       # Format the outputs
       # Strip each, in case the unit is empty
       feature.subfs.values.map do |v|
-        case v[:subtype]
-        when SSF_TEMP_INPUT
-          tmp[:input] = v[:value]
-          out[:input] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_TEMP_MAX
-          if v[:value] != 0 then
-            tmp[:max] = v[:value]
-            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+        if v[:value] then
+          case v[:subtype]
+          when SSF_TEMP_INPUT
+            tmp[:input] = v[:value]
+            out[:input] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_TEMP_MAX
+            if v[:value] != 0 then
+              tmp[:max] = v[:value]
+              out[:max] = "#{v[:value].round(2)} #{unit}".strip
+            end
+          when SSF_TEMP_CRIT
+            if v[:value] != 0 then
+              tmp[:crit] = v[:value]
+              out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+            end
+          when SSF_TEMP_MIN
+            if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
           end
-        when SSF_TEMP_CRIT
-          if v[:value] != 0 then
-            tmp[:crit] = v[:value]
-            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
-          end
-        when SSF_TEMP_MIN
-          if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
         end
       end # End value mapper for fan
       

data/lib/lmsensors/features/voltage.rb

@@ -19,22 +19,24 @@ module LmSensors
       # Format the outputs
       # Strip each, in case the unit is empty
       feature.subfs.values.map do |v|
-        case v[:subtype]
-        when SSF_IN_INPUT
-          tmp[:input] = v[:value]
-          out[:input] = "#{v[:value].round(2)} #{unit}".strip
-        when SSF_IN_MAX
-          if v[:value] != 0 then
-            tmp[:max] = v[:value]
-            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+        if v[:value] then 
+          case v[:subtype]
+          when SSF_IN_INPUT
+            tmp[:input] = v[:value]
+            out[:input] = "#{v[:value].round(2)} #{unit}".strip
+          when SSF_IN_MAX
+            if v[:value] != 0 then
+              tmp[:max] = v[:value]
+              out[:max] = "#{v[:value].round(2)} #{unit}".strip
+            end
+          when SSF_IN_CRIT
+            if v[:value] != 0 then
+              tmp[:crit] = v[:value]
+              out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+            end
+          when SSF_IN_MIN
+            if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
           end
-        when SSF_IN_CRIT
-          if v[:value] != 0 then
-            tmp[:crit] = v[:value]
-            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
-          end
-        when SSF_IN_MIN
-          if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
         end
       end # End value mapper for fan
       

data/lib/lmsensors/lm_constants.rb

@@ -1,7 +1,7 @@
 # lib/lmsensors/lm_constants.rb
 
 # Require the base implementation
-require_relative "../lmsensors_base/lmsensors_base"
+require "lmsensors_base.so"
 
 # :nodoc: Constants for the LmSensors module
 module LmSensors

data/lib/lmsensors/lmsensors.rb

@@ -1,7 +1,7 @@
 # lib/lmsensors/lmsensors.rb
 
 # Base requires
-require_relative "../lmsensors_base/lmsensors_base"
+require "lmsensors_base.so"
 require_relative "./lm_constants"
 
 require_relative "./sensors/sensorspawner"

data/lib/lmsensors/sensors/abssensor.rb

@@ -1,7 +1,7 @@
 # lib/lmsensors/sensors/abssensors.rb
 
 # Requires
-require_relative "../../lmsensors_base/lmsensors_base"
+require "lmsensors_base.so"
 require_relative "../lm_constants"
 require_relative "../feature"
 

data/lib/lmsensors/version.rb

@@ -4,5 +4,5 @@
 module LmSensors
   ##
   # The current version
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end # End appending of version data

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lmsensors
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Edelweiss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-01 00:00:00.000000000 Z
+date: 2021-07-22 00:00:00.000000000 Z
 dependencies: []
 description: "Wrapper for the ``lm-sensors`` library, which provides the programs,
   \n``sensors`` and ``sensors-detect``, for Linux systems. This library \nand its
@@ -30,7 +30,10 @@ files:
 - FMAPPER.md
 - LICENSE.txt
 - README.md
+- Rakefile
 - ext/lmsensors_base/extconf.rb
+- ext/lmsensors_base/lmsensors_base.c
+- ext/lmsensors_base/lmsensors_base.h
 - lib/lmsensors.rb
 - lib/lmsensors/feature.rb
 - lib/lmsensors/features/abs_feature.rb
@@ -48,7 +51,6 @@ files:
 - lib/lmsensors/sensors/sensor.rb
 - lib/lmsensors/sensors/sensorspawner.rb
 - lib/lmsensors/version.rb
-- lib/lmsensors_base/lmsensors_base.so
 homepage: https://github.com/KleineEdelweiss/lmsensors_rb
 licenses:
 - LGPL-3.0