kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkgsrc/sysutils/xenvstat/files/xenvstat.c
xtraeme 4b1aad95d6 Initial import of xenvstart-20041127 from pkgsrc-wip, packaged/coded by 
Rui-Xiang Guo <rxg@NetBSD.org>.

xenvstat displays sensor readings from any device which supports the
envsys(4) API in X11-based GUI.
2004-12-28 00:01:07 +00:00

839 lines
22 KiB
C
Raw Blame History

/*
* This code is derived from xmbmon.c written by Yoshifumi R. Shimizu.
*
* Copyright (c) 2004 Rui-Xiang Guo
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <err.h>
#include <sys/envsys.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
/* Fahrenheit flag used in get_values() */
int fahrn_flag = 0;
/* Label for showing or not showing a label */
char *label;
#define RES_NAME "xenvstat"
#define DEFAULT_GEOMETRY "141x126"
#define DEFAULT_FONT "-adobe-helvetica-bold-r-*-*-10-*-*-*-*-*-*-*"
#define DEFAULT_LBFONT "-adobe-helvetica-bold-r-*-*-12-*-*-*-*-*-*-*"
#define DEFAULT_LBCOLOR "black"
#define DEFAULT_COUNT "4"
#define DEFAULT_SEC "2"
#define DEFAULT_WSEC "180"
#define DEFAULT_TMIN "20.0"
#define DEFAULT_TMAX "60.0"
#define DEFAULT_TMINF "50.0" /* for Fahrenheit */
#define DEFAULT_TMAXF "130.0" /* for Fahrenheit */
#define DEFAULT_VMIN "1.80"
#define DEFAULT_VMAX "2.20"
#define DEFAULT_TICK "3"
#define DEFAULT_CLTCPU "red"
#define DEFAULT_CLTMB "blue"
#define DEFAULT_CLTCS "cyan"
#define DEFAULT_CLFAN1 "gray"
#define DEFAULT_CLFAN2 "pink"
#define DEFAULT_CLVC "green"
#define DEFAULT_CMTCPU "CPU"
#define DEFAULT_CMTMB "MB"
#define DEFAULT_CMTCS "chip"
#define DEFAULT_CMFAN1 "fan1"
#define DEFAULT_CMFAN2 "fan2"
#define DEFAULT_CMVC "Vc "
#define DEFAULT_FAHRN "False"
/* global variables */
/* temp1(CPU), temp2(MotherBoard), temp3(ChipSet), fan1, fan2, Vcore0 */
#define NUM_DATA 6
int nd = NUM_DATA;
char *font;
int width, height;
int count, sec, wsec;
int counter = 0;
int npoints = 0;
int range;
unsigned long ms;
float *fmean;
float tmin, tmax, vmin, vmax;
int tick;
float sscl, htck;
float cur_val[NUM_DATA] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
char *l_color[NUM_DATA];
unsigned long cpix[NUM_DATA], d_cpix[NUM_DATA];
#define C_LBL 10
char ctmin[C_LBL], ctmax[C_LBL];
char cvmin[C_LBL], cvmax[C_LBL];
char *c_rdv[NUM_DATA], *c_rdg[NUM_DATA];
char *c_rdp[NUM_DATA] = {"%4.1f", "%4.1f", "%4.1f", "%4.0f", "%4.0f", "%4.2f"};
char *lb_font, *lb_color;
int h_lb = 0;
float scale[NUM_DATA];
float orign[NUM_DATA];
int x_rdg[NUM_DATA], x_rdv[NUM_DATA], y_rdg, y_rdv;
int cg_width[NUM_DATA], cv_width[NUM_DATA];
int h_cm, x_cm, y_cm;
unsigned long cpixlb, d_cpixlb;
typedef struct ring_data { /* def. of ring-buffer */
float val;
struct ring_data *next;
} ring_d;
ring_d *rdp[NUM_DATA];
ring_d *rdpw[NUM_DATA];
int fd, ns;
envsys_tre_data_t *etds;
/* variables for X11 */
Widget wgt;
Display *disp;
Window win;
GC gct, gclb, gcl[NUM_DATA];
XPoint *points;
XFontStruct *fontstr;
XFontStruct *lb_fontstr;
/* functions */
void usage(void);
void get_res(void);
void init_dt(void);
void getWH(int *width, int *height);
void repaint_proc(void);
void quit_proc(void);
void draw_values(void);
int ColorPix(Display *, char *, unsigned long *);
void alarm_handler(void);
int num_sensors(void);
int fill_sensors(void);
void get_values(void);
void calc_position(void);
void calc_scale(void);
/*---------- definitions of static data for X Toolkits ----------*/
static String fallback_resources[] = {
"*translations: #override \
<Configure>: repaint_proc()\\n\
<Expose>: repaint_proc()\\n\
<BtnUp>: repaint_proc()\\n\
<Key>Q: quit_proc()",
"*geometry: " DEFAULT_GEOMETRY,
"*font: " DEFAULT_FONT,
"*count: " DEFAULT_COUNT,
"*sec: " DEFAULT_SEC,
"*wsec: " DEFAULT_WSEC,
"*tmin: " DEFAULT_TMIN,
"*tmax: " DEFAULT_TMAX,
"*vmin: " DEFAULT_VMIN,
"*vmax: " DEFAULT_VMAX,
"*tick: " DEFAULT_TICK,
"*cltcpu: " DEFAULT_CLTCPU,
"*cltmb: " DEFAULT_CLTMB,
"*cltcs: " DEFAULT_CLTCS,
"*clfan1: " DEFAULT_CLFAN1,
"*clfan2: " DEFAULT_CLFAN2,
"*clvc: " DEFAULT_CLVC,
"*cmtcpu: " DEFAULT_CMTCPU,
"*cmtmb: " DEFAULT_CMTMB,
"*cmtcs: " DEFAULT_CMTCS,
"*cmfan1: " DEFAULT_CMFAN1,
"*cmfan2: " DEFAULT_CMFAN2,
"*cmvc: " DEFAULT_CMVC,
"*fahrn: " DEFAULT_FAHRN,
"*label: " ,
"*labelfont: " DEFAULT_LBFONT,
"*labelcolor: " DEFAULT_LBCOLOR,
NULL,
};
static XtActionsRec actions[] = {
{"repaint_proc", (XtActionProc) repaint_proc},
{"quit_proc", (XtActionProc) quit_proc},
};
static struct _app_res {
char *font;
int count;
int sec;
int wsec;
float tmin;
float tmax;
float vmin;
float vmax;
int tick;
char *cltcpu;
char *cltmb;
char *cltcs;
char *clfan1;
char *clfan2;
char *clvc;
char *cmtcpu;
char *cmtmb;
char *cmtcs;
char *cmfan1;
char *cmfan2;
char *cmvc;
Boolean fahrn;
char *label;
char *labelfont;
char *labelcolor;
} app_resources;
static XtResource resources[] = {
{"font", "Font", XtRString, sizeof(String),
XtOffset(struct _app_res*, font),
XtRString, (XtPointer) NULL},
{"count", "Count", XtRInt, sizeof(int),
XtOffset(struct _app_res*, count),
XtRImmediate, (XtPointer) NULL},
{"sec", "Sec", XtRInt, sizeof(int),
XtOffset(struct _app_res*, sec),
XtRImmediate, (XtPointer) NULL},
{"wsec", "wSec", XtRInt, sizeof(int),
XtOffset(struct _app_res*, wsec),
XtRImmediate, (XtPointer) NULL},
{"tmin", "Tmin", XtRFloat, sizeof(float),
XtOffset(struct _app_res*, tmin),
XtRImmediate, (XtPointer) NULL},
{"tmax", "Tmax", XtRFloat, sizeof(float),
XtOffset(struct _app_res*, tmax),
XtRImmediate, (XtPointer) NULL},
{"vmin", "Vmin", XtRFloat, sizeof(float),
XtOffset(struct _app_res*, vmin),
XtRImmediate, (XtPointer) NULL},
{"vmax", "Vmax", XtRFloat, sizeof(float),
XtOffset(struct _app_res*, vmax),
XtRImmediate, (XtPointer) NULL},
{"tick", "Tick", XtRInt, sizeof(int),
XtOffset(struct _app_res*, tick),
XtRImmediate, (XtPointer) NULL},
{"cltcpu", "CLTcpu", XtRString, sizeof(String),
XtOffset(struct _app_res*, cltcpu),
XtRString, (XtPointer) NULL},
{"cltmb", "CLTmb", XtRString, sizeof(String),
XtOffset(struct _app_res*, cltmb),
XtRString, (XtPointer) NULL},
{"cltcs", "CLTcs", XtRString, sizeof(String),
XtOffset(struct _app_res*, cltcs),
XtRString, (XtPointer) NULL},
{"clfan1", "CLFan1", XtRString, sizeof(String),
XtOffset(struct _app_res*, clfan1),
XtRString, (XtPointer) NULL},
{"clfan2", "CLFan2", XtRString, sizeof(String),
XtOffset(struct _app_res*, clfan2),
XtRString, (XtPointer) NULL},
{"clvc", "CLVc", XtRString, sizeof(String),
XtOffset(struct _app_res*, clvc),
XtRString, (XtPointer) NULL},
{"cmtcpu", "CMTcpu", XtRString, sizeof(String),
XtOffset(struct _app_res*, cmtcpu),
XtRString, (XtPointer) NULL},
{"cmtmb", "CMTmb", XtRString, sizeof(String),
XtOffset(struct _app_res*, cmtmb),
XtRString, (XtPointer) NULL},
{"cmtcs", "CMTcs", XtRString, sizeof(String),
XtOffset(struct _app_res*, cmtcs),
XtRString, (XtPointer) NULL},
{"cmfan1", "CMFan1", XtRString, sizeof(String),
XtOffset(struct _app_res*, cmfan1),
XtRString, (XtPointer) NULL},
{"cmfan2", "CMFan2", XtRString, sizeof(String),
XtOffset(struct _app_res*, cmfan2),
XtRString, (XtPointer) NULL},
{"cmvc", "CMVc", XtRString, sizeof(String),
XtOffset(struct _app_res*, cmvc),
XtRString, (XtPointer) NULL},
{"fahrn","Fahrn",XtRBoolean,sizeof(Boolean),
XtOffset(struct _app_res*, fahrn),
XtRImmediate, (XtPointer) NULL},
{"label","Label",XtRString,sizeof(String),
XtOffset(struct _app_res*, label),
XtRString,(XtPointer) NULL},
{"labelfont","LabelFont",XtRString,sizeof(String),
XtOffset(struct _app_res*, labelfont),
XtRString,(XtPointer) NULL},
{"labelcolor","LabelColor",XtRString,sizeof(String),
XtOffset(struct _app_res*, labelcolor),
XtRString,(XtPointer) NULL},
};
static XrmOptionDescRec options[] = {
{"-font", ".font", XrmoptionSepArg, NULL},
{"-count", ".count", XrmoptionSepArg, NULL},
{"-sec", ".sec", XrmoptionSepArg, NULL},
{"-wsec", ".wsec", XrmoptionSepArg, NULL},
{"-tmin", ".tmin", XrmoptionSepArg, NULL},
{"-tmax", ".tmax", XrmoptionSepArg, NULL},
{"-vmin", ".vmin", XrmoptionSepArg, NULL},
{"-vmax", ".vmax", XrmoptionSepArg, NULL},
{"-tick", ".tick", XrmoptionSepArg, NULL},
{"-cltcpu", ".cltcpu", XrmoptionSepArg, NULL},
{"-cltmb", ".cltmb", XrmoptionSepArg, NULL},
{"-cltcs", ".cltcs", XrmoptionSepArg, NULL},
{"-clfan1", ".clfan1", XrmoptionSepArg, NULL},
{"-clfan2", ".clfan2", XrmoptionSepArg, NULL},
{"-clvc", ".clvc", XrmoptionSepArg, NULL},
{"-cmtcpu", ".cmtcpu", XrmoptionSepArg, NULL},
{"-cmtmb", ".cmtmb", XrmoptionSepArg, NULL},
{"-cmtcs", ".cmtcs", XrmoptionSepArg, NULL},
{"-cmfan1", ".cmfan1", XrmoptionSepArg, NULL},
{"-cmfan2", ".cmfan2", XrmoptionSepArg, NULL},
{"-cmvc", ".cmvc", XrmoptionSepArg, NULL},
{"-fahrn",".fahrn",XrmoptionSepArg,NULL},
{"-label",".label",XrmoptionSepArg,NULL},
{"-labelfont",".labelfont",XrmoptionSepArg,NULL},
{"-labelcolor",".labelcolor",XrmoptionSepArg,NULL},
};
/*---------- end of static data for X Toolkits ----------*/
void usage(void)
{
fprintf(stderr,
""RES_NAME" options:\n"
" -g ("DEFAULT_GEOMETRY") <geometry(Toolkit option)>\n"
" -count ("DEFAULT_COUNT") <counts in an interval>\n"
" -sec ("DEFAULT_SEC") <seconds of an interval>\n"
" -wsec ("DEFAULT_WSEC") <total seconds shown>\n"
" -tmin ("DEFAULT_TMIN") <min. temperature>\n"
" -tmax ("DEFAULT_TMAX") <max. temperature>\n"
" -vmin ("DEFAULT_VMIN") <min. voltage>\n"
" -vmax ("DEFAULT_VMAX") <max. voltage>\n"
" -tick ("DEFAULT_TICK") <ticks in ordinate>\n"
" -cltcpu ("DEFAULT_CLTCPU") <color of Temp1>\n"
" -cltmb ("DEFAULT_CLTMB") <color of Temp2>\n"
" -cltcs ("DEFAULT_CLTCS") <color of Temp3>\n"
" -clfan1 ("DEFAULT_CLFAN1") <color of Fan1>\n"
" -clfan2 ("DEFAULT_CLFAN2") <color of Fan2>\n"
" -clvc ("DEFAULT_CLVC") <color of Vcore>\n"
" -cmtcpu ("DEFAULT_CMTCPU") <comment of Temp1>\n"
" -cmtmb ("DEFAULT_CMTMB") <comment of Temp2>\n"
" -cmtcs ("DEFAULT_CMTCS") <comment of Temp3>\n"
" -cmfan1 ("DEFAULT_CMFAN1") <comment of Fan1>\n"
" -cmfan2 ("DEFAULT_CMFAN2") <comment of Fan2>\n"
" -cmvc ("DEFAULT_CMVC") <comment of Vcore>\n"
" -fahrn ("DEFAULT_FAHRN") <temp. in Fahrenheit (True|False)>\n"
" -label ( ) <for showing label and -labelfont, -labelcolor>\n");
exit(1);
}
/* Xt Application Context, global */
XtAppContext app_con;
int main(int argc, char *argv[])
{
int i;
const char *dev = "/dev/sysmon";
for (i = 1; i < argc; i++)
if (0 == strcmp("-h", argv[i]) || 0 == strcmp("-help", argv[i]))
usage();
if ((fd = open(dev, O_RDONLY)) == -1)
err(1, "unable to open %s", dev);
if ((ns = num_sensors()) <= 0)
errx(1, "cannot determine number of sensors");
etds = (envsys_tre_data_t *)malloc(ns * sizeof(envsys_tre_data_t));
if (etds == NULL)
errx(1, "cannot allocate memory");
wgt = XtVaAppInitialize(&app_con, RES_NAME, options, XtNumber(options),
&argc, argv, fallback_resources, NULL);
XtVaGetApplicationResources(wgt, (caddr_t) &app_resources,
resources, XtNumber(resources), NULL);
XtAppAddActions(app_con, actions, XtNumber(actions));
XtRealizeWidget(wgt);
get_res();
init_dt();
XtAppAddTimeOut(app_con, ms, (XtTimerCallbackProc) alarm_handler, NULL);
XtAppMainLoop(app_con);
return (0);
}
void get_res()
{
font = app_resources.font;
if (font == NULL)
font = DEFAULT_FONT;
count = app_resources.count;
if (count <= 0)
count = atoi(DEFAULT_COUNT);
sec = app_resources.sec;
if (sec <= 0)
sec = atoi(DEFAULT_SEC);
wsec = app_resources.wsec;
if (wsec <= 0)
wsec = atoi(DEFAULT_WSEC);
tmin = app_resources.tmin;
if (tmin <= 0.0)
tmin = (float) atof(DEFAULT_TMIN);
tmax = app_resources.tmax;
if (tmax <= 0.0)
tmax = (float) atof(DEFAULT_TMAX);
vmin = app_resources.vmin;
if (vmin <= 0.0)
vmin = (float) atof(DEFAULT_VMIN);
vmax = app_resources.vmax;
if (vmax <= 0.0)
vmax = (float) atof(DEFAULT_VMAX);
tick = app_resources.tick;
if (tick <= 0)
tick = atoi(DEFAULT_TICK);
l_color[0] = app_resources.cltcpu;
if (l_color[0] == NULL)
l_color[0] = DEFAULT_CLTCPU;
l_color[1] = app_resources.cltmb;
if (l_color[1] == NULL)
l_color[1] = DEFAULT_CLTMB;
l_color[2] = app_resources.cltcs;
if (l_color[2] == NULL)
l_color[2] = DEFAULT_CLTCS;
l_color[3] = app_resources.clfan1;
if (l_color[3] == NULL)
l_color[3] = DEFAULT_CLFAN1;
l_color[4] = app_resources.clfan2;
if (l_color[4] == NULL)
l_color[4] = DEFAULT_CLFAN2;
l_color[5] = app_resources.clvc;
if (l_color[5] == NULL)
l_color[5] = DEFAULT_CLVC;
c_rdg[0] = app_resources.cmtcpu;
if (c_rdg[0] == NULL)
c_rdg[0] = DEFAULT_CMTCPU;
c_rdg[1] = app_resources.cmtmb;
if (c_rdg[1] == NULL)
c_rdg[1] = DEFAULT_CMTMB;
c_rdg[2] = app_resources.cmtcs;
if (c_rdg[2] == NULL)
c_rdg[2] = DEFAULT_CMTCS;
c_rdg[3] = app_resources.cmfan1;
if (c_rdg[3] == NULL)
c_rdg[3] = DEFAULT_CMFAN1;
c_rdg[4] = app_resources.cmfan2;
if (c_rdg[4] == NULL)
c_rdg[4] = DEFAULT_CMFAN2;
c_rdg[5] = app_resources.cmvc;
if (c_rdg[5] == NULL)
c_rdg[5] = DEFAULT_CMVC;
if (app_resources.fahrn) {
fahrn_flag = 1;
if (tmin == (float) atof(DEFAULT_TMIN) &&
tmax == (float) atof(DEFAULT_TMAX)) {
tmin = (float) atof(DEFAULT_TMINF);
tmax = (float) atof(DEFAULT_TMAXF);
}
}
label = app_resources.label;
lb_font = app_resources.labelfont;
lb_color = app_resources.labelcolor;
if (lb_color == NULL)
lb_color = DEFAULT_LBCOLOR;
}
void quit_proc(void)
{
exit(1);
}
void repaint_proc(void)
{
int wwd, hht;
int i, n;
ring_d *p;
getWH(&wwd, &hht);
if (wwd != width) {
width = wwd;
x_cm = width - XTextWidth(fontstr, cvmin, strlen(cvmin)) - 1;
sscl = (float) width / (float) range;
calc_position();
}
if (hht != height) {
height = hht;
calc_scale();
}
XClearWindow(disp, win);
if(*label != NULL)
XDrawString(disp, win, gclb, 2, h_lb - 2, label, strlen(label));
for (i = 0; i < nd; i++) {
XDrawString(disp, win, gcl[i], x_rdg[i], y_rdg,
c_rdg[i], strlen(c_rdg[i]));
XDrawString(disp, win, gcl[i], x_rdv[i], y_rdv,
c_rdv[i], strlen(c_rdv[i]));
}
XDrawString(disp, win, gct, 0, height, ctmin, strlen(ctmin));
XDrawString(disp, win, gct, 0, y_cm, ctmax, strlen(ctmax));
XDrawString(disp, win, gct, x_cm, height, cvmin, strlen(cvmin));
XDrawString(disp, win, gct, x_cm, y_cm, cvmax, strlen(cvmax));
for (i = 1; i <= tick + 1; i++) {
n = height - (int) ((float) i * htck + 0.5);
XDrawLine(disp, win, gct, 0, n, width, n);
}
for (i = nd - 1; i >= 0; i--) {
for (n = 0, p = rdp[i]; n < npoints; n++) {
(points + n)->x = (short) ((float) n * sscl + 0.5);
(points + n)->y = height -
(short) ((p->val - orign[i]) * scale[i] + 0.5);
p = p->next;
}
if (scale[i])
XDrawLines(disp, win, gcl[i], points, npoints,
CoordModeOrigin);
}
XFlush(disp);
}
void getWH(int *width, int *height)
{
Dimension wd, ht;
XtVaGetValues(wgt, XtNwidth, &wd, XtNheight, &ht, NULL);
*width = (int) wd;
*height = (int) ht;
}
int ColorPix(Display *display, char *color, unsigned long *cpix)
{
Colormap cmap;
XColor c0, c1;
if (color == NULL)
return (1);
cmap = DefaultColormap(display, 0);
if (XAllocNamedColor(disp, cmap, color, &c1, &c0)) {
*cpix = c1.pixel;
return (0);
} else
return (1);
}
void init_dt(void)
{
ring_d *p;
int n, i;
if (wsec < 10 * sec)
errx(1, "wsec(%d) is too small w.r.t sec(%d)!", wsec, sec);
if (tmax < tmin)
errx(1, "tmin(%f) > tmax(%f), not allowed!", tmin, tmax);
if (vmax < vmin)
errx(1, "vmin(%f) > vmax(%f), not allowed!", vmin, vmax);
if (fill_sensors() == -1)
errx(1, "cannot enumerate sensors");
get_values();
disp = XtDisplay(wgt);
win = XtWindow(wgt);
if ((fontstr = XLoadQueryFont(disp, font)) == NULL)
errx(1, "Can't find font: %s\n", font);
ColorPix(disp, DEFAULT_CLTCPU, &(d_cpix[0]));
ColorPix(disp, DEFAULT_CLTMB, &(d_cpix[1]));
ColorPix(disp, DEFAULT_CLTCS, &(d_cpix[2]));
ColorPix(disp, DEFAULT_CLFAN1, &(d_cpix[3]));
ColorPix(disp, DEFAULT_CLFAN2, &(d_cpix[4]));
ColorPix(disp, DEFAULT_CLVC, &(d_cpix[5]));
gct = XCreateGC(disp, win, 0, 0);
XSetFont(disp, gct, fontstr->fid);
for (i = 0; i < nd; i++) {
if (ColorPix(disp, l_color[i], &(cpix[i])))
cpix[i] = d_cpix[i];
gcl[i] = XCreateGC(disp, win, 0, 0);
XSetLineAttributes(disp, gcl[i], 2, LineSolid, CapRound,
JoinRound);
XSetForeground(disp, gcl[i], cpix[i]);
XSetFont(disp, gcl[i], fontstr->fid);
c_rdv[i] = (char *) malloc(C_LBL);
sprintf(c_rdv[i], c_rdp[i], cur_val[i]);
cg_width[i] = XTextWidth(fontstr, c_rdg[i], strlen(c_rdg[i]));
cv_width[i] = XTextWidth(fontstr, c_rdv[i], strlen(c_rdv[i]));
}
if(*label != NULL) {
if ((lb_fontstr = XLoadQueryFont(disp, lb_font)) == NULL)
errx(1, "Can't find font for label: %s\n", font);
ColorPix(disp, DEFAULT_LBCOLOR, &d_cpixlb);
if (ColorPix(disp, lb_color, &cpixlb))
cpixlb = d_cpixlb;
gclb = XCreateGC(disp, win, 0, 0);
XSetFont(disp, gclb, lb_fontstr->fid);
XSetForeground(disp, gclb, cpixlb);
}
sprintf(ctmin, "%2.0f", tmin);
sprintf(ctmax, "%2.0f", tmax);
sprintf(cvmin, "%3.1f", vmin);
sprintf(cvmax, "%3.1f", vmax);
range = wsec / sec;
points = (XPoint *) malloc(sizeof(short) * 2 * (range + 1));
for (i = 0; i < nd; i++) {
rdp[i] = p = (ring_d *) malloc(sizeof(ring_d));
rdpw[i] = p;
for (n = 1; n < (range + 1); n++) {
p->next = (ring_d *) malloc(sizeof(ring_d));
p = p->next;
}
p->next = rdp[i];
}
fmean = (float *) malloc(sizeof(float) * nd * count);
getWH(&width, &height);
sscl = (float) width / (float) range;
orign[0] = tmin;
orign[1] = tmin;
orign[2] = tmin;
orign[5] = vmin;
x_rdg[0] = 0;
x_rdv[0] = 0;
calc_position();
y_rdg = fontstr->max_bounds.ascent - 1;
y_rdv = 2 * y_rdg;
if(*label != NULL) {
h_lb = lb_fontstr->max_bounds.ascent + 1;
y_rdg += h_lb;
y_rdv += h_lb;
}
h_cm = 2 * fontstr->max_bounds.ascent;
y_cm = h_cm + y_rdg;
x_cm = width - XTextWidth(fontstr, cvmin, strlen(cvmin));
calc_scale();
ms = 1000 * sec / count;
}
void alarm_handler(void)
{
float d, *p;
int i, n;
get_values();
if (fill_sensors() == -1)
errx(1, "cannot enumerate sensors");
if (cur_val[0] >= tmax)
XBell(XtDisplay(wgt), 0);
draw_values();
p = fmean + counter;
for (i = 0; i < nd; i++)
*(p + i * count) = cur_val[i];
counter++;
if (counter == count) {
if (npoints <= range)
npoints++;
else
for (i = 0; i < nd; i++)
rdp[i] = rdp[i]->next;
counter = 0;
p = fmean;
for (i = 0; i < nd; i++) {
for (n = 0, d = 0.0; n < count; n++, p++)
d += *p;
rdpw[i]->val = d / (float) count;
rdpw[i] = rdpw[i]->next;
}
repaint_proc();
}
XtAppAddTimeOut(app_con, ms, (XtTimerCallbackProc) alarm_handler, NULL);
}
void draw_values(void)
{
int i;
XClearArea(disp, win, 0, y_rdg , 0, y_rdg - h_lb, False);
for (i = 0; i < nd; i++) {
sprintf(c_rdv[i], c_rdp[i], cur_val[i]);
XDrawString(disp, win, gcl[i], x_rdv[i], y_rdv,
c_rdv[i], strlen(c_rdv[i]));
}
XFlush(disp);
}
void calc_position(void)
{
int i, cg_r, cv_r;
cg_r = width - (cg_width[0] + cg_width[nd - 1]) / 2;
cv_r = width - (cv_width[0] + cv_width[nd - 1]) / 2;
for (i = 1; i <= nd - 1; i++) {
x_rdg[i] =
cg_width[0] / 2 + cg_r * i / (nd - 1) - cg_width[i] / 2;
x_rdv[i] =
cv_width[0] / 2 + cv_r * i / (nd - 1) - cv_width[i] / 2;
}
}
void calc_scale(void)
{
float tscl, vscl;
tscl = (float) (height - h_lb - h_cm) / (tmax - tmin);
vscl = (float) (height - h_lb - h_cm) / (vmax - vmin);
htck = (float) (height - h_lb - h_cm) / (float) (tick + 1);
scale[0] = tscl;
scale[1] = tscl;
scale[2] = tscl;
scale[3] = 0;
scale[4] = 0;
scale[5] = vscl;
}
int num_sensors(void)
{
int num = 0, valid = 1;
envsys_tre_data_t etd;
etd.sensor = 0;
while (valid) {
if (ioctl(fd, ENVSYS_GTREDATA, &etd) == -1)
errx(1, "cannot enumerate sensors");
valid = etd.validflags & ENVSYS_FVALID;
if (valid)
++num;
++etd.sensor;
}
return (num);
}
int fill_sensors(void)
{
int i;
for (i = 0; i < ns; ++i) {
etds[i].sensor = i;
if (ioctl(fd, ENVSYS_GTREDATA, &etds[i]) == -1)
return (-1);
}
return (0);
}
void get_values(void)
{
int i, j = 0, k = 0, l = 0;
for (i = 0; i < ns; ++i) {
if ((etds[i].validflags & ENVSYS_FCURVALID) == 0)
continue;
switch (etds[i].units) {
case ENVSYS_STEMP:
cur_val[j] = (etds[i].cur.data_us / 1000000.0) - 273.15;
if (fahrn_flag)
cur_val[j] = (9.0 / 5.0) * cur_val[j] + 32.0;
++j;
break;
case ENVSYS_SFANRPM:
if (k < 2)
cur_val[k + 3] = etds[i].cur.data_us;
++k;
break;
default:
if (l < 1)
cur_val[5] = etds[i].cur.data_s / 1000000.0;
++l;
break;
}
}
}
Reference in a new issue View git blame Copy permalink