2 Copyright (C) 2010-2011 jeanfi@gmail.com
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 #define _(str) gettext(str)
27 #include <sensors/sensors.h>
28 #include <sensors/error.h>
34 struct psensor *psensor_create(char *id, char *name,
35 unsigned int type, int values_max_length)
37 struct psensor *psensor
38 = (struct psensor *)malloc(sizeof(struct psensor));
43 psensor->min = UNKNOWN_VALUE;
44 psensor->max = UNKNOWN_VALUE;
48 psensor->values_max_length = values_max_length;
49 psensor->measures = measures_create(values_max_length);
51 psensor->alarm_limit = 0;
53 psensor->cb_alarm_raised = NULL;
54 psensor->cb_alarm_raised_data = NULL;
55 psensor->alarm_raised = 0;
57 psensor->alarm_enabled = 0;
61 psensor->color = NULL;
66 void psensor_values_resize(struct psensor *s, int new_size)
68 struct measure *new_ms, *cur_ms;
71 cur_size = s->values_max_length;
73 new_ms = measures_create(new_size);
77 for (i = 0; i < new_size - 1 && i < cur_size - 1; i++)
78 measure_copy(&cur_ms[cur_size - i - 1],
79 &new_ms[new_size - i - 1]);
81 measures_free(s->measures);
84 s->values_max_length = new_size;
88 void psensor_free(struct psensor *sensor)
97 measures_free(sensor->measures);
105 void psensor_list_free(struct psensor **sensors)
107 struct psensor **sensor_cur;
110 sensor_cur = sensors;
112 while (*sensor_cur) {
113 psensor_free(*sensor_cur);
124 int psensor_list_size(struct psensor **sensors)
127 struct psensor **sensor_cur;
133 sensor_cur = sensors;
135 while (*sensor_cur) {
142 int psensor_list_contains_type(struct psensor **sensors, unsigned int type)
151 if ((*s)->type == type)
159 struct psensor **psensor_list_add(struct psensor **sensors,
160 struct psensor *sensor)
162 int size = psensor_list_size(sensors);
164 struct psensor **result
165 = malloc((size + 1 + 1) * sizeof(struct psensor *));
168 memcpy(result, sensors, size * sizeof(struct psensor *));
170 result[size] = sensor;
171 result[size + 1] = NULL;
176 struct psensor *psensor_list_get_by_id(struct psensor **sensors, const char *id)
178 struct psensor **sensors_cur = sensors;
180 while (*sensors_cur) {
181 if (!strcmp((*sensors_cur)->id, id))
190 int is_temp_type(unsigned int type)
192 return type & SENSOR_TYPE_TEMP;
195 int is_fan_type(unsigned int type)
197 return type & SENSOR_TYPE_FAN;
200 char *psensor_value_to_string(unsigned int type, double value)
202 /* should not be possible to exceed 20 characters with temp or
203 rpm values the .x part is never displayed */
204 char *str = malloc(20);
208 if (is_temp_type(type))
213 sprintf(str, "%.0f%s", value, unit);
218 void psensor_set_current_value(struct psensor *sensor, double value)
222 if (gettimeofday(&tv, NULL) != 0)
225 psensor_set_current_measure(sensor, value, tv);
229 psensor_set_current_measure(struct psensor *s,
230 double v, struct timeval tv)
234 (s->values_max_length - 1) * sizeof(struct measure));
236 s->measures[s->values_max_length - 1].value = v;
237 s->measures[s->values_max_length - 1].time = tv;
239 if (s->min == UNKNOWN_VALUE || v < s->min)
242 if (s->max == UNKNOWN_VALUE || v > s->max)
245 if (s->alarm_limit && s->alarm_enabled) {
246 if (v > s->alarm_limit) {
247 if (!s->alarm_raised && s->cb_alarm_raised)
248 s->cb_alarm_raised(s,
249 s->cb_alarm_raised_data);
258 double psensor_get_current_value(struct psensor *sensor)
260 return sensor->measures[sensor->values_max_length - 1].value;
263 struct measure *psensor_get_current_measure(struct psensor *sensor)
265 return &sensor->measures[sensor->values_max_length - 1];
269 Returns the minimal value of a given 'type' (SENSOR_TYPE_TEMP or
272 double get_min_value(struct psensor **sensors, int type)
274 double m = UNKNOWN_VALUE;
275 struct psensor **s = sensors;
278 struct psensor *sensor = *s;
280 if (sensor->enabled && (sensor->type & type)) {
284 for (i = 0; i < sensor->values_max_length; i++) {
285 t = sensor->measures[i].value;
287 if (t == UNKNOWN_VALUE)
290 if (m == UNKNOWN_VALUE || t < m)
301 Returns the maximal value of a given 'type' (SENSOR_TYPE_TEMP or
304 static double get_max_value(struct psensor **sensors, int type)
306 double m = UNKNOWN_VALUE;
307 struct psensor **s = sensors;
310 struct psensor *sensor = *s;
312 if (sensor->enabled && (sensor->type & type)) {
315 for (i = 0; i < sensor->values_max_length; i++) {
316 t = sensor->measures[i].value;
318 if (t == UNKNOWN_VALUE)
321 if (m == UNKNOWN_VALUE || t > m)
332 psensor_get_max_current_value(struct psensor **sensors, unsigned int type)
334 double m = UNKNOWN_VALUE;
335 struct psensor **s_cur = sensors;
338 struct psensor *s = *s_cur;
340 if (s->enabled && (s->type & type)) {
341 double v = psensor_get_current_value(s);
343 if (m == UNKNOWN_VALUE || v > m)
353 double get_min_temp(struct psensor **sensors)
355 return get_min_value(sensors, SENSOR_TYPE_TEMP);
358 double get_min_rpm(struct psensor **sensors)
360 return get_min_value(sensors, SENSOR_TYPE_FAN);
363 double get_max_rpm(struct psensor **sensors)
365 return get_max_value(sensors, SENSOR_TYPE_FAN);
368 double get_max_temp(struct psensor **sensors)
370 return get_max_value(sensors, SENSOR_TYPE_TEMP);
373 struct psensor **get_all_sensors(int values_max_length)
375 struct psensor **psensors = NULL;
377 const sensors_chip_name *chip;
379 struct psensor **tmp_psensors;
380 const sensors_feature *feature;
381 struct psensor *psensor;
384 while ((chip = sensors_get_detected_chips(NULL, &chip_nr))) {
386 while ((feature = sensors_get_features(chip, &i))) {
388 if (feature->type == SENSORS_FEATURE_TEMP
389 || feature->type == SENSORS_FEATURE_FAN) {
391 psensor = lmsensor_psensor_create
392 (chip, feature, values_max_length);
396 = psensor_list_add(psensors,
401 psensors = tmp_psensors;
409 tmp_psensors = hdd_psensor_list_add(psensors, values_max_length);
411 if (tmp_psensors != psensors) {
413 psensors = tmp_psensors;
416 if (!psensors) { /* there is no detected sensors */
417 psensors = malloc(sizeof(struct psensor *));
424 const char *psensor_type_to_str(unsigned int type)
426 if (type & SENSOR_TYPE_REMOTE)
429 if (type & SENSOR_TYPE_LMSENSOR_TEMP)
430 return "Temperature";
432 if (type & SENSOR_TYPE_LMSENSOR_FAN)
435 if (type & SENSOR_TYPE_NVIDIA)
436 return "NVidia GPU Temperature";
438 if (type & SENSOR_TYPE_HDD_TEMP)
439 return "HDD Temperature";
441 return "N/A"; /* should not be possible */
445 const char *psensor_type_to_unit_str(unsigned int type)
447 if (type & SENSOR_TYPE_TEMP)
450 if (type & SENSOR_TYPE_FAN)
456 void psensor_list_update_measures(struct psensor **sensors)
458 lmsensor_psensor_list_update(sensors);
460 if (psensor_list_contains_type(sensors, SENSOR_TYPE_HDD_TEMP))
461 hdd_psensor_list_update(sensors);