2 * Copyright (C) 2010-2013 jeanfi@gmail.com
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * 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
24 #define _(str) gettext(str)
34 struct psensor *psensor_create(char *id,
38 int values_max_length)
40 struct psensor *psensor
41 = (struct psensor *)malloc(sizeof(struct psensor));
46 psensor->min = UNKNOWN_DBL_VALUE;
47 psensor->max = UNKNOWN_DBL_VALUE;
51 psensor->values_max_length = values_max_length;
52 psensor->measures = measures_dbl_create(values_max_length);
54 psensor->alarm_enabled = 0;
55 psensor->alarm_high_threshold = 0;
56 psensor->alarm_low_threshold = 0;
58 psensor->cb_alarm_raised = NULL;
59 psensor->cb_alarm_raised_data = NULL;
60 psensor->alarm_raised = 0;
64 psensor->color = NULL;
66 psensor->graph_enabled = 1;
67 psensor->appindicator_enabled = 0;
72 void psensor_values_resize(struct psensor *s, int new_size)
74 struct measure *new_ms, *cur_ms;
77 cur_size = s->values_max_length;
79 new_ms = measures_dbl_create(new_size);
83 for (i = 0; i < new_size - 1 && i < cur_size - 1; i++)
84 measure_copy(&cur_ms[cur_size - i - 1],
85 &new_ms[new_size - i - 1]);
87 measures_free(s->measures);
90 s->values_max_length = new_size;
94 void psensor_free(struct psensor *sensor)
97 log_debug("Cleanup %s", sensor->id);
108 measures_free(sensor->measures);
116 void psensor_list_free(struct psensor **sensors)
118 struct psensor **sensor_cur;
121 sensor_cur = sensors;
123 while (*sensor_cur) {
124 psensor_free(*sensor_cur);
135 int psensor_list_size(struct psensor **sensors)
138 struct psensor **sensor_cur;
144 sensor_cur = sensors;
146 while (*sensor_cur) {
153 int psensor_list_contains_type(struct psensor **sensors, unsigned int type)
162 if ((*s)->type & type)
170 struct psensor **psensor_list_add(struct psensor **sensors,
171 struct psensor *sensor)
173 int size = psensor_list_size(sensors);
175 struct psensor **result
176 = malloc((size + 1 + 1) * sizeof(struct psensor *));
179 memcpy(result, sensors, size * sizeof(struct psensor *));
181 result[size] = sensor;
182 result[size + 1] = NULL;
187 struct psensor *psensor_list_get_by_id(struct psensor **sensors, const char *id)
189 struct psensor **sensors_cur = sensors;
191 while (*sensors_cur) {
192 if (!strcmp((*sensors_cur)->id, id))
201 int is_temp_type(unsigned int type)
203 return type & SENSOR_TYPE_TEMP;
206 int is_fan_type(unsigned int type)
208 return type & SENSOR_TYPE_FAN;
211 double celcius_to_fahrenheit(double c)
213 return c * (9.0/5.0) + 32;
216 double fahrenheit_to_celcius(double f)
218 return (f - 32) * (5.0/9.0);
222 psensor_value_to_str(unsigned int type, double value, int use_celcius)
228 * should not be possible to exceed 20 characters with temp or
229 * rpm values the .x part is never displayed
233 unit = psensor_type_to_unit_str(type, use_celcius);
235 if (is_temp_type(type) && !use_celcius)
236 value = celcius_to_fahrenheit(value);
238 sprintf(str, "%.0f%s", value, unit);
244 psensor_measure_to_str(const struct measure *m,
246 unsigned int use_celcius)
248 return psensor_value_to_str(type, m->value, use_celcius);
251 void psensor_set_current_value(struct psensor *sensor, double value)
255 if (gettimeofday(&tv, NULL) != 0)
258 psensor_set_current_measure(sensor, value, tv);
261 void psensor_set_current_measure(struct psensor *s, double v, struct timeval tv)
265 (s->values_max_length - 1) * sizeof(struct measure));
267 s->measures[s->values_max_length - 1].value = v;
268 s->measures[s->values_max_length - 1].time = tv;
270 if (s->min == UNKNOWN_DBL_VALUE || v < s->min)
273 if (s->max == UNKNOWN_DBL_VALUE || v > s->max)
276 if (s->alarm_enabled) {
277 if (v > s->alarm_high_threshold || v < s->alarm_low_threshold) {
278 if (!s->alarm_raised && s->cb_alarm_raised)
279 s->cb_alarm_raised(s, s->cb_alarm_raised_data);
288 double psensor_get_current_value(const struct psensor *sensor)
290 return sensor->measures[sensor->values_max_length - 1].value;
293 struct measure *psensor_get_current_measure(struct psensor *sensor)
295 return &sensor->measures[sensor->values_max_length - 1];
299 Returns the minimal value of a given 'type' (SENSOR_TYPE_TEMP or
302 double get_min_value(struct psensor **sensors, int type)
304 double m = UNKNOWN_DBL_VALUE;
305 struct psensor **s = sensors;
308 struct psensor *sensor = *s;
310 if (sensor->graph_enabled && (sensor->type & type)) {
314 for (i = 0; i < sensor->values_max_length; i++) {
315 t = sensor->measures[i].value;
317 if (t == UNKNOWN_DBL_VALUE)
320 if (m == UNKNOWN_DBL_VALUE || t < m)
331 Returns the maximal value of a given 'type' (SENSOR_TYPE_TEMP or
334 double get_max_value(struct psensor **sensors, int type)
336 double m = UNKNOWN_DBL_VALUE;
337 struct psensor **s = sensors;
340 struct psensor *sensor = *s;
342 if (sensor->graph_enabled && (sensor->type & type)) {
345 for (i = 0; i < sensor->values_max_length; i++) {
346 t = sensor->measures[i].value;
348 if (t == UNKNOWN_DBL_VALUE)
351 if (m == UNKNOWN_DBL_VALUE || t > m)
362 psensor_get_max_current_value(struct psensor **sensors, unsigned int type)
364 double m = UNKNOWN_DBL_VALUE;
365 struct psensor **s_cur = sensors;
368 struct psensor *s = *s_cur;
370 if (s->graph_enabled && (s->type & type)) {
371 double v = psensor_get_current_value(s);
373 if (m == UNKNOWN_DBL_VALUE || v > m)
383 double get_min_temp(struct psensor **sensors)
385 return get_min_value(sensors, SENSOR_TYPE_TEMP);
388 double get_min_rpm(struct psensor **sensors)
390 return get_min_value(sensors, SENSOR_TYPE_FAN);
393 double get_max_rpm(struct psensor **sensors)
395 return get_max_value(sensors, SENSOR_TYPE_FAN);
398 double get_max_temp(struct psensor **sensors)
400 return get_max_value(sensors, SENSOR_TYPE_TEMP);
403 struct psensor **get_all_sensors(int use_libatasmart, int values_max_length)
405 struct psensor **psensors;
406 struct psensor **tmp_psensors;
408 psensors = lmsensor_psensor_list_add(NULL, values_max_length);
410 if (!use_libatasmart) {
411 tmp_psensors = hddtemp_psensor_list_add(psensors,
413 if (tmp_psensors != psensors) {
415 psensors = tmp_psensors;
420 tmp_psensors = hdd_psensor_list_add(psensors,
422 if (tmp_psensors != psensors) {
424 psensors = tmp_psensors;
429 if (!psensors) { /* there is no detected sensors */
430 psensors = malloc(sizeof(struct psensor *));
437 const char *psensor_type_to_str(unsigned int type)
439 if (type & SENSOR_TYPE_NVCTRL)
442 if (type & SENSOR_TYPE_ATIADL) {
443 if (type & SENSOR_TYPE_TEMP)
444 return "AMD GPU Temperature";
445 else if (type & SENSOR_TYPE_RPM)
446 return "AMD GPU Fan Speed";
447 else /* type & SENSOR_TYPE_USAGE */
448 return "AMD GPU Usage";
451 if ((type & SENSOR_TYPE_HDD_TEMP) == SENSOR_TYPE_HDD_TEMP)
452 return "HDD Temperature";
454 if ((type & SENSOR_TYPE_CPU_USAGE) == SENSOR_TYPE_CPU_USAGE)
457 if (type & SENSOR_TYPE_TEMP)
458 return "Temperature";
460 if (type & SENSOR_TYPE_FAN)
463 if (type & SENSOR_TYPE_CPU)
466 if (type & SENSOR_TYPE_REMOTE)
473 const char *psensor_type_to_unit_str(unsigned int type, int use_celcius)
475 if (is_temp_type(type)) {
480 } else if (is_fan_type(type)) {
482 } else if (type & SENSOR_TYPE_CPU_USAGE) {
489 void psensor_list_update_measures(struct psensor **sensors)
491 lmsensor_psensor_list_update(sensors);
494 cpu_psensor_list_update(sensors);
497 if (psensor_list_contains_type(sensors, SENSOR_TYPE_HDDTEMP))
498 hddtemp_psensor_list_update(sensors);
501 if (psensor_list_contains_type(sensors, SENSOR_TYPE_ATASMART))
502 hdd_psensor_list_update(sensors);
506 void psensor_log_measures(struct psensor **sensors)
508 if (log_level == LOG_DEBUG)
510 log_debug("Measure: %s %.2f",
512 psensor_get_current_value(*sensors));
523 void psensor_cleanup()
528 struct psensor **psensor_list_copy(struct psensor **sensors)
530 struct psensor **result;
533 n = psensor_list_size(sensors);
534 result = malloc((n+1) * sizeof(struct psensor *));
535 for (i = 0; i < n; i++)
536 result[i] = sensors[i];
543 psensor_current_value_to_str(const struct psensor *s, unsigned int celcius)
545 return psensor_value_to_str(s->type,
546 psensor_get_current_value(s),