path: root/utils/wattsup/src/wattsup.c

/*
 *	wattsup - Program for controlling the Watts Up? Pro Device
 *
 *
 *	Copyright (c) 2005 Patrick Mochel
 *
 *	This program is released under the GPLv2
 *
 *
 *	Compiled with:
 *
 *	gcc -O2 -Wall -o wattsup wattsup.c
 *
 */

#define _GNU_SOURCE
#include<stdio.h>
#include<stdlib.h>
#include<stdarg.h>
#include<string.h>
#include<errno.h>
#include<unistd.h>
#include<fcntl.h>
#include<termios.h>
#include<ctype.h>
#include<getopt.h>
#include<signal.h>
#include<time.h>

#include<sys/stat.h>

static const char * wu_version = "0.02";


#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))

static const char * prog_name = "wattsup";

static const char * sysfs_path_start = "/sys/class/tty";

static char * wu_device = "ttyUSB0";
static int wu_fd = 0;
static int wu_count = 0;
static int wu_debug = 0;
static char *wu_delim = ", ";
static int wu_final = 0;
static int wu_interval = 1;
static int wu_label = 0;
static int wu_newline = 0;
static int wu_suppress = 0;

static int wu_localtime = 0;
static int wu_gmtime = 0;

static int wu_info_all = 0;
static int wu_no_data = 0;
static int wu_set_only = 0;

#define wu_strlen	256
#define wu_num_fields	18
#define wu_param_len	16

struct wu_packet {
	unsigned int	cmd;
	unsigned int	sub_cmd;
	unsigned int	count;
	char	buf[wu_strlen];
	int	len;
	char	* field[wu_num_fields];
	char	* label[wu_num_fields];
};


struct wu_data {
	unsigned int	watts;
	unsigned int	volts;
	unsigned int	amps;
	unsigned int	watt_hours;

	unsigned int	cost;
	unsigned int	mo_kWh;
	unsigned int	mo_cost;
	unsigned int	max_watts;

	unsigned int	max_volts;
	unsigned int	max_amps;
	unsigned int	min_watts;
	unsigned int	min_volts;

	unsigned int	min_amps;
	unsigned int	power_factor;
	unsigned int	duty_cycle;
	unsigned int	power_cycle;
};

struct wu_options {
	char	* longopt;
	int	shortopt;
	int	param;
	int	flag;
	char	* value;

	char	* descr;
	char	* option;
	char	* format;

	int	(*show)(int dev_fd);
	int	(*store)(int dev_fd);
};

enum {
	wu_option_help = 0,
	wu_option_version,

	wu_option_debug,

	wu_option_count,
	wu_option_final,

	wu_option_delim,
	wu_option_newline,
	wu_option_localtime,
	wu_option_gmtime,
	wu_option_label,

	wu_option_suppress,

	wu_option_cal,
	wu_option_header,

	wu_option_interval,
	wu_option_mode,
	wu_option_user,

	wu_option_info_all,
	wu_option_no_data,
	wu_option_set_only,
};


static char * wu_option_value(unsigned int index);


enum {
	wu_field_watts		= 0,
	wu_field_volts,
	wu_field_amps,

	wu_field_watt_hours,
	wu_field_cost,
	wu_field_mo_kwh,
	wu_field_mo_cost,

	wu_field_max_watts,
	wu_field_max_volts,
	wu_field_max_amps,

	wu_field_min_watts,
	wu_field_min_volts,
	wu_field_min_amps,

	wu_field_power_factor,
	wu_field_duty_cycle,
	wu_field_power_cycle,
};

struct wu_field {
	unsigned int	enable;
	char		* name;
	char		* descr;
};

static struct wu_field wu_fields[wu_num_fields] = {
	[wu_field_watts]	= {
		.name	= "watts",
		.descr	= "Watt Consumption",
	},

	[wu_field_min_watts]	= {
		.name	= "min-watts",
		.descr	= "Minimum Watts Consumed",
	},

	[wu_field_max_watts]	= {
		.name	= "max-watts",
		.descr	= "Maxium Watts Consumed",
	},

	[wu_field_volts]	= {
		.name	= "volts",
		.descr	= "Volts Consumption",
	},

	[wu_field_min_volts]	= {
		.name	= "max-volts",
		.descr	= "Minimum Volts Consumed",
	},

	[wu_field_max_volts]	= {
		.name	= "min-volts",
		.descr	= "Maximum Volts Consumed",
	},

	[wu_field_amps]		= {
		.name	= "amps",
		.descr	= "Amp Consumption",
	},

	[wu_field_min_amps]	= {
		.name	= "min-amps",
		.descr	= "Minimum Amps Consumed",
	},

	[wu_field_max_amps]	= {
		.name	= "max-amps",
		.descr	= "Maximum Amps Consumed",
	},

	[wu_field_watt_hours]	= {
		.name	= "kwh",
		.descr	= "Average KWH",
	},

	[wu_field_mo_kwh]	= {
		.name	= "mo-kwh",
		.descr	= "Average monthly KWH",
	},

	[wu_field_cost]		= {
		.name	= "cost",
		.descr	= "Cost per watt",
	},

	[wu_field_mo_cost]	= {
		.name	= "mo-cost",
		.descr	= "Monthly Cost",
	},

	[wu_field_power_factor]	= {
		.name	= "power-factor",
		.descr	= "Ratio of Watts vs. Volt Amps",
	},

	[wu_field_duty_cycle]	= {
		.name	= "duty-cycle",
		.descr	= "Percent of the Time On vs. Time Off",
	},

	[wu_field_power_cycle]	= {
		.name	= "power-cycle",
		.descr	= "Indication of power cycle",
	},

};



static void msg_start(const char * fmt, ...)
{
	va_list(ap);
	va_start(ap, fmt);
	vprintf(fmt, ap);
	va_end(ap);
}

static void msg_end(void)
{
	printf("\n");
}

static void msg(const char * fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vprintf(fmt, ap);
	va_end(ap);
}

static void dbg(const char * fmt, ...)
{
	va_list ap;

	if (wu_debug) {
		va_start(ap, fmt);
		msg_start("%s: [debug] ", prog_name);
		vprintf(fmt, ap);
		msg_end();
		va_end(ap);
	}
}

static void err(const char * fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	fprintf(stderr, "%s: [error] ", prog_name);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);
}

static void perr(const char * fmt, ...)
{
	char buf[1024];
	int n;
	va_list ap;

	va_start(ap, fmt);
	n = sprintf(buf, "%s: [error] ", prog_name);
	vsnprintf(buf + n, sizeof(buf) - n, fmt, ap);
	perror(buf);
	va_end(ap);
}

static int ret_err(int err)
{
	errno = err;
	return -1;
}


static void print_packet(struct wu_packet * p, char * str)
{
	int i;

	if (!wu_suppress)
		msg_start("Watts Up? %s\n", str);
	for (i = 0; i<  p->count; i++) {
		if (i)
			msg("%s", wu_newline ? "\n" : wu_delim);
		if (wu_label)
			msg("[%s] ", p->label[i]);
		msg(p->field[i]);
	}
	msg_end();
}


static void print_time(void)
{
	time_t t;
	struct tm * tm;

	if (wu_localtime || wu_gmtime) {
		time(&t);

		if (wu_localtime)
			tm = localtime(&t);
		else
			tm = gmtime(&t);

		msg("[%02d:%02d:%02d] ",
		    tm->tm_hour, tm->tm_min, tm->tm_sec);
	}
}

static void print_packet_filter(struct wu_packet * p,
				int (*filter_ok)(struct wu_packet * p, int i, char * str))
{
	char buf[256];
	int printed;
	int i;

	print_time();
	for (i = 0, printed = 0; i<  p->count; i++) {
		if (!filter_ok(p, i, buf))
			continue;

		if (printed++)
			msg("%s", wu_newline ? "\n" : wu_delim);
		if (wu_label)
			msg("[%s] ", p->label[i]);
		msg(buf);
	}
	msg_end();
}


/*
 * Device should be something like "ttyS0"
 */

static int open_device(char * device_name, int * dev_fd)
{
	struct stat s;
	int ret;
	int cur_fd;

	cur_fd = open(".", O_RDONLY);
	if (cur_fd<  0) {
		perr("Could not open current directory.");
		return cur_fd;
	}

	ret = chdir(sysfs_path_start);
	if (ret) {
		perr(sysfs_path_start);
		return ret;
	}

	/*
	 * First, check if /sys/class/tty/<name>/ exists.
	 */

	dbg("Checking sysfs path: %s/%s", sysfs_path_start, device_name);

	ret = stat(device_name,&s);
	if (ret<  0) {
		perr(device_name);
		goto Done;
	}

	if (!S_ISDIR(s.st_mode)) {
		errno = -ENOTDIR;
		err("%s is not a TTY device.", device_name);
		goto Done;
	}

	dbg("%s is a registered TTY device", device_name);

	fchdir(cur_fd);


	/*
	 * Check if device node exists and is writable
	 */
	chdir("/dev");

	ret = stat(device_name,&s);
	if (ret<  0) {
		perr("/dev/%s (device node)", device_name);
		goto Done;
	}

	if (!S_ISCHR(s.st_mode)) {
		errno = -ENOTTY;
		ret = -1;
		err("%s is not a TTY character device.", device_name);
		goto Done;
	}

	dbg("%s has a device node", device_name);

	ret = access(device_name, R_OK | W_OK);
	if (ret) {
		perr("%s: Not writable?", device_name);
		goto Done;
	}

	ret = open(device_name, O_RDWR | O_NONBLOCK);
	if (ret<  0) {
		perr("Could not open %s");
		goto Done;
	}
	*dev_fd = ret;
	ret = 0;
Done:
	fchdir(cur_fd);
	close(cur_fd);
	return ret;
}


static int setup_serial_device(int dev_fd)
{
	struct termios t;
	int ret;

	ret = tcgetattr(dev_fd,&t);
	if (ret)
		return ret;

	cfmakeraw(&t);
	cfsetispeed(&t, B115200);
	cfsetospeed(&t, B115200);
	tcflush(dev_fd, TCIFLUSH);

	t.c_iflag |= IGNPAR;
	t.c_cflag&= ~CSTOPB;
	ret = tcsetattr(dev_fd, TCSANOW,&t);

	if (ret) {
		perr("setting terminal attributes");
		return ret;
	}

	return 0;
}


static int wu_write(int fd, struct wu_packet * p)
{
	int ret;
	int n;
	int i;
	char * s = p->buf;

	memset(p->buf, 0, sizeof(p->buf));
	n = sprintf(p->buf, "#%c,%c,%d", p->cmd, p->sub_cmd, p->count);
	p->len = n;
	s = p->buf + n;

	for (i = 0; i<  p->count; i++) {
		if ((p->len + strlen(p->field[i]) + 4)>= sizeof(p->buf)) {
			err("Overflowed command string");
			return ret_err(EOVERFLOW);
		}
		n = sprintf(s, ",%s", p->field[i]);
		s += n;
		p->len += n;
	}
	p->buf[p->len++] = ';';

	dbg("Writing '%s' (strlen = %d) (len = %d) to device",
	    p->buf, strlen(p->buf), p->len);
	ret = write(fd, p->buf, p->len);
	if (ret != p->len)
		perr("Writing to device");
	
	return ret>= 0 ? 0 : ret;
}


static void dump_packet(struct wu_packet * p)
{
	int i;

	dbg("Packet - Command '%c' %d parameters", p->cmd, p->count);
	
	for (i = 0; i<  p->count; i++)
		dbg("[%2d] [%20s] = \"%s\"", i, p->label[i], p->field[i]);
}


static int parse_packet(struct wu_packet * p)
{
	char * s, *next;
	int i;

	p->buf[p->len] = '\0';

	dbg("Parsing Packet, Raw buffer is (%d bytes) [%s]",
	    p->len, p->buf);

	s = p->buf;

	/*
	 * First character should be '#'
	 */
	if (s) {
		s = strchr(s, '#');
		if (s)
			s++;
		else {
			dbg("Invalid packet");
			return ret_err(EFAULT);
		}
	} else {
		dbg("Invalid packet");
		return ret_err(EFAULT);
	}

	/*
	 * Command character is first
	 */
	next = strchr(s, ',');
	if (next) {
		p->cmd = *s;
		s = ++next;
	} else {
		dbg("Invalid Command field [%s]", s);
		return ret_err(EFAULT);
	}

	/*
	 * Next character is the subcommand, and should be '-'
	 * Though, it doesn't matter, because we just
	 * discard it anyway.
	 */
	next = strchr(s, ',');
	if (next) {
		p->sub_cmd = *s;
		s = ++next;
	} else {
		dbg("Invalid 2nd field");
		return ret_err(EFAULT);
	}

	/*
	 * Next is the number of parameters,
	 * which should always be>  0.
	 */
	next = strchr(s, ',');
	if (next) {
		*next++ = '\0';
		p->count = atoi(s);
		s = next;
	} else {
		dbg("Couldn't determine number of parameters");
		return ret_err(EFAULT);
	}
	
	dbg("Have %d parameter%s (cmd = '%c')",
	    p->count, p->count>  1 ? "s" : "", p->cmd);

	/*
	 * Now, we loop over the rest of the string,
	 * storing a pointer to each in p->field[].
	 *
	 * The last character was originally a ';', but may have been
	 * overwritten with a '\0', so we make sure to catch
	 * that when converting the last parameter.
	 */
	for (i = 0; i<  p->count; i++) {
		next = strpbrk(s, ",;");
		if (next) {
			*next++ = '\0';
		} else {
			if (i<  (p->count - 1)) {
				dbg("Malformed parameter string [%s]", s);
				return ret_err(EFAULT);
			}
		}

		/*
		 * Skip leading white space in fields
		 */
		while (isspace(*s))
			s++;
		p->field[i] = s;
		s = next;
	}
	dump_packet(p);
	return 0;
}


static int wu_read(int fd, struct wu_packet * p)
{
	fd_set read_fd;
	struct timeval tv;
	int ret;

	FD_ZERO(&read_fd);
	FD_SET(fd,&read_fd);
	
	tv.tv_sec = 2;
	tv.tv_usec = 0;

	ret = select(fd + 1,&read_fd, NULL, NULL,&tv);
	if (ret<  0) {
		perr("select on terminal device");
		return ret;
	} else if (ret>  0) {

		ret = read(fd, p->buf, wu_strlen);
		if (ret<  0) {
			perr("Reading from device");
			return ret;
		}
		p->len = ret;
	} else {
		dbg("Device timed out while reading");
		return ret_err(ETIME);
	}
	return parse_packet(p);
}


static int wu_show_header(int fd)
{
	struct wu_packet p = {
		.cmd		= 'H',
		.sub_cmd	= 'R',
		.count		= 0,
		.label = {
			[0] = "watts header",
			[1] = "volts header",
			[2] = "amps header",
			[3] = "kWh header",
			[4] = "cost header",
			[5] = "mo. kWh header",
			[6] = "mo. cost header",
			[7] = "max watts header",
			[8] = "max volts header",
			[9] = "max amps header",
			[10] = "min watts header",
			[11] = "min volts header",
			[12] = "min amps header",
			[13] = "power factor header",
			[14] = "duty cycle header",
			[15] = "power cycle header",
		}
	};
	int ret;

	ret = wu_write(fd,&p);
	if (ret) {
		perr("Requesting header strings");
		return ret;
	}
	sleep(1);

	ret = wu_read(fd,&p);
	if (ret) {
		perr("Reading header strings");
		return ret;
	}

	print_packet(&p, "Header Record");

	return 0;
}


static int wu_show_cal(int fd)
{
	struct wu_packet p = {
		.cmd		= 'F',
		.sub_cmd	= 'R',
		.count		= 0,
		.label = {
			[0] = "flags",
			[1] = "sample count",
			[2] = "volts gain",
			[3] = "volts bias",
			[4] = "amps gain",
			[5] = "amps bias",
			[6] = "amps offset",
			[7] = "low amps gain",
			[8] = "low amps bias",
			[9] = "low amps offset",
			[10] = "watts gain",
			[11] = "watts offset",
			[12] = "low watts gain",
			[13] = "low watts offset",
		},
	};
	int ret;

	ret = wu_write(fd,&p);
	if (ret) {
		perr("Requesting calibration parameters");
		return ret;
	}
	sleep(1);

	ret = wu_read(fd,&p);
	if (ret) {
		perr("Reading header strings");
		return ret;
	}
	print_packet(&p, "Calibration Settings");

	return 0;
}

static int wu_start_log(void)
{
	struct wu_packet p = {
		.cmd		= 'L',
		.sub_cmd	= 'W',
		.count		= 3,
		.field		= {
			[0] = "E",
			[1] = "1",
			[2] = "1",
		},
	};
	int ret;

	/*
	 * Start up logging
	 */
	ret = wu_write(wu_fd,&p);
	if (!ret)
		sleep(1);
	else {
		perr("Starting External Logging");
		return ret;
	}
	return ret;
}

static int wu_stop_log(void)
{
	struct wu_packet p = {
		.cmd		= 'L',
		.sub_cmd	= 'R',
		.count		= 0,
		.label = {
			[0] = "time stamp",
			[1] = "interval",
		},
	};
	int ret;

	/*
	 * Stop logging and read time stamp.
	 */
	ret = wu_write(wu_fd,&p);
	if (ret) {
		perr("Stopping External Logging");
		return ret;
	}
	sleep(1);

	ret = wu_read(wu_fd,&p);
	if (ret) {
		perr("Reading final time stamp");
		return ret;
	}
	if (wu_final)
		print_packet(&p, "Final Time Stamp and Interval");
	return ret;
}

static int filter_data(struct wu_packet * p, int i, char * buf)
{
	if (i<  wu_num_fields) {
		if (wu_fields[i].enable) {
			double val = strtod(p->field[i], NULL);
			snprintf(buf, 256, "%.1f", val / 10.0);
			return 1;
		}
	}
	return 0;
}

static int wu_clear(int fd)
{
	struct wu_packet p = {
		.cmd		= 'R',
		.sub_cmd	= 'W',
		.count		= 0,
	};
	int ret;

	/*
	 * Clear the memory
	 */
	ret = wu_write(fd,&p);
	if (ret)
		perr("Clearing memory");
	else
		sleep(2);
	
	/*
	 * Dummy read
	 */
	wu_read(fd,&p);
	return ret;

}

static int wu_read_data(int fd)
{
	struct wu_packet p = {
		.label = {
			[0] = "watts",
			[1] = "volts",
			[2] = "amps",
			[3] = "watt hours",
			[4] = "cost",
			[5] = "mo. kWh",
			[6] = "mo. cost",
			[7] = "max watts",
			[8] = "max volts",
			[9] = "max amps",
			[10] = "min watts",
			[11] = "min volts",
			[12] = "min amps",
			[13] = "power factor",
			[14] = "duty cycle",
			[15] = "power cycle",
		},
	};
	int num_read = 0;
	int retry = 0;
	int ret;
	int i;

	static const int wu_max_retry = 2;

	i = 0;
	while (1) {
		
		ret = wu_read(fd,&p);
		if (ret) {
			if (++retry<  wu_max_retry) {
				dbg("Bad record back, retrying\n");
				sleep(wu_interval);
				continue;
			} else if (retry == wu_max_retry) {
				dbg("Still couldn't get a good record, resetting\n");
				wu_stop_log();
				wu_clear(fd);
				wu_start_log();
				num_read = 0;
				sleep(wu_interval);
				continue;
			}
			perr("Blech. Giving up on read");
			break;
		} else if (retry)
			retry = 0;

		dbg("[%d] ", num_read);
		num_read++;
		print_packet_filter(&p, filter_data);

		if (wu_count&&  (++i == wu_count))
			break;
		
		sleep(wu_interval);
	}
	return 0;

}


static int wu_show_interval(int fd)
{
	struct wu_packet p = {
		.cmd		= 'S',
		.sub_cmd	= 'R',
		.count		= 0,
		.label = {
			[0] = "reserved",
			[1] = "interval",
		},
	};
	int ret;
	
	ret = wu_write(fd,&p);
	if (ret) {
		perr("Requesting interval");
		return ret;
	}
	sleep(1);

	ret = wu_read(fd,&p);
	if (ret) {
		perr("Reading interval");
		return ret;
	}
	print_packet(&p, "Interval Settings");

	return 0;
}

static int wu_write_interval(int fd, unsigned int seconds,
			     unsigned int interval)
{
	char str_seconds[wu_param_len];
	char str_interval[wu_param_len];
	struct wu_packet p = {
		.cmd		= 'S',
		.sub_cmd	= 'W',
		.count		= 2,
		.field		= {
			[0] = str_seconds,
			[1] = str_interval,
		},
	};
	int ret;

	snprintf(str_seconds, wu_param_len, "%ud", seconds);
	snprintf(str_interval, wu_param_len, "%ud", interval);

	ret = wu_write(fd,&p);
	if (ret) {
		perr("Setting Sampling Interval");
		return ret;
	}
	sleep(1);
	return 0;
}

static int wu_store_interval(int fd)
{
	char * s = wu_option_value(wu_option_interval);
	char * end;

	wu_interval = strtol(s,&end, 0);
	if (*end) {
		err("Invalid interval: %s", s);
		return ret_err(EINVAL);
	}
	return wu_write_interval(fd, 1, wu_interval);
}

static int wu_show_mode(int fd)
{
	struct wu_packet p = {
		.cmd		= 'M',
		.sub_cmd	= 'R',
		.count		= 0,
		.label		= {
			[0] = "display mode",
		},
	};
	int ret;

	ret = wu_write(fd,&p);
	if (ret) {
		perr("Requesting device display mode");
		return ret;
	}

	ret = wu_read(fd,&p);
	if (ret) {
		perr("Reaing device display mode");
		return ret;
	}
	dump_packet(&p);
	return ret;
}

static int wu_write_mode(int fd, int mode)
{
	char str_mode[wu_param_len];
	struct wu_packet p = {
		.cmd		= 'M',
		.sub_cmd	= 'W',
		.count		= 1,
		.field		= {
			[0] = str_mode,
		},
	};
	int ret;
	
	snprintf(str_mode, wu_param_len, "%ud", mode);
	ret = wu_write(fd,&p);
	if (ret)
		perr("Setting device display mode");
	else
		sleep(1);
	return ret;
}

static int wu_store_mode(int fd)
{
	char * s = wu_option_value(wu_option_mode);
	char * end;
	unsigned int mode;

	mode = strtol(s,&end, 0);
	if (*end) {
		err("Invalid mode: %s", s);
		return ret_err(EINVAL);
	}
	return wu_write_mode(fd, mode);
}



static int wu_show_user(int fd)
{
	struct wu_packet p = {
		.cmd		= 'U',
		.sub_cmd	= 'R',
		.count		= 0,
		.label		= {
			[0] = "cost per kWh",
			[1] = "2nd tier cost",
			[2] = "2nd tier threshold",
			[3] = "duty cycle threshold",
		},
	};
	int ret;

	ret = wu_write(fd,&p);
	if (ret) {
		perr("Requesting user parameters");
		return ret;
	}
	sleep(1);

	ret = wu_read(fd,&p);
	if (ret) {
		perr("Reading user parameters");
		return ret;
	}
	print_packet(&p, "User Settings");
	return 0;
}


static int wu_write_user(int fd, unsigned int kwh_cost,
			 unsigned int second_tier_cost,
			 unsigned int second_tier_threshold,
			 unsigned int duty_cycle_threshold)
{
	char str_kwh_cost[wu_param_len];
	char str_2nd_tier_cost[wu_param_len];
	char str_2nd_tier_threshold[wu_param_len];
	char str_duty_cycle_threshold[wu_param_len];

	struct wu_packet p = {
		.cmd		= 'U',
		.sub_cmd	= 'R',
		.count		= 0,
		.label		= {
			[0] = str_kwh_cost,
			[1] = str_2nd_tier_cost,
			[2] = str_2nd_tier_threshold,
			[3] = str_duty_cycle_threshold,
		},
	};
	int ret;

	snprintf(str_kwh_cost, wu_param_len, "%ud", kwh_cost);
	snprintf(str_2nd_tier_cost, wu_param_len, "%ud",
		 second_tier_cost);
	snprintf(str_2nd_tier_threshold, wu_param_len, "%ud",
		 second_tier_threshold);
	snprintf(str_duty_cycle_threshold, wu_param_len, "%ud",
		 duty_cycle_threshold);

	ret = wu_write(fd,&p);
	if (ret)
		perr("Writing user parameters");
	else
		sleep(1);
	return ret;
}

static int wu_store_user(int fd)
{
	unsigned int kwh_cost;
	unsigned int second_tier_cost;
	unsigned int second_tier_threshold;
	unsigned int duty_cycle_threshold;
	char * buf = wu_option_value(wu_option_user);
	char * s = buf;
	char * next;

	if (!buf) {
		err("No user parameters?");
		return ret_err(EINVAL);
	}

	kwh_cost = strtoul(s,&next, 0);
	if (next == s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}

	s = next;
	while (s&&  !isdigit(*s))
		s++;
	if (!s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}


	second_tier_cost = strtoul(s,&next, 0);
	if (next == s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}

	s = next;
	while (s&&  !isdigit(*s))
		s++;
	if (!s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}


	second_tier_threshold = strtoul(s,&next, 0);
	if (next == s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}

	s = next;
	while (s&&  !isdigit(*s))
		s++;
	if (!s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}


	duty_cycle_threshold = strtoul(s,&next, 0);
	if (next == s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}

	s = next;
	while (s&&  !isdigit(*s))
		s++;
	if (!s) {
		err("Incomplete user parameters");
		return ret_err(EINVAL);
	}

	return wu_write_user(fd, kwh_cost, second_tier_cost,
			     second_tier_threshold, duty_cycle_threshold);
}


static void enable_field(char * name)
{
	int i;

	for (i = 0; i<  wu_num_fields; i++) {
		if (!strcasecmp(wu_fields[i].name, name)) {
			wu_fields[i].enable = 1;
			break;
		}
	}
}

static void enable_all_fields(void)
{
	int i;

	for (i = 0; i<  wu_num_fields; i++)
		wu_fields[i].enable = 1;
}



static int wu_show_help(int);
static int wu_show_version(int);



static int wu_store_count(int unused)
{
	char * s = wu_option_value(wu_option_count);
	char * end;

	if (s) {
		wu_count = strtol(s,&end, 0);
		if (*end) {
			err("Bad count field");
			return ret_err(EINVAL);
		}
	}
	return 0;
}

static int wu_store_debug(int unused)
{
	wu_debug = 1;
	return 0;
}

static int wu_store_delim(int unused)
{
	char * s = wu_option_value(wu_option_delim);
	
	if (s)
		wu_delim = s;
	return 0;
}

static int wu_store_final(int unused)
{
	wu_final = 1;
	return 0;
}

static int wu_store_label(int unused)
{
	wu_label = 1;
	return 0;
}

static int wu_store_newline(int unused)
{
	wu_newline = 1;
	return 0;
}

static int wu_store_suppress(int unused)
{
	wu_suppress = 1;
	return 0;
}

static int wu_store_localtime(int unused)
{
	wu_localtime = 1;
	return 0;
}

static int wu_store_gmtime(int unused)
{
	wu_gmtime = 1;
	return 0;
}

static int wu_store_info_all(int unused)
{
	wu_info_all = 1;
	return 0;
}

static int wu_store_no_data(int unused)
{
	wu_no_data = 1;
	return 0;
}

static int wu_store_set_only(int unused)
{
	wu_set_only = 1;
	return 0;
}


/**
 *	wu_options - command line options and their associated flags
 *
 */
static struct wu_options wu_options[] = {

	/*
	 * Help!
	 */
	[wu_option_help] = {
		.longopt	= "help",
		.shortopt	= 'h',
		.param		= 0,
		.descr		= "Display help text and exit",
		.show		= wu_show_help,
	},

	[wu_option_version] = {
		.longopt	= "version",
		.shortopt	= 'V',
		.param		= 0,
		.descr		= "Display version information and exit",
		.show		= wu_show_version,
	},

	/*
	 * Modifies the output for all other options
	 */
	[wu_option_debug] = {
		.longopt	= "debug",
		.shortopt	= 'd',
		.param		= 0,
		.descr		= "Print out debugging messages",
		.store		= wu_store_debug,
	},

	/*
	 * For data reading..
	 */
	[wu_option_count] = {
		.longopt	= "count",
		.shortopt	= 'c',
		.param		= 1,
		.descr		= "Specify number of data samples",
		.option		= "<n>",
		.store		= wu_store_count,
	},

	[wu_option_final] = {
		.longopt	= "final",
		.shortopt	= 'z',
		.param		= 0,
		.descr		= "Print final interval information",
		.store		= wu_store_final,
	},

	/*
	 * Modifies output for each option (most relevant for data)
	 */
	[wu_option_delim] = {
		.longopt	= "delim",
		.shortopt	= 'f',
		.param		= 1,
		.descr		= "Set field delimiter (default \", \")",
		.option		= "<str>",
		.store		= wu_store_delim,
	},

	[wu_option_newline] = {
		.longopt	= "newline",
		.shortopt	= 'n',
		.param		= 0,
		.descr		= "Use '\\n' as delimter instead",
		.store		= wu_store_newline,
	},

	[wu_option_localtime] = {
		.longopt	= "localtime",
		.shortopt	= 't',
		.param		= 0,
		.descr		= "Print localtime with each data reading",
		.store		= wu_store_localtime,
	},

	[wu_option_gmtime] = {
		.longopt	= "gmtime",
		.shortopt	= 'g',
		.param		= 0,
		.descr		= "Print GMT time with each data reading",
		.store		= wu_store_gmtime,
	},

	[wu_option_label] = {
		.longopt	= "label",
		.shortopt	= 'l',
		.param		= 0,
		.descr		= "Show labels of each field",
		.store		= wu_store_label,
	},

	/*
	 * Relevant for each of the fields below
	 */
	[wu_option_suppress] = {
		.longopt	= "suppress",
		.shortopt	= 's',
		.param		= 0,
		.descr		= "Suppress printing of the field description",
		.store		= wu_store_suppress,
	},

	/*
	 * These options print values from the device and exit.
	 */
	[wu_option_cal] = {
		.longopt	= "calibrate",
		.shortopt	= 'b',
		.param		= 0,
		.descr		= "Print calibration parameters",
		.show		= wu_show_cal,
	},

	[wu_option_header] = {
		.longopt	= "header",
		.shortopt	= 'r',
		.param		= 0,
		.descr		= "Print data field names (as read from device)",
		.show		= wu_show_header,
	},

	/*
	 * These options have an optional parameter.
	 * W/o that parameter, they print values from the device.
	 * W/ that parameter, they set that option and read data.
	 *
	 * Except when the 'set-only' parameter is used, then the
	 * parameters are set, then re-read and printed.
	 */
	[wu_option_interval] = {
		.longopt	= "interval",
		.shortopt	= 'i',
		.param		= 2,
		.descr		= "Get/Set sampling interval",
		.option		= "<n>",
		.show		= wu_show_interval,
		.store		= wu_store_interval,
	},

	[wu_option_mode] = {
		.longopt	= "mode",
		.shortopt	= 'm',
		.param		= 2,
		.descr		= "Get/Set display mode",
		.option		= "<n>",
		.show		= wu_show_mode,
		.store		= wu_store_mode,
	},

	[wu_option_user] = {
		.longopt	= "user",
		.shortopt	= 'u',
		.param		= 2,
		.descr		= "Get/Set user parameters",
		.option		= "<str>",
		.format		= "<cost per kwh>,<2nd tier cost>,"
				  "<2nd tier threshold>,"
				  "<duty cycle threshold>",
		.show		= wu_show_user,
		.store		= wu_store_user,
	},

	[wu_option_info_all] = {
		.longopt	= "show-all",
		.shortopt	= 'a',
		.param		= 0,
		.descr		= "Show all device parameters",
		.store		= wu_store_info_all,
	},

	[wu_option_no_data] = {
		.longopt	= "no-data",
		.shortopt	= 'N',
		.param		= 0,
		.descr		= "Don't read any data (just read device info)",
		.store		= wu_store_no_data,
	},

	[wu_option_set_only] = {
		.longopt	= "set-only",
		.shortopt	= 'S',
		.param		= 0,
		.descr		= "Set parameters only (don't read them back)",
		.store		= wu_store_set_only,
	},
};

#define wu_num_options ARRAY_SIZE(wu_options)

static int wu_show_version(int unused)
{
	printf("%s Version %s\n", prog_name, wu_version);
	return 0;
}

static int wu_show_help(int unused)
{
	int i;
	int n;

	wu_show_version(unused);
	printf("  A program for interfacing with the Watts Up? Power Meter\n");
	printf("\n");

	printf("Usage: %s [<options>  ... ]<device>  [<values>  ... ]\n",
	       prog_name);
	printf("\n");
	
	printf("<device>  is the serial port the device is connected at.\n");
	printf("\n");

	printf("<options>  are any of the following:\n");
	for (i = 0; i<  wu_num_options; i++) {
		n = printf("  -%c", wu_options[i].shortopt);

		if (wu_options[i].param == 0)
			n = printf(" ");
		else if (wu_options[i].param == 1)
			n = printf(" %s", wu_options[i].option);
		else if (wu_options[i].param == 2)
			n = printf(" [%s]", wu_options[i].option);

		n += printf("%*c| ", n - 12, ' ');
		n += printf("--%s", wu_options[i].longopt);

		if (wu_options[i].param == 0)
			n += printf(" ");
		else if (wu_options[i].param == 1)
			n += printf("=%s", wu_options[i].option);
		else if (wu_options[i].param == 2)
			n += printf("[=%s]", wu_options[i].option);

		printf("%*c%s\n",
		       40 - n, ' ', wu_options[i].descr);
	}
	printf("\n");
	printf("<value>  specifies which of these to print out (default: ALL)\n");
	for (i = 0; i<  wu_num_fields; i++) {
		printf("%12s -- %s\n", wu_fields[i].name, wu_fields[i].descr);
	}
	printf("\n");

	return 0;
}


static char * wu_option_value(unsigned int index)
{
	return (index<  wu_num_options) ? wu_options[index].value : NULL;
}


static int wu_check_option_show(int index)
{
	/*
	 * Return 1 if we need to print something out for
	 * a particular option.
	 */
	if (index<  wu_num_options) {
		if (wu_options[index].flag) {
			return 1;
		}
	}
	return 0;
}

static int wu_check_option_store(int index)
{
	/*
	 * Return a 1 if this option is set.
	 */

	if (index<  wu_num_options) {
		if (wu_options[index].flag) {
			return 1;
		}
	}
	return 0;
}


static int wu_show(int index, int dev_fd)
{
	if (wu_options[index].show)
		return wu_options[index].show(dev_fd);
	return 0;
}

/*
 * Check if the option is set, and call its method if so.
 * Return whether or not we did anything..
 */

static int wu_check_show(int index, int dev_fd)
{
	if (wu_check_option_show(index)) {
		wu_show(index, dev_fd);
		return 1;
	}
	return 0;
}


/*
 * Check if the option is set and if so, call it
 * Return the value from the ->store() method.
 */

static int wu_check_store(int index, int dev_fd)
{
	if (wu_check_option_store(index)) {
		if (wu_options[index].store)
			return wu_options[index].store(dev_fd);
	}
	return 0;
}


static void make_longopt(struct option * l)
{
	int i;

	for (i = 0; i<  wu_num_options; i++) {
		l[i].name = wu_options[i].longopt;
		l[i].has_arg = wu_options[i].param;
		l[i].flag =&wu_options[i].flag;
		l[i].val = 0;
	}
}

static void make_shortopt(char * str)
{
	int i;
	char * s = str;
	
	for (i = 0; i<  wu_num_options; i++) {
		*s++ = wu_options[i].shortopt;
		if (wu_options[i].param)
			*s++ = wu_options[i].param == 1 ? ':' : ';';
	}
}

static void enable_short_option(int c, char * arg)
{
	int i;

	/*
	 * Friggin' getopt_long() will return the
	 * character if we get a short option (e.g. '-h'),
	 * instead of returning 0 like it does when it
	 * gets a long option (e.g. "--help"). Ugh.
	 */
	for (i = 0; i<  wu_num_options; i++) {
		if (wu_options[i].shortopt == c) {
			wu_options[i].flag = 1;
			if (arg)
				wu_options[i].value = strdup(arg);
			break;
		}
	}
}

static int parse_args(int argc, char ** argv)
{
	struct option longopts[wu_num_options + 1] = { };
	char shortopts[wu_num_options * 2] = "";

	make_longopt(longopts);
	make_shortopt(shortopts);


	while (1) {
		int c;
		int index;

		c = getopt_long(argc, argv, shortopts,
				longopts,&index);
		if (c == -1)
			break;
		
		switch (c) {
		case 0:
			wu_options[index].flag = 1;
			if (optarg)
				wu_options[index].value = strdup(optarg);
			
			printf("long option: val = %c, optarg = %s\n",
			       wu_options[index].shortopt, optarg);
			break;
		case '?':
			err("Bad parameter");
			return ret_err(EINVAL);
			break;
		default:
			enable_short_option(c, optarg);
			break;
		}
	}

	/*
	 * Check for help request now and bail after
	 * printing it, if it's set.
	 */
	if (wu_check_show(wu_option_help, 0))
		exit(0);

	if (wu_check_show(wu_option_version, 0))
		exit(0);

	/*
	 * Fields to print out
	 */
	if (optind<  argc) {
		int i;

		wu_device = argv[optind++];

		if (optind<  argc) {
			for (i = optind; i<  argc; i++)
				enable_field(argv[i]);
		} else
			enable_all_fields();

	} else {
		wu_show(wu_option_help, 0);
		return ret_err(EINVAL);
	}
	return 0;
}


int main(int argc, char ** argv)
{
	int ret;
	int fd = 0;

	ret = parse_args(argc, argv);
	if (ret)
		return 0;

	/*
	 * Try to enable debugging early
	 */
	if ((ret = wu_check_store(wu_option_debug, 0)))
		goto Close;

	ret = open_device(wu_device,&fd);
	if (ret)
		return ret;

	dbg("%s: Open for business", wu_device);

	ret = setup_serial_device(fd);
	if (ret)
		goto Close;

	wu_clear(fd);

	wu_fd = fd;

	/*
	 * Set delimeter before we print out any fields.
	 */
	if ((ret = wu_check_store(wu_option_delim, fd)))
		goto Close;

	/*
	 * Ditto for 'label' and 'newline' flags.
	 */
	if ((ret = wu_check_store(wu_option_label, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_newline, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_suppress, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_localtime, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_gmtime, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_set_only, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_no_data, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_info_all, fd)))
		goto Close;


	/*
	 * Options to set device parameters.
	 */
	if ((ret = wu_check_store(wu_option_interval, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_mode, fd)))
		goto Close;

	if ((ret = wu_check_store(wu_option_user, fd)))
		goto Close;

	/*
	 * Check for options to print device info
	 */
	if (wu_info_all) {
		wu_show(wu_option_cal, fd);
		wu_show(wu_option_header, fd);
		wu_show(wu_option_interval, fd);
		wu_show(wu_option_mode, fd);
		wu_show(wu_option_user, fd);
	} else {
		wu_check_show(wu_option_cal, fd);
		wu_check_show(wu_option_header, fd);

		if (!wu_set_only) {
			wu_check_show(wu_option_interval, fd);
			wu_check_show(wu_option_mode, fd);
			wu_check_show(wu_option_user, fd);
		}
	}

	if (!wu_no_data) {

		if ((ret = wu_check_store(wu_option_count, fd)))
			goto Close;

		if ((ret = wu_check_store(wu_option_final, fd)))
			goto Close;

		if ((ret = wu_start_log()))
			goto Close;
	
		wu_read_data(fd);
		
		wu_stop_log();
	}
Close:
	close(fd);
	return ret;
}