snow/dockapps
1
0
Fork 0
Code Issues Releases Activity
dockapps/wmapm/wmapm/wmapm.c
Doug Torrance 0075abd36f Remove trailing whitespace.
2018-01-08 16:08:44 -02:00

1000 lines
24 KiB
C
Raw Blame History

/*
* wmapm-3.1
*
* A WindowMaker dockable application that allows laptop users
* to graphically monitor the status of their power source.
* (I.e. whether or not AC or battery is in use as well as
* how long it will take to drain or charge the battery.)
*
* Originally written (and copyrighted under GPL) by
* Chris D. Faulhaber <jedgar@fxp.org>. Version 3.0
* is an extensively modified version of version 2.0
* by Michael G. Henderson <mghenderson@lanl.gov>.
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program (see the file COPYING); if not, write to the
* Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* Portions of code derived from:
* apm/apmd/libapm : (c) 1996 Rickard E. Faith (r.faith@ieee.org)
* wmmon : (c) 1998 Martijn Pieterse (pieterse@xs4all.nl) and
* Antoine Nulle (warp@xs4all.nl)
*
* Thanx to Timecop <timecop@linuxwarez.com> for pointing out/helping to
* Toggle fix the meter mismatch.
*
*/
/*
* Changes:
*
* 3.1 -Released: June 1, 1999.
* + Added support for time left on FreeBSD 3.x/4.x
* (Chris D. Faulhaber <jedgar@fxp.org>)
*
*
* 3.01 -Released: January 3, 1999.
*
* + Added a LowColor Pixmap for the poor saps using 8-bit displays
* on laptops. There are a *lot* of laptops out there that are only
* 8-bit. Use the "-l" command-line option to invoke.
*
*
* 3.0 -Released: December 15, 1998.
* A Major overhaul performed. Changes include;
*
* + Added buttons to place laptop into "Suspend" (button labeled `Z')
* or "Standby" (button labeled `S') mode. Buttons are separated
* by status LEDs to minimize accidentally clicking on the wrong
* one. I used `Z' for suspend because its like the laptop is
* catching some Zs (i.e. going to sleep).
*
* + Replaced the 3 rectangular red/yellow/green status indicators
* with 3 small round LEDs and moved them to a viewport at the
* bottom between the two buttons. This array of LEDs could in future
* be moved to a single LED in the main viewport to make room for
* other things at this location (perhaps more buttons if apm supports
* more things like truning off LCD, etc).
*
* + Created user-definable LowLevel and CriticalLevel thresholds. Yellow LED
* comes on when Battery Percentage hits the LowLevel threshold. Red comes on
* when you reach CriticalLevel threshold.
*
* + Made red status LED blink for extra noticability. User can define blink rate.
* A BlinkRate of 0 turns off blinking.
*
* + Moved all of the other indicators into a single viewport above the
* buttons and status LEDs.
*
* + Changed the red-dark-green colorbar to a banded blue LED bar that is tipped
* with a color indicating capacity level. The tip color goes through
* green-yellow-orange-red. A series of single-pixel dots is always present
* below the bar to indicate its range. This is needed now, because
* the bar is free-floating in the viewport. The single-pixel dots can be
* seen easily on an LCD - the type of monitor wmapm is likely to be used.
*
* + Changed the `CHARGING' indicator with a single red `C' indicator at the
* upper left of the APP.
*
* + Changed percentage indicator so that it can display 100%. (Used to only go
* up to 99% max).
*
* + Changed time indicator to have a +/- sign depending on whether you are
* charging up or draining down. (+ means you have that much battery life
* left before its discharged. - means you have that much time to wait until
* the battery is fully charged.)
*
* + Fixed a problem with very large "TimeLeft" values. If the time is greater
* than the maximum time displayable 99 hours and 59 minutes, a ---:-- is
* listed instead. Since the time is based on measured charge/discharge rates,
* when the battery is doing neither, the time is essentially infinite. On my
* (M Henderson's) laptop, the time left indicated 32766 when this happened.
* FreeBSD systems should also show a ---:-- indicator. Dont have FreeBSD though
* so I couldnt test it....
*
* + Changed Makefile to suid the apm program. This is needed to allow users to
* invoke the standby and suspend capabilities in apm.
*
* + Sped up the loop to catch button press and expose events. But the querying of
* /proc/apm is still done about once a second...
*
* + Added alert feature. User can use command line option -A <T1 T2> to turn on alerts
* via wall. T1 and T2 are the time in seconds between updates for Low and Critical
* status. By default the alerts are turned off.
*
* + Various sundry code cleanups.
*
*
* 2.0 - Added FreeBSD support.
*
* 1.3 - Fixed an annoying little problem with the the meter
* not properly lowering as the battery is depleted.
* Also did some code cleanup, enhanced the Makefile which
* now includes 'make install'.
* Released 980826
*
* 1.2 - Fixed bug that showed 100% battery capacity
* as 90% (I never noticed since my battery seems
* to max out at 98%).
* Thanx to Brice Ruth <bruth@ltic.com> for pointing out/helping fix the
* 100% bug (err...feature).
* Released 980731
*
* 1.1 - Removed libapm dependency; tweaked some code.
* Released 980729
*
* 1.0 - Initial release version.
* Released 980725
*
*/
#ifdef SunOS
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/battery.h>
#endif
#ifdef FreeBSD
#include <err.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <machine/apm_bios.h>
#endif
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <X11/X.h>
#include <X11/xpm.h>
#include "wmapm.h"
#include <libdockapp/wmgeneral.h>
#include "wmapm_master.xpm"
#include "wmapm_master_LowColor.xpm"
#include "wmapm_mask.xbm"
#ifdef Linux
int apm_read(struct my_apm_info *i);
#else
# ifdef FreeBSD
int apm_read(apm_info_t temp_info);
# endif
#endif
int apm_exists();
void ParseCMDLine(int argc, char *argv[]);
void pressEvent(XButtonEvent *xev);
int CriticalLevel = 10;
int LowLevel = 40;
float BlinkRate = 3.0; /* blinks per second */
float UpdateRate = 0.8; /* Number of updates per second */
int Beep = 0; /* Controls beeping when you get to CriticalLevel: Off by default */
int Volume = 50; /* ring bell at 50% volume */
int Alert = 0; /* Controls whether alert is sent to all users via wall: Off by default */
int UseLowColorPixmap = 0; /* Use a lower number of colors for the poor saps on 8-bit displays -- common
on laptops! */
float LAlertRate = 300.0; /* send alert every 5 minutes when Low */
float CAlertRate = 120.0; /* send alert every 2 minutes when Critical */
/*
* main
*/
int main(int argc, char *argv[]) {
struct my_apm_info my_cur_info;
int time_left,
hour_left,
min_left,
digit;
#ifdef FreeBSD
struct apm_info temp_info;
#endif
XEvent event;
int m, mMax, n, nMax, k, Toggle;
long int r, rMax, s, sMax;
FILE *fp;
BlinkRate = 3.0;
UpdateRate = 1.0/1.25;
/*
* Parse any command line arguments.
*/
ParseCMDLine(argc, argv);
BlinkRate = (BlinkRate >= 0.0) ? BlinkRate : -1.0*BlinkRate;
UpdateRate = (UpdateRate >= 0.0) ? UpdateRate : -1.0*UpdateRate;
nMax = (int)( 1.0e6/(2.0*UpdateRate*DELAY) );
mMax = (BlinkRate > 0.0) ? (int)( 1.0e6/(2.0*BlinkRate*DELAY) ) : nMax;
rMax = (int)( LAlertRate*1.0e6/(2.0*DELAY) );
sMax = (int)( CAlertRate*1.0e6/(2.0*DELAY) );
/*
* Check for APM support
*/
if (!apm_exists()) {
#ifdef Linux
fprintf(stderr, "No APM support in kernel\n");
#else
fprintf(stderr, "Unable to access APM info\n");
#endif
exit(1);
}
if (UseLowColorPixmap)
openXwindow(argc, argv, wmapm_master_LowColor, wmapm_mask_bits, wmapm_mask_width, wmapm_mask_height);
else
openXwindow(argc, argv, wmapm_master, wmapm_mask_bits, wmapm_mask_width, wmapm_mask_height);
/*
* Loop until we die...
*/
n = 32000;
m = 32000;
r = rMax+1;
s = sMax+1;
while(1) {
/*
* Only process apm info only every nMax cycles of this
* loop. We run it faster to catch the xevents like button
* presses and expose events, etc...
*
* DELAY is set at 0.00625 seconds, so process apm info
* every 1.25 seconds...
*
*/
if (n>nMax){
n = 0;
#if defined(Linux) || defined(SunOS)
if (apm_read(&my_cur_info)) {
#else
# ifdef FreeBSD
if (apm_read(&temp_info)) {
# endif
#endif
fprintf(stderr, "Cannot read APM information: %i\n");
exit(1);
}
#ifdef FreeBSD /* Convert status's */
my_cur_info.ac_line_status = (int)temp_info.ai_acline;
my_cur_info.battery_status = (int)temp_info.ai_batt_stat;
my_cur_info.battery_percentage = (int)temp_info.ai_batt_life;
my_cur_info.battery_time = (int)temp_info.ai_batt_time;
#endif
/*
* Check AC status.
*/
switch (my_cur_info.ac_line_status) {
case 1:
/*
* AC on-line. I.e. we are "plugged-in".
*/
copyXPMArea(68, 6, 26, 7, 31, 35);
break;
default:
/*
* AC off-line. I.e. we are using battery.
*/
copyXPMArea(68, 20, 26, 7, 31, 35);
}
/*
* Paste up the default charge status and time
*/
copyXPMArea(104, 6, 5, 7, 6, 7);
copyXPMArea(83, 93, 41, 9, 15, 7);
/*
* Check to see if we are charging.
*/
if ( (int)(my_cur_info.battery_status) == 3){
/*
* Battery Status: Charging.
*/
copyXPMArea(98, 6, 5, 7, 6, 7);
copyXPMArea(75, 81, 1, 2, 17, 9);
copyXPMArea(75, 81, 1, 2, 17, 12);
}
/*
* Repaint buttons.
*/
copyXPMArea(42, 106, 13, 11, 5, 48);
copyXPMArea(57, 106, 13, 11, 46, 48);
/*
* Paste up the "Time Left". This time means:
*
* If not charging: Time left before battery drains to 0%
* If charging: Time left before battery gets to maximum
*
*/
#ifdef Linux
if (my_cur_info.battery_time >= ((my_cur_info.using_minutes) ? 1440 : 86400) ) {
#else
# ifdef FreeBSD
if (my_cur_info.battery_time >= 86400) {
# endif
#endif
/*
* If battery_time is too large, it likely means that there is
* no charging or discharging going on. So just display a "null"
* indicator (--:--).
*
*/
copyXPMArea(83, 106, 41, 9, 15, 7);
} else if (my_cur_info.battery_time >= 0) {
#ifdef Linux
time_left = (my_cur_info.using_minutes) ? my_cur_info.battery_time : my_cur_info.battery_time / 60;
#endif
#ifdef FreeBSD
time_left = (my_cur_info.using_minutes) ? my_cur_info.battery_time / 60 : my_cur_info.battery_time / 3600;
#endif
hour_left = time_left / 60;
min_left = time_left % 60;
copyXPMArea( (hour_left / 10) * 7 + 5, 93, 7, 9, 21, 7); /* Show 10's (hour) */
copyXPMArea((hour_left % 10) * 7 + 5, 93, 7, 9, 29, 7); /* Show 1's (hour) */
copyXPMArea(76, 93, 2, 9, 38, 7); /* colon */
copyXPMArea((min_left / 10) * 7 + 5, 93, 7, 9, 42, 7); /* Show 10's (min) */
copyXPMArea((min_left % 10) * 7 + 5, 93, 7, 9, 50, 7); /* Show 1's (min) */
}
/*
* Do Battery Percentage.
*/
copyXPMArea(76, 81, 19, 7, 7, 34); /* Show Default % */
copyXPMArea(66, 31, 49, 9, 7, 21); /* Show Default Meter */
if (my_cur_info.battery_percentage == 100){
copyXPMArea(15, 81, 1, 7, 7, 34); /* If 100%, show 100% */
copyXPMArea( 5, 81, 6, 7, 9, 34);
copyXPMArea( 5, 81, 6, 7, 15, 34);
copyXPMArea(64, 81, 7, 7, 21, 34); /* Show '%' */
copyXPMArea(66, 42, 49, 9, 7, 21); /* Show Meter */
} else {
if (my_cur_info.battery_percentage >= 10)
copyXPMArea((my_cur_info.battery_percentage / 10) * 6 + 4, 81, 6, 7, 9, 34); /* Show 10's */
copyXPMArea((my_cur_info.battery_percentage % 10) * 6 + 4, 81, 6, 7, 15, 34); /* Show 1's */
copyXPMArea(64, 81, 7, 7, 21, 34); /* Show '%' */
/*
* Show Meter
*/
k = my_cur_info.battery_percentage * 49 / 100;
copyXPMArea(66, 42, k, 9, 7, 21);
if (k%2)
copyXPMArea(66+k-1, 52, 1, 9, 7+k-1, 21);
else
copyXPMArea(66+k, 52, 1, 9, 7+k, 21);
}
} else {
/*
* Update the counter. When it hits nMax, we will
* process /proc/apm information again.
*/
++n;
}
/*
* This controls the 3 LEDs
*/
if (m>mMax){
m = 0;
if (( (int)(my_cur_info.battery_status) == 2)
||( (int)(my_cur_info.battery_percentage) <= CriticalLevel )){
/*
* Battery Status: Critical.
* Blink the red led on/off...
*/
if (Toggle||(BlinkRate == 0.0)){
if (Beep) XBell(display, Volume);
Toggle = 0;
copyXPMArea(95, 68, 4, 4, 24, 51);
} else{
Toggle = 1;
copyXPMArea(75, 68, 4, 4, 24, 51);
}
copyXPMArea(81, 68, 4, 4, 30, 51); /* turn off yellow */
copyXPMArea(87, 68, 4, 4, 36, 51); /* turn off green */
} else if (( (int)(my_cur_info.battery_status) == 1)
||( (int)(my_cur_info.battery_percentage) <= LowLevel )){
/*
* Battery Status: Low.
*/
copyXPMArea(75, 68, 4, 4, 24, 51); /* turn off red */
copyXPMArea(101, 68, 4, 4, 30, 51); /* turn ON yellow */
copyXPMArea(87, 68, 4, 4, 36, 51); /* turn off green */
} else if (( (int)( my_cur_info.battery_status ) == 0)
||( (int)(my_cur_info.battery_percentage) > LowLevel )){
/*
* Battery Status: High.
*/
copyXPMArea(75, 68, 4, 4, 24, 51); /* turn off red */
copyXPMArea(81, 68, 4, 4, 30, 51); /* turn off yellow */
copyXPMArea(107, 68, 4, 4, 36, 51); /* turn ON green */
}
} else {
/*
* Update the counter.
*/
++m;
}
/*
* This controls Critical Alerts
*/
if (Alert){
if (( (int)(my_cur_info.battery_status) == 2)
||( (int)(my_cur_info.battery_percentage) <= CriticalLevel )){
if (s>sMax){
s = 0;
fp = popen("wall", "w");
fprintf(fp, "Battery is critical!. Percent: %d\n", (int)(my_cur_info.battery_percentage));
pclose(fp);
} else {
/*
* Update the counter.
*/
++s;
}
} else if (( (int)(my_cur_info.battery_status) == 1)
||( (int)(my_cur_info.battery_percentage) <= LowLevel )){
if (r>rMax){
r = 0;
fp = popen("wall", "w");
fprintf(fp, "Battery is low. Percent: %d\n", (int)(my_cur_info.battery_percentage));
pclose(fp);
} else {
/*
* Update the counter.
*/
++r;
}
}
}
/*
* Process any pending X events.
*/
while(XPending(display)){
XNextEvent(display, &event);
switch(event.type){
case Expose:
RedrawWindow();
break;
case ButtonPress:
pressEvent(&event.xbutton);
break;
case ButtonRelease:
break;
}
}
/*
* Redraw and wait for next update
*/
RedrawWindow();
usleep(DELAY);
}
}
/*
* This routine handles button presses. Pressing the 'S' button
* invokes 'apm -S' to place the machine into standby mode. And
* pressing the 'Z' buton invokes 'apm -s' to place the machine
* into suspend mode.
*
* Note: in order for users other than root to be able to run
* 'apm -s' and 'apm -S', you need to make apm suid (i.e.
* run 'chmod +s /usr/bin/apm' as root). This will allow
* 'normal' users to execute apm with root privilages.
*
*/
void pressEvent(XButtonEvent *xev){
int x=xev->x;
int y=xev->y;
if(x>=5 && y>=48 && x<=17 && y<=58){
/*
* Standby Call.
*
* Draw button as 'pushed'. Redraw window to show it.
* Call 'apm -S' to standby. Sleep for 2 seconds so that
* the button doesnt immediately redraw back to unpressed
* before the 'apm -S' takes effect.
*/
copyXPMArea(5, 106, 13, 11, 5, 48);
RedrawWindow();
#ifndef SunOS
system("apm -S");
#endif
usleep(2000000L);
} else if (x>=46 && y>=48 && x<=58 && y<=58){
/*
* Suspend Call.
*
* Draw button as 'pushed'. Redraw window to show it.
* Call 'apm -s' to suspend. Sleep for 2 seconds so that
* the button doesnt immediately redraw back to unpressed
* before the 'apm -s' takes effect.
*/
copyXPMArea(21, 106, 13, 11, 46, 48);
RedrawWindow();
#ifndef SunOS
system("apm -s");
#endif
usleep(2000000L);
}
return;
}
/*
* apm_exists()
* - Check to see if /proc/apm exists...
*
*/
int apm_exists()
{
if (access(APMDEV, R_OK))
/*
* Cannot find /proc/apm
*/
return 0;
else
return 1;
}
/*
* apm_read()
* - Read in the information found in /proc/apm...
*
*/
#ifdef Linux
int apm_read(struct my_apm_info *i){
FILE *str;
char units[10];
char buffer[100];
int retcode = 0;
/*
* Open /proc/apm for reading
*/
if (!(str = fopen(APMDEV, "r")))
return 1;
/*
* Scan in the information....
*/
fgets(buffer, sizeof(buffer) - 1, str);
buffer[sizeof(buffer) - 1] = '\0';
sscanf(buffer, "%s %d.%d %x %x %x %x %d%% %d %s\n",
(char *)i->driver_version,
&i->apm_version_major,
&i->apm_version_minor,
&i->apm_flags,
&i->ac_line_status,
&i->battery_status,
&i->battery_flags,
&i->battery_percentage,
&i->battery_time,
units);
i->using_minutes = !strncmp(units, "min", 3) ? 1 : 0;
/*
* Old Style
*/
if (i->driver_version[0] == 'B') {
strcpy((char *)i->driver_version, "pre-0.7");
i->apm_version_major = 0;
i->apm_version_minor = 0;
i->apm_flags = 0;
i->ac_line_status = 0xff;
i->battery_status = 0xff;
i->battery_flags = 0xff;
i->battery_percentage = -1;
i->battery_time = -1;
i->using_minutes = 1;
sscanf(buffer, "BIOS version: %d.%d", &i->apm_version_major, &i->apm_version_minor);
fgets(buffer, sizeof(buffer) - 1, str);
sscanf(buffer, "Flags: 0x%02x", &i->apm_flags);
if (i->apm_flags & APM_32_BIT_SUPPORT) {
fgets(buffer, sizeof(buffer) - 1, str);
fgets(buffer, sizeof(buffer) - 1, str);
if (buffer[0] != 'P') {
if (!strncmp(buffer+4, "off line", 8)) i->ac_line_status = 0;
else if (!strncmp(buffer+4, "on line", 7)) i->ac_line_status = 1;
else if (!strncmp(buffer+4, "on back", 7)) i->ac_line_status = 2;
fgets(buffer, sizeof(buffer) - 1, str);
if (!strncmp(buffer+16, "high", 4)) i->battery_status = 0;
else if (!strncmp(buffer+16, "low", 3)) i->battery_status = 1;
else if (!strncmp(buffer+16, "crit", 4)) i->battery_status = 2;
else if (!strncmp(buffer+16, "charg", 5)) i->battery_status = 3;
fgets(buffer, sizeof(buffer) - 1, str);
if (strncmp(buffer+14, "unknown", 7)) i->battery_percentage = atoi(buffer + 14);
if (i->apm_version_major >= 1 && i->apm_version_minor >= 1) {
fgets(buffer, sizeof(buffer) - 1, str);
sscanf(buffer, "Battery flag: 0x%02x", &i->battery_flags);
fgets(buffer, sizeof(buffer) - 1, str);
if (strncmp(buffer+14, "unknown", 7)) i->battery_time = atoi(buffer + 14);
}
}
}
}
/*
* Take care of battery percentages > 100%
*/
if (i->battery_percentage > 100) i->battery_percentage = -1;
fclose(str);
return retcode;
}
#else
# ifdef FreeBSD
int apm_read(apm_info_t temp_info) {
int fd;
if ( (fd = open(APMDEV, O_RDWR)) < 0){
return(1);
} else if ( ioctl(fd, APMIO_GETINFO, temp_info) == -1 ) {
close(fd);
return(1);
} else {
close(fd);
return(0);
}
}
# endif
#endif
#ifdef SunOS
int apm_read(struct my_apm_info *i) {
int fd;
battery_t info;
memset(i,0,sizeof(*i));
if ((fd = open(APMDEV,O_RDONLY)) < 0) {
perror("open");
exit(1);
}
if (ioctl(fd,BATT_STATUS,&info) < 0) return(1);
close(fd);
i->battery_percentage = info.capacity;
i->battery_time = info.discharge_time;
i->using_minutes = 0;
/* convert to internal status:
*
* 0 = high
* 1 = low
* 2 = critical
* 3 = charging
*/
switch(info.status) {
case EMPTY: /* Battery has (effectively) no capacity */
i->battery_status = 2;
break;
case LOW_CAPACITY: /* Battery has less than 25% capacity */
i->battery_status = 1;
break;
case MED_CAPACITY: /* Battery has less than 50% capacity */
i->battery_status = 1;
break;
case HIGH_CAPACITY: /* Battery has less than 75% capacity */
case FULL_CAPACITY: /* Battery has more than 75% capacity */
i->battery_status = 0;
break;
default:
i->battery_status = 2;
break;
}
switch(info.charge) {
case DISCHARGE: /* Battery is discharging (i.e. in use) */
i->ac_line_status = 0;
break;
case FULL_CHARGE: /* Battery is charging at its fastest rate */
case TRICKLE_CHARGE: /* Battery is charging at a slower rate */
default:
i->ac_line_status = 1;
break;
}
if (i->battery_percentage > 100) i->battery_percentage = 100;
/* Not sure what else we can fill in right now.
* Relevant information is:
*
* info.id_string = type of battery (internal, external, etc)
* info.total = total capacity (mWhrs)
*/
return(0);
}
#endif
/*
* ParseCMDLine()
*/
void ParseCMDLine(int argc, char *argv[]) {
char *cmdline;
int i,j;
char puke[20];
for (i = 1; i < argc; i++) {
cmdline = argv[i];
if (cmdline[0] == '-') {
switch(cmdline[1]) {
case 'd':
++i;
break;
case 'A':
Alert = 1;
LAlertRate = atof(argv[++i]);
CAlertRate = atof(argv[++i]);
break;
case 'b':
BlinkRate = atof(argv[++i]);
break;
case 'C':
CriticalLevel = atoi(argv[++i]);
break;
case 'L':
LowLevel = atoi(argv[++i]);
break;
case 'l':
UseLowColorPixmap = 1;
break;
case 'B':
Beep = 1;
Volume = atoi(argv[++i]);
break;
default:
printf("\nwmapm version: %s\n", WMAPM_VERSION);
printf("usage:\n");
printf("\t-display <display>\tUse alternate display.\n");
printf("\t-l\t\t\tUse a low-color pixmap to conserve colors on 8-bit displays.\n");
printf("\t-L <LowLevel>\t\tDefine level at which yellow LED turns on.\n");
printf("\t \t\tCriticalLevel takes precedence if LowLevel<CriticalLevel.\n");
printf("\t-C <CriticalLevel>\tDefine level at which red LED turns on.\n");
printf("\t-b <BlinkRate>\t\tBlink rate for red LED. (0 for no blinking.)\n");
printf("\t-B <Volume>\t\tBeep at Critical Level. Volume is between -100%% to 100%%.\n");
printf("\t-A <T1 T2>\t\tSend messages to users terminals when Low and critical.\n");
printf("\t \t\tT1 is seconds between messages when Low. T2 is seconds between messages when Critical.\n");
printf("\t-h\t\t\tDisplay help screen.\n\n");
exit(1);
}
}
}
}
Reference in a new issue View git blame Copy permalink