2 * Copyright (C) 2010-2012 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)
35 struct psensor *psensor_create(char *id, char *name,
36 unsigned int type, int values_max_length)
38 struct psensor *psensor
39 = (struct psensor *)malloc(sizeof(struct psensor));
44 psensor->min = UNKNOWN_DBL_VALUE;
45 psensor->max = UNKNOWN_DBL_VALUE;
49 psensor->values_max_length = values_max_length;
50 psensor->measures = measures_dbl_create(values_max_length);
52 psensor->alarm_limit = 0;
54 psensor->cb_alarm_raised = NULL;
55 psensor->cb_alarm_raised_data = NULL;
56 psensor->alarm_raised = 0;
58 psensor->alarm_enabled = 0;
62 psensor->color = NULL;
67 void psensor_values_resize(struct psensor *s, int new_size)
69 struct measure *new_ms, *cur_ms;
72 cur_size = s->values_max_length;
74 new_ms = measures_dbl_create(new_size);
78 for (i = 0; i < new_size - 1 && i < cur_size - 1; i++)
79 measure_copy(&cur_ms[cur_size - i - 1],
80 &new_ms[new_size - i - 1]);
82 measures_free(s->measures);
85 s->values_max_length = new_size;
89 void psensor_free(struct psensor *sensor)
98 measures_free(sensor->measures);
106 void psensor_list_free(struct psensor **sensors)
108 struct psensor **sensor_cur;
111 sensor_cur = sensors;
113 while (*sensor_cur) {
114 psensor_free(*sensor_cur);
125 int psensor_list_size(struct psensor **sensors)
128 struct psensor **sensor_cur;
134 sensor_cur = sensors;
136 while (*sensor_cur) {
143 int psensor_list_contains_type(struct psensor **sensors, unsigned int type)
152 if ((*s)->type == type)
160 struct psensor **psensor_list_add(struct psensor **sensors,
161 struct psensor *sensor)
163 int size = psensor_list_size(sensors);
165 struct psensor **result
166 = malloc((size + 1 + 1) * sizeof(struct psensor *));
169 memcpy(result, sensors, size * sizeof(struct psensor *));
171 result[size] = sensor;
172 result[size + 1] = NULL;
177 struct psensor *psensor_list_get_by_id(struct psensor **sensors, const char *id)
179 struct psensor **sensors_cur = sensors;
181 while (*sensors_cur) {
182 if (!strcmp((*sensors_cur)->id, id))
191 int is_temp_type(unsigned int type)
193 return type & SENSOR_TYPE_TEMP;
196 int is_fan_type(unsigned int type)
198 return type & SENSOR_TYPE_FAN;
201 char *psensor_value_to_string(unsigned int type, double value)
203 /* should not be possible to exceed 20 characters with temp or
204 rpm values the .x part is never displayed */
205 char *str = malloc(20);
209 if (is_temp_type(type))
211 else if (type & SENSOR_TYPE_CPU_USAGE)
216 sprintf(str, "%.0f%s", value, unit);
221 void psensor_set_current_value(struct psensor *sensor, double value)
225 if (gettimeofday(&tv, NULL) != 0)
228 psensor_set_current_measure(sensor, value, tv);
232 psensor_set_current_measure(struct psensor *s,
233 double v, struct timeval tv)
237 (s->values_max_length - 1) * sizeof(struct measure));
239 s->measures[s->values_max_length - 1].value.d_num = v;
240 s->measures[s->values_max_length - 1].time = tv;
242 if (s->min == UNKNOWN_DBL_VALUE || v < s->min)
245 if (s->max == UNKNOWN_DBL_VALUE || v > s->max)
248 if (s->alarm_limit && s->alarm_enabled) {
249 if (v > s->alarm_limit) {
250 if (!s->alarm_raised && s->cb_alarm_raised)
251 s->cb_alarm_raised(s,
252 s->cb_alarm_raised_data);
261 double psensor_get_current_value(struct psensor *sensor)
263 return sensor->measures[sensor->values_max_length - 1].value.d_num;
266 struct measure *psensor_get_current_measure(struct psensor *sensor)
268 return &sensor->measures[sensor->values_max_length - 1];
272 Returns the minimal value of a given 'type' (SENSOR_TYPE_TEMP or
275 double get_min_value(struct psensor **sensors, int type)
277 double m = UNKNOWN_DBL_VALUE;
278 struct psensor **s = sensors;
281 struct psensor *sensor = *s;
283 if (sensor->enabled && (sensor->type & type)) {
287 for (i = 0; i < sensor->values_max_length; i++) {
288 t = sensor->measures[i].value.d_num;
290 if (t == UNKNOWN_DBL_VALUE)
293 if (m == UNKNOWN_DBL_VALUE || t < m)
304 Returns the maximal value of a given 'type' (SENSOR_TYPE_TEMP or
307 double get_max_value(struct psensor **sensors, int type)
309 double m = UNKNOWN_DBL_VALUE;
310 struct psensor **s = sensors;
313 struct psensor *sensor = *s;
315 if (sensor->enabled && (sensor->type & type)) {
318 for (i = 0; i < sensor->values_max_length; i++) {
319 t = sensor->measures[i].value.d_num;
321 if (t == UNKNOWN_DBL_VALUE)
324 if (m == UNKNOWN_DBL_VALUE || t > m)
335 psensor_get_max_current_value(struct psensor **sensors, unsigned int type)
337 double m = UNKNOWN_DBL_VALUE;
338 struct psensor **s_cur = sensors;
341 struct psensor *s = *s_cur;
343 if (s->enabled && (s->type & type)) {
344 double v = psensor_get_current_value(s);
346 if (m == UNKNOWN_DBL_VALUE || v > m)
356 double get_min_temp(struct psensor **sensors)
358 return get_min_value(sensors, SENSOR_TYPE_TEMP);
361 double get_min_rpm(struct psensor **sensors)
363 return get_min_value(sensors, SENSOR_TYPE_FAN);
366 double get_max_rpm(struct psensor **sensors)
368 return get_max_value(sensors, SENSOR_TYPE_FAN);
371 double get_max_temp(struct psensor **sensors)
373 return get_max_value(sensors, SENSOR_TYPE_TEMP);
376 struct psensor **get_all_sensors(int values_max_length)
378 struct psensor **psensors = NULL;
379 struct psensor **tmp_psensors;
381 psensors = lmsensor_psensor_list_add(NULL, values_max_length);
383 tmp_psensors = hdd_psensor_list_add(psensors, values_max_length);
384 if (tmp_psensors != psensors) {
386 psensors = tmp_psensors;
389 if (!psensors) { /* there is no detected sensors */
390 psensors = malloc(sizeof(struct psensor *));
397 const char *psensor_type_to_str(unsigned int type)
399 if ((type & SENSOR_TYPE_NVIDIA_TEMP) == SENSOR_TYPE_NVIDIA_TEMP)
400 return "NVidia GPU Temperature";
402 if ((type & SENSOR_TYPE_AMD_TEMP) == SENSOR_TYPE_AMD_TEMP)
403 return "AMD GPU Temperature";
405 if ((type & SENSOR_TYPE_AMD_FAN) == SENSOR_TYPE_AMD_FAN)
406 return "AMD GPU Fan Speed";
408 if ((type & SENSOR_TYPE_HDD_TEMP) == SENSOR_TYPE_HDD_TEMP)
409 return "HDD Temperature";
411 if (type & SENSOR_TYPE_CPU_USAGE)
414 if (type & SENSOR_TYPE_TEMP)
415 return "Temperature";
417 if (type & SENSOR_TYPE_FAN)
420 if (type & SENSOR_TYPE_REMOTE)
423 return "N/A"; /* should not be possible */
427 const char *psensor_type_to_unit_str(unsigned int type)
429 if (type & SENSOR_TYPE_TEMP)
432 if (type & SENSOR_TYPE_FAN)
435 if (type & SENSOR_TYPE_CPU_USAGE)
441 void psensor_list_update_measures(struct psensor **sensors)
443 lmsensor_psensor_list_update(sensors);
446 cpu_psensor_list_update(sensors);
449 if (psensor_list_contains_type(sensors, SENSOR_TYPE_HDD_TEMP))
450 hdd_psensor_list_update(sensors);
458 void psensor_cleanup()