2 * Copyright (C) 2010-2014 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)
30 #include <temperature.h>
32 struct psensor *psensor_create(char *id,
36 int values_max_length)
38 struct psensor *psensor;
40 psensor = (struct psensor *)malloc(sizeof(struct psensor));
45 psensor->sess_lowest = UNKNOWN_DBL_VALUE;
46 psensor->sess_highest = UNKNOWN_DBL_VALUE;
48 if (type & SENSOR_TYPE_PERCENT) {
52 psensor->min = UNKNOWN_DBL_VALUE;
53 psensor->max = UNKNOWN_DBL_VALUE;
58 psensor->values_max_length = values_max_length;
59 psensor->measures = measures_dbl_create(values_max_length);
61 psensor->alarm_high_threshold = 0;
62 psensor->alarm_low_threshold = 0;
64 psensor->cb_alarm_raised = NULL;
65 psensor->cb_alarm_raised_data = NULL;
66 psensor->alarm_raised = 0;
68 psensor->provider_data = NULL;
69 psensor->provider_data_free_fct = &free;
74 void psensor_values_resize(struct psensor *s, int new_size)
76 struct measure *new_ms, *cur_ms;
79 cur_size = s->values_max_length;
81 new_ms = measures_dbl_create(new_size);
86 for (i = 0; i < new_size - 1 && i < cur_size - 1; i++)
87 measure_copy(&cur_ms[cur_size - i - 1],
88 &new_ms[new_size - i - 1]);
90 measures_free(s->measures);
93 s->values_max_length = new_size;
97 void psensor_free(struct psensor *s)
102 log_debug("Cleanup %s", s->id);
110 measures_free(s->measures);
112 if (s->provider_data && s->provider_data_free_fct)
113 s->provider_data_free_fct(s->provider_data);
118 void psensor_list_free(struct psensor **sensors)
120 struct psensor **sensor_cur;
123 sensor_cur = sensors;
125 while (*sensor_cur) {
126 psensor_free(*sensor_cur);
137 int psensor_list_size(struct psensor **sensors)
140 struct psensor **sensor_cur;
146 sensor_cur = sensors;
148 while (*sensor_cur) {
155 struct psensor **psensor_list_add(struct psensor **sensors,
156 struct psensor *sensor)
159 struct psensor **result;
161 size = psensor_list_size(sensors);
163 result = malloc((size + 1 + 1) * sizeof(struct psensor *));
166 memcpy(result, sensors, size * sizeof(struct psensor *));
168 result[size] = sensor;
169 result[size + 1] = NULL;
174 void psensor_list_append(struct psensor ***sensors, struct psensor *sensor)
176 struct psensor **tmp;
181 tmp = psensor_list_add(*sensors, sensor);
183 if (tmp != *sensors) {
190 struct psensor *psensor_list_get_by_id(struct psensor **sensors, const char *id)
192 struct psensor **sensors_cur = sensors;
194 while (*sensors_cur) {
195 if (!strcmp((*sensors_cur)->id, id))
204 int is_temp_type(unsigned int type)
206 return type & SENSOR_TYPE_TEMP;
210 psensor_value_to_str(unsigned int type, double value, int use_celsius)
216 * should not be possible to exceed 20 characters with temp or
217 * rpm values the .x part is never displayed
221 unit = psensor_type_to_unit_str(type, use_celsius);
223 if (is_temp_type(type) && !use_celsius)
224 value = celsius_to_fahrenheit(value);
226 sprintf(str, "%.0f%s", value, unit);
232 psensor_measure_to_str(const struct measure *m,
234 unsigned int use_celsius)
236 return psensor_value_to_str(type, m->value, use_celsius);
239 void psensor_set_current_value(struct psensor *sensor, double value)
243 if (gettimeofday(&tv, NULL) != 0)
246 psensor_set_current_measure(sensor, value, tv);
249 void psensor_set_current_measure(struct psensor *s, double v, struct timeval tv)
253 (s->values_max_length - 1) * sizeof(struct measure));
255 s->measures[s->values_max_length - 1].value = v;
256 s->measures[s->values_max_length - 1].time = tv;
258 if (s->sess_lowest == UNKNOWN_DBL_VALUE || v < s->sess_lowest)
261 if (s->sess_highest == UNKNOWN_DBL_VALUE || v > s->sess_highest)
264 if (v > s->alarm_high_threshold || v < s->alarm_low_threshold) {
265 if (!s->alarm_raised && s->cb_alarm_raised) {
266 s->alarm_raised = true;
267 s->cb_alarm_raised(s, s->cb_alarm_raised_data);
270 s->alarm_raised = false;
274 double psensor_get_current_value(const struct psensor *sensor)
276 return sensor->measures[sensor->values_max_length - 1].value;
279 struct measure *psensor_get_current_measure(struct psensor *sensor)
281 return &sensor->measures[sensor->values_max_length - 1];
285 * Returns the minimal value of a given 'type' (SENSOR_TYPE_TEMP or
288 static double get_min_value(struct psensor **sensors, int type)
290 double m = UNKNOWN_DBL_VALUE;
291 struct psensor **s = sensors;
294 struct psensor *sensor = *s;
296 if (sensor->type & type) {
300 for (i = 0; i < sensor->values_max_length; i++) {
301 t = sensor->measures[i].value;
303 if (t == UNKNOWN_DBL_VALUE)
306 if (m == UNKNOWN_DBL_VALUE || t < m)
317 * Returns the maximal value of a given 'type' (SENSOR_TYPE_TEMP or
320 double get_max_value(struct psensor **sensors, int type)
322 double m = UNKNOWN_DBL_VALUE;
323 struct psensor **s = sensors;
326 struct psensor *sensor = *s;
328 if (sensor->type & type) {
332 for (i = 0; i < sensor->values_max_length; i++) {
333 t = sensor->measures[i].value;
335 if (t == UNKNOWN_DBL_VALUE)
338 if (m == UNKNOWN_DBL_VALUE || t > m)
348 double get_min_temp(struct psensor **sensors)
350 return get_min_value(sensors, SENSOR_TYPE_TEMP);
353 double get_min_rpm(struct psensor **sensors)
355 return get_min_value(sensors, SENSOR_TYPE_FAN);
358 double get_max_rpm(struct psensor **sensors)
360 return get_max_value(sensors, SENSOR_TYPE_FAN);
363 double get_max_temp(struct psensor **sensors)
365 return get_max_value(sensors, SENSOR_TYPE_TEMP);
368 const char *psensor_type_to_str(unsigned int type)
370 if (type & SENSOR_TYPE_NVCTRL) {
371 if (type & SENSOR_TYPE_TEMP)
372 return "Temperature";
373 else if (type & SENSOR_TYPE_GRAPHICS)
374 return "Graphics usage";
375 else if (type & SENSOR_TYPE_VIDEO)
376 return "Video usage";
377 else if (type & SENSOR_TYPE_MEMORY)
378 return "Memory usage";
379 else if (type & SENSOR_TYPE_PCIE)
385 if (type & SENSOR_TYPE_ATIADL) {
386 if (type & SENSOR_TYPE_TEMP)
387 return "AMD GPU Temperature";
388 else if (type & SENSOR_TYPE_RPM)
389 return "AMD GPU Fan Speed";
390 /*else type & SENSOR_TYPE_USAGE */
391 return "AMD GPU Usage";
394 if ((type & SENSOR_TYPE_HDD_TEMP) == SENSOR_TYPE_HDD_TEMP)
395 return "HDD Temperature";
397 if ((type & SENSOR_TYPE_CPU_USAGE) == SENSOR_TYPE_CPU_USAGE)
400 if (type & SENSOR_TYPE_TEMP)
401 return "Temperature";
403 if (type & SENSOR_TYPE_RPM)
406 if (type & SENSOR_TYPE_CPU)
409 if (type & SENSOR_TYPE_REMOTE)
412 if (type & SENSOR_TYPE_MEMORY)
419 const char *psensor_type_to_unit_str(unsigned int type, int use_celsius)
421 if (is_temp_type(type)) {
425 } else if (type & SENSOR_TYPE_RPM) {
427 } else if (type & SENSOR_TYPE_PERCENT) {
433 void psensor_log_measures(struct psensor **sensors)
435 if (log_level == LOG_DEBUG) {
440 log_debug("Measure: %s %.2f",
442 psensor_get_current_value(*sensors));
449 struct psensor **psensor_list_copy(struct psensor **sensors)
451 struct psensor **result;
454 n = psensor_list_size(sensors);
455 result = malloc((n+1) * sizeof(struct psensor *));
456 for (i = 0; i < n; i++)
457 result[i] = sensors[i];
464 psensor_current_value_to_str(const struct psensor *s, unsigned int use_celsius)
466 return psensor_value_to_str(s->type,
467 psensor_get_current_value(s),