void HwmonDriver::readEvents(mxml_node_t *const) {
int err = sensors_init(NULL);
if (err) {
logg->logMessage("Failed to initialize libsensors! (%d)", err);
return;
}
sensors_sysfs_no_scaling = 1;
int chip_nr = 0;
const sensors_chip_name *chip;
while ((chip = sensors_get_detected_chips(NULL, &chip_nr))) {
int feature_nr = 0;
const sensors_feature *feature;
while ((feature = sensors_get_features(chip, &feature_nr))) {
// Keep in sync with HwmonCounter::read
// Can this counter be read?
double value;
const sensors_subfeature *const subfeature = sensors_get_subfeature(chip, feature, getInput(feature->type));
if ((subfeature == NULL) || (sensors_get_value(chip, subfeature->number, &value) != 0)) {
continue;
}
// Get the name of the counter
int len = sensors_snprintf_chip_name(NULL, 0, chip) + 1;
char *chip_name = new char[len];
sensors_snprintf_chip_name(chip_name, len, chip);
len = snprintf(NULL, 0, "hwmon_%s_%d_%d", chip_name, chip_nr, feature->number) + 1;
char *const name = new char[len];
snprintf(name, len, "hwmon_%s_%d_%d", chip_name, chip_nr, feature->number);
delete [] chip_name;
setCounters(new HwmonCounter(getCounters(), name, chip, feature));
}
}
}
static char *get_chip_name_string(const sensors_chip_name *chip) {
char *name;
#if SENSORS_API_VERSION < 0x400
// taken from lm-sensors:prog/sensors/main.c:sprintf_chip_name
switch (chip->bus) {
case SENSORS_CHIP_NAME_BUS_ISA:
name = g_strdup_printf ("%s-isa-%04x", chip->prefix, chip->addr);
break;
case SENSORS_CHIP_NAME_BUS_DUMMY:
name = g_strdup_printf ("%s-%s-%04x", chip->prefix, chip->busname, chip->addr);
break;
case SENSORS_CHIP_NAME_BUS_PCI:
name = g_strdup_printf ("%s-pci-%04x", chip->prefix, chip->addr);
break;
default:
name = g_strdup_printf ("%s-i2c-%d-%02x", chip->prefix, chip->bus, chip->addr);
break;
}
#else
// adapted from lm-sensors:prog/sensors/main.c:sprintf_chip_name
// in lm-sensors-3.0
#define BUF_SIZE 200
name = g_malloc0(BUF_SIZE);
if (sensors_snprintf_chip_name(name, BUF_SIZE, chip) < 0) {
g_free(name);
name = NULL;
}
#endif
return name;
}
static const char *chipName(const sensors_chip_name *chip)
{
static char buffer[256];
if (sensors_snprintf_chip_name(buffer, 256, chip) < 0)
return NULL;
return buffer;
}
static const char *sprintf_chip_name(const sensors_chip_name *name)
{
#define BUF_SIZE 200
static char buf[BUF_SIZE];
if (sensors_snprintf_chip_name(buf, BUF_SIZE, name) < 0)
return NULL;
return buf;
}
// Not re-entrant/thread-safe
static const char *
_j4status_sensors_get_feature_name(const sensors_chip_name *chip, const sensors_feature *feature)
{
int n;
static char name[MAX_CHIP_NAME_SIZE + NAME_MAX + 1];
n = sensors_snprintf_chip_name(name, MAX_CHIP_NAME_SIZE, chip);
name[n++] = '/';
strcpy(name + n, feature->name);
return name;
}
Chip(const sensors_chip_name * c) : chip(c) {
// populate name
if(sensors_snprintf_chip_name(name, NAME_SZ, c) < 0) {
// error: bad chip name
snprintf(name, NAME_SZ, "Unknown chip");
}
// populate features
int i = 0;
const sensors_feature * feature;
while( (feature = sensors_get_features(chip, &i)) ) {
features.push_back(Feature(c, feature));
}
}
SensorChip::SensorChip(sensors_chip_name const *chip_name,
const std::vector<std::string> &ignore) :
internal_name_(chip_name)
{
char name_buffer[NAME_BUFFER_SIZE];
sensors_snprintf_chip_name(name_buffer, NAME_BUFFER_SIZE, internal_name_);
name_ = name_buffer;
ROS_DEBUG("Found Sensor: %s", getName().c_str());
// enumerate the features of this sensor
sensors_feature const *feature;
int number = 0;
while ((feature = sensors_get_features(internal_name_, &number)) != NULL) {
sensors_feature_type type = feature->type;
SensorChipFeaturePtr feature_ptr;
switch(type){
case SENSORS_FEATURE_FAN:
feature_ptr.reset(new FanSensor(*this, feature));
break;
case SENSORS_FEATURE_TEMP:
feature_ptr.reset(new TempSensor(*this, feature));
break;
case SENSORS_FEATURE_IN:
feature_ptr.reset(new VoltageSensor(*this, feature));
break;
default:
feature_ptr.reset(new OtherSensor(*this, feature));
break;
}
if( std::count(ignore.begin(), ignore.end(),
feature_ptr->getFullName()) > 0 ) {
ROS_INFO_STREAM("Ignoring sensor " << feature_ptr->getFullName());
} else {
features_.push_back(feature_ptr);
}
}
std::stringstream info_msg;
info_msg << "Found sensor " << getName();
if( features_.size() > 0 ) {
info_msg << " with features: ";
size_t remain = features_.size();
BOOST_FOREACH(const SensorChipFeaturePtr & feature, features_) {
remain--;
info_msg << feature->getFeatureName();
if( remain > 0 ) info_msg << ", ";
}
static void
build_sensor_list(void)
{
const sensors_chip_name *chip;
const sensors_chip_name *match = 0;
const sensors_feature *feature;
int chip_nr = 0;
char name[256];
while ((chip = sensors_get_detected_chips(match, &chip_nr))) {
sensors_snprintf_chip_name(name, sizeof(name), chip);
/* Get all features and filter accordingly. */
int fnr = 0;
while ((feature = sensors_get_features(chip, &fnr))) {
char *featurename = sensors_get_label(chip, feature);
if (!featurename)
continue;
/* Create a 'current' and 'critical' object pair.
* Ignore sensor if its not temperature based.
*/
switch(feature->type) {
case SENSORS_FEATURE_TEMP:
create_object(name, featurename, chip, feature,
SENSORS_TEMP_CURRENT);
create_object(name, featurename, chip, feature,
SENSORS_TEMP_CRITICAL);
break;
case SENSORS_FEATURE_IN:
create_object(name, featurename, chip, feature,
SENSORS_VOLTAGE_CURRENT);
break;
case SENSORS_FEATURE_CURR:
create_object(name, featurename, chip, feature,
SENSORS_CURRENT_CURRENT);
break;
case SENSORS_FEATURE_POWER:
create_object(name, featurename, chip, feature,
SENSORS_POWER_CURRENT);
break;
default:
break;
}
free(featurename);
}
}
}
static PyObject*
str(ChipName *self)
{
char buffer[512];
int status;
status = sensors_snprintf_chip_name(buffer, sizeof buffer,
&(self->chip_name));
if (status < 0)
{
PyErr_SetString(SensorsException, sensors_strerror(status));
return NULL;
}
return PyString_FromString(buffer);
}
HwmonCounter::HwmonCounter(HwmonCounter *next, const sensors_chip_name *chip, const sensors_feature *feature) : next(next), key(getEventKey()), polled(false), readable(false), enabled(false), duplicate(false), chip(chip), feature(feature) {
int len = sensors_snprintf_chip_name(NULL, 0, chip) + 1;
char *chip_name = new char[len];
sensors_snprintf_chip_name(chip_name, len, chip);
len = snprintf(NULL, 0, "hwmon_%s_%d", chip_name, feature->number) + 1;
name = new char[len];
snprintf(name, len, "hwmon_%s_%d", chip_name, feature->number);
delete [] chip_name;
label = sensors_get_label(chip, feature);
switch (feature->type) {
case SENSORS_FEATURE_IN:
title = "Voltage";
input = SENSORS_SUBFEATURE_IN_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "V";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_FAN:
title = "Fan";
input = SENSORS_SUBFEATURE_FAN_INPUT;
display = "average";
counter_class = "absolute";
unit = "RPM";
modifier = 1;
monotonic = false;
break;
case SENSORS_FEATURE_TEMP:
title = "Temperature";
input = SENSORS_SUBFEATURE_TEMP_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "°C";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_POWER:
title = "Power";
input = SENSORS_SUBFEATURE_POWER_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "W";
modifier = 1000000;
monotonic = false;
break;
case SENSORS_FEATURE_ENERGY:
title = "Energy";
input = SENSORS_SUBFEATURE_ENERGY_INPUT;
display = "accumulate";
counter_class = "delta";
unit = "J";
modifier = 1000000;
monotonic = true;
break;
case SENSORS_FEATURE_CURR:
title = "Current";
input = SENSORS_SUBFEATURE_CURR_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "A";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_HUMIDITY:
title = "Humidity";
input = SENSORS_SUBFEATURE_HUMIDITY_INPUT;
display = "average";
counter_class = "absolute";
unit = "%";
modifier = 1000;
monotonic = false;
break;
default:
logg->logError(__FILE__, __LINE__, "Unsupported hwmon feature %i", feature->type);
handleException();
}
for (HwmonCounter * counter = next; counter != NULL; counter = counter->getNext()) {
if (strcmp(label, counter->getLabel()) == 0 && strcmp(title, counter->getTitle()) == 0) {
duplicate = true;
counter->duplicate = true;
break;
}
}
}
static int sensors_read (void)
{
if (sensors_load_conf () != 0)
return (-1);
#if SENSORS_API_VERSION < 0x400
for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next)
{
double value;
int status;
char plugin_instance[DATA_MAX_NAME_LEN];
char type_instance[DATA_MAX_NAME_LEN];
status = sensors_get_feature (*fl->chip,
fl->data->number, &value);
if (status < 0)
continue;
status = sensors_snprintf_chip_name (plugin_instance,
sizeof (plugin_instance), fl->chip);
if (status < 0)
continue;
sstrncpy (type_instance, fl->data->name,
sizeof (type_instance));
sensors_submit (plugin_instance,
sensor_type_name_map[fl->type],
type_instance,
value);
} /* for fl = first_feature .. NULL */
/* #endif SENSORS_API_VERSION < 0x400 */
#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500)
for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next)
{
double value;
int status;
char plugin_instance[DATA_MAX_NAME_LEN];
char type_instance[DATA_MAX_NAME_LEN];
char *sensor_label;
const char *type;
status = sensors_get_value (fl->chip,
fl->subfeature->number, &value);
if (status < 0)
continue;
status = sensors_snprintf_chip_name (plugin_instance,
sizeof (plugin_instance), fl->chip);
if (status < 0)
continue;
if (use_labels)
{
sensor_label = sensors_get_label (fl->chip, fl->feature);
sstrncpy (type_instance, sensor_label, sizeof (type_instance));
free (sensor_label);
}
else
{
sstrncpy (type_instance, fl->feature->name,
sizeof (type_instance));
}
if (fl->feature->type == SENSORS_FEATURE_IN)
type = "voltage";
else if (fl->feature->type
== SENSORS_FEATURE_FAN)
type = "fanspeed";
else if (fl->feature->type
== SENSORS_FEATURE_TEMP)
type = "temperature";
else if (fl->feature->type
== SENSORS_FEATURE_POWER)
type = "power";
else
continue;
sensors_submit (plugin_instance, type, type_instance, value);
} /* for fl = first_feature .. NULL */
#endif /* (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */
return (0);
} /* int sensors_read */