mirror of
https://github.com/gryf/wmtemp.git
synced 2026-04-21 05:31:26 +02:00
364 lines
9.9 KiB
C
364 lines
9.9 KiB
C
/*
|
|
* wmtempnv: a temperature monitor for WindowMaker. This little app is mainly
|
|
* based on wmsensormon and other simple dockapps, although it doesn't use
|
|
* lmsensors, just provided information from kernel via /sys filesystem.
|
|
*
|
|
* version = 0.5
|
|
*
|
|
* licence: gpl
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <string.h>
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "standards.h"
|
|
#include <X11/Xlib.h>
|
|
#include <X11/xpm.h>
|
|
#include <X11/extensions/shape.h>
|
|
|
|
#include "../wmgeneral/wmgeneral.h"
|
|
#include "../wmgeneral/misc.h"
|
|
#include "../wmgeneral/misc.h"
|
|
#include "wmtempnv_master.xpm"
|
|
#include "wmtempnv_mask.xbm"
|
|
|
|
#define MAXLEN 200
|
|
#define MAXFNAME 70
|
|
#define MAXCORENUM 4
|
|
|
|
struct entry {
|
|
char *path;
|
|
long critical;
|
|
long warning;
|
|
};
|
|
|
|
struct config {
|
|
struct entry cpu1;
|
|
struct entry cpu2;
|
|
struct entry cpu3;
|
|
struct entry cpu4;
|
|
struct entry gpu;
|
|
};
|
|
|
|
char cpu1_path[100];
|
|
int cpu1_warn = 0;
|
|
int cpu1_crit = 0;
|
|
char cpu2_path[100];
|
|
int cpu2_warn = 0;
|
|
int cpu2_crit = 0;
|
|
char cpu3_path[100];
|
|
int cpu3_warn = 0;
|
|
int cpu3_crit = 0;
|
|
char cpu4_path[100];
|
|
int cpu4_warn = 0;
|
|
int cpu4_crit = 0;
|
|
char gpu1_path[100];
|
|
int gpu1_warn = 0;
|
|
int gpu1_crit = 0;
|
|
|
|
typedef struct _core {
|
|
int temp;
|
|
/* offset is one of 0 (normal), 7 (critical), 14 (warning) */
|
|
short offset;
|
|
} core;
|
|
|
|
Display *display;
|
|
|
|
char *vcopy(char *str);
|
|
int get_gpu_temp(char *path, Display *disp);
|
|
int get_temp(struct entry *etr);
|
|
short get_offset(short temp, struct entry *etr);
|
|
void conf_read(char *filename);
|
|
void display_help(char *progname);
|
|
void display_values(int, short, short);
|
|
void draw_cpu_temp(short core_no, core *cpu);
|
|
void draw_gpu_temp(core *gpu);
|
|
void read_file_into(char *filepath, int *output);
|
|
void set_defaults(struct config *conf);
|
|
char *strip(char * string);
|
|
void parse_config(struct config *conf);
|
|
|
|
int main(int argc, char **argv){
|
|
int i;
|
|
short counter = 0;
|
|
struct config conf;
|
|
|
|
set_defaults(&conf);
|
|
|
|
parse_config(&conf);
|
|
|
|
display = XOpenDisplay(NULL);
|
|
core gpu, *cpus = malloc(MAXCORENUM * sizeof (core));
|
|
|
|
if (argc > 1) {
|
|
if (argc > 2) {
|
|
display_help(argv[0]);
|
|
exit(2);
|
|
}
|
|
|
|
if (argc == 2 &&
|
|
(strcmp(argv[1], "--help") == 0 ||
|
|
strcmp(argv[1], "-h") == 0)) {
|
|
display_help(argv[0]);
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
openXwindow(argc, argv, wmtempnv_master, wmtempnv_mask_bits,
|
|
wmtempnv_mask_width, wmtempnv_mask_height);
|
|
|
|
while(TRUE){
|
|
if (counter < 1){
|
|
counter = 5;
|
|
cpus[0].temp = get_temp(&conf.cpu1);
|
|
cpus[0].offset = get_offset(cpus[0].temp, &conf.cpu1);
|
|
cpus[1].temp = get_temp(&conf.cpu2);
|
|
cpus[1].offset = get_offset(cpus[1].temp, &conf.cpu2);
|
|
cpus[2].temp = get_temp(&conf.cpu3);
|
|
cpus[2].offset = get_offset(cpus[2].temp, &conf.cpu3);
|
|
cpus[3].temp = get_temp(&conf.cpu4);
|
|
cpus[3].offset = get_offset(cpus[3].temp, &conf.cpu4);
|
|
gpu.temp = get_temp(&conf.gpu);
|
|
gpu.offset = get_offset(gpu.temp, &conf.gpu);
|
|
}
|
|
|
|
// cpu's
|
|
for (i=0; i < 4; i++){
|
|
draw_cpu_temp(i, &cpus[i]);
|
|
}
|
|
|
|
// gpu
|
|
draw_gpu_temp(&gpu);
|
|
|
|
RedrawWindow();
|
|
counter--;
|
|
usleep(100000);
|
|
}
|
|
free(conf.cpu1.path);
|
|
free(conf.cpu2.path);
|
|
free(conf.cpu3.path);
|
|
free(conf.cpu4.path);
|
|
free(conf.gpu.path);
|
|
}
|
|
|
|
void set_defaults(struct config *conf) {
|
|
struct config configuration;
|
|
configuration = *conf;
|
|
configuration.cpu1.critical = 80;
|
|
configuration.cpu1.warning = 65;
|
|
configuration.cpu2.critical = 80;
|
|
configuration.cpu2.warning = 65;
|
|
configuration.cpu3.critical = 80;
|
|
configuration.cpu3.warning = 65;
|
|
configuration.cpu4.critical = 80;
|
|
configuration.cpu4.warning = 65;
|
|
configuration.gpu.critical = 80;
|
|
configuration.gpu.warning = 65;
|
|
|
|
configuration.cpu1.path = malloc(sizeof(char));
|
|
strcpy(configuration.cpu1.path, "");
|
|
configuration.cpu2.path = malloc(sizeof(char));
|
|
strcpy(configuration.cpu2.path, "");
|
|
configuration.cpu3.path = malloc(sizeof(char));
|
|
strcpy(configuration.cpu3.path, "");
|
|
configuration.cpu4.path = malloc(sizeof(char));
|
|
strcpy(configuration.cpu4.path, "");
|
|
configuration.gpu.path = malloc(sizeof(char));
|
|
strcpy(configuration.gpu.path, "");
|
|
*conf = configuration;
|
|
}
|
|
|
|
char *strip(char * string) {
|
|
char *string1 = string,
|
|
*string2 = &string[strlen (string) - 1];
|
|
|
|
/* Strip right side */
|
|
while ((isspace(*string2)) && (string2 >= string1))
|
|
string2--;
|
|
|
|
*(string2+1) = '\0';
|
|
|
|
/* Strip left side */
|
|
while ((isspace(*string1)) && (string1 < string2))
|
|
string1++;
|
|
|
|
strcpy (string, string1);
|
|
return string;
|
|
}
|
|
|
|
void parse_config(struct config *conf) {
|
|
char *item,
|
|
*conf_file,
|
|
buff[256],
|
|
name[MAXLEN],
|
|
value[MAXLEN];
|
|
struct config cfg;
|
|
FILE *fp;
|
|
|
|
conf_file = malloc(strlen(getenv("HOME")) + strlen("/.wmtemp") + 1);
|
|
sprintf(conf_file, "%s/.wmtemp", getenv("HOME"));
|
|
|
|
cfg = *conf;
|
|
fp = fopen (conf_file, "r");
|
|
if (fp == NULL) {
|
|
return;
|
|
}
|
|
|
|
while ((item = fgets (buff, sizeof buff, fp)) != NULL) {
|
|
if (buff[0] == '\n' || buff[0] == '#')
|
|
continue;
|
|
|
|
/* Parse name/value pair from item */
|
|
item = strtok(buff, "=");
|
|
strip(item);
|
|
if (item == NULL)
|
|
continue;
|
|
else
|
|
strncpy (name, item, MAXLEN);
|
|
|
|
item = strtok (NULL, "=");
|
|
if (item == NULL)
|
|
continue;
|
|
else
|
|
strncpy (value, item, MAXLEN);
|
|
strip(value);
|
|
|
|
if (!strcmp(name, "cpu1_path")){
|
|
free(cfg.cpu1.path);
|
|
cfg.cpu1.path = malloc(sizeof(value) + 1);
|
|
strcpy(cfg.cpu1.path, value);
|
|
}
|
|
|
|
if (!strcmp(name, "cpu2_path")){
|
|
free(cfg.cpu2.path);
|
|
cfg.cpu2.path = malloc(sizeof(value) + 1);
|
|
strcpy(cfg.cpu2.path, value);
|
|
}
|
|
|
|
if (!strcmp(name, "cpu1_path")){
|
|
free(cfg.cpu3.path);
|
|
cfg.cpu3.path = malloc(sizeof(value) + 1);
|
|
strcpy(cfg.cpu3.path, value);
|
|
}
|
|
|
|
if (!strcmp(name, "cpu1_path")){
|
|
free(cfg.cpu4.path);
|
|
cfg.cpu4.path = malloc(sizeof(value) + 1);
|
|
strcpy(cfg.cpu4.path, value);
|
|
}
|
|
|
|
if (!strcmp(name, "gpu_path")){
|
|
free(cfg.gpu.path);
|
|
cfg.gpu.path = malloc(sizeof(value) + 1);
|
|
strcpy(cfg.gpu.path, value);
|
|
}
|
|
|
|
if (!strcmp(name, "cpu1_critical"))
|
|
cfg.cpu1.critical = atoi(value);
|
|
if (!strcmp(name, "cpu2_critical"))
|
|
cfg.cpu2.critical = atoi(value);
|
|
if (!strcmp(name, "cpu3_critical"))
|
|
cfg.cpu3.critical = atoi(value);
|
|
if (!strcmp(name, "cpu4_critical"))
|
|
cfg.cpu4.critical = atoi(value);
|
|
if (!strcmp(name, "gpu_critical"))
|
|
cfg.gpu.critical = atoi(value);
|
|
|
|
if (!strcmp(name, "cpu1_warning"))
|
|
cfg.cpu1.warning = atoi(value);
|
|
if (!strcmp(name, "cpu2_warning"))
|
|
cfg.cpu2.warning = atoi(value);
|
|
if (!strcmp(name, "cpu3_warning"))
|
|
cfg.cpu3.warning = atoi(value);
|
|
if (!strcmp(name, "cpu4_warning"))
|
|
cfg.cpu4.warning = atoi(value);
|
|
if (!strcmp(name, "gpu_warning"))
|
|
cfg.gpu.warning = atoi(value);
|
|
}
|
|
|
|
*conf = cfg;
|
|
fclose (fp);
|
|
free(conf_file);
|
|
}
|
|
|
|
short get_offset(short temp, struct entry *etr){
|
|
if(temp >= etr->critical){
|
|
return 7; // Alert
|
|
}else if(temp >= etr->warning){
|
|
return 14; // Warning
|
|
}else{
|
|
return 0; // Normal
|
|
}
|
|
}
|
|
|
|
void display_values(int temp, short offset, short core2_offset){
|
|
char text[5], num1, num2, num3, num4;
|
|
|
|
sprintf(text, "%03d", temp);
|
|
num1 = (text[0] - '0');
|
|
num2 = (text[1] - '0');
|
|
num3 = (text[2] - '0');
|
|
num4 = (text[3] - '0');
|
|
if(num1)
|
|
copyXPMArea(5 * num1, 65 + core2_offset, 5, 7, 31, 7 + offset);
|
|
else
|
|
copyXPMArea(60, 65 + core2_offset, 5, 7, 31, 7 + offset);
|
|
copyXPMArea(5 * num2, 65 + core2_offset, 5, 7, 38, 7 + offset);
|
|
copyXPMArea(5 * num3, 65 + core2_offset, 5, 7, 45, 7 + offset);
|
|
copyXPMArea(5 * num4, 65 + core2_offset, 5, 7, 51, 7 + offset);
|
|
}
|
|
|
|
int get_temp(struct entry *etr){
|
|
int core_temp = 0;
|
|
read_file_into(etr->path, &core_temp);
|
|
return core_temp;
|
|
}
|
|
|
|
void read_file_into(char *filepath, int *output) {
|
|
// Read an integer from the provided filepath and write it in the address
|
|
FILE *fp;
|
|
if((fp = fopen(filepath, "r")) != NULL){
|
|
if(fscanf(fp, "%d", output) != EOF){
|
|
*output = *output / 1000;
|
|
fclose(fp);
|
|
}
|
|
}else{
|
|
*output = 0;
|
|
}
|
|
}
|
|
|
|
void draw_cpu_temp(short core_no, core *cpu) {
|
|
// Copy prepared bitmap for the core. Cores are enumerated from 0. offset
|
|
// is warning/critical (orange/red) shift in the bitmap
|
|
|
|
short y_offset = core_no * 9;
|
|
|
|
copyXPMArea(0, 87 + cpu->offset, 23, 7, 4, 7 + y_offset); // "CPU"
|
|
// number of cpu
|
|
copyXPMArea(5 + core_no * 5, 65 + cpu->offset, 5, 7, 22, 7 + y_offset);
|
|
copyXPMArea(66, 65 + cpu->offset, 9, 7, 51, 7 + y_offset); // "°C"
|
|
display_values(cpu->temp, y_offset, cpu->offset); // temp
|
|
}
|
|
|
|
void draw_gpu_temp(core *gpu) {
|
|
copyXPMArea(23, 87 + gpu->offset, 23, 7, 4, 49);
|
|
copyXPMArea(66, 65 + gpu->offset , 9, 7, 51, 49);
|
|
display_values(gpu->temp, 42, gpu->offset);
|
|
}
|
|
|
|
void display_help(char *progname){
|
|
printf("Dockapp for monitoring CPU and Nvidia GPU temperatures.\n");
|
|
printf("Usage:\n\t%s [full path for temp in sysfs]\n\n", progname);
|
|
printf("As an optional parameter you can provide `temp_input' ");
|
|
printf("full path from sysfs,\ncorresponding to your gfx card ");
|
|
printf("to read temperature from. Otherwise\nfunctionality of ");
|
|
printf("nv-control will be used (package nvidia-settings).\n");
|
|
}
|