[fs20pcs] / fs20pcs.c

#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <libusb-1.0/libusb.h>

#define USB_TIMEOUT		10000

#define ID_VENDOR	0x18ef
#define ID_PRODUCT	0xe015

extern char *optarg;

/* Not in all libusb-1.0 versions, so we have to roll our own :-( */
static char * usb_strerror(int e)
{
	static char unknerr[256];

	switch (e) {
		case LIBUSB_SUCCESS:
			return "Success";
		case LIBUSB_ERROR_IO:
			return "Input/output error";
		case LIBUSB_ERROR_INVALID_PARAM:
			return "Invalid parameter";
		case LIBUSB_ERROR_ACCESS:
			return "Access denied (insufficient permissions)";
		case LIBUSB_ERROR_NO_DEVICE:
			return "No such device (it may have been disconnected)";
		case LIBUSB_ERROR_NOT_FOUND:
			return "Entity not found";
		case LIBUSB_ERROR_BUSY:
			return "Resource busy";
		case LIBUSB_ERROR_TIMEOUT:
			return "Operation timed out";
		case LIBUSB_ERROR_OVERFLOW:
			return "Overflow";
		case LIBUSB_ERROR_PIPE:
			return "Pipe error";
		case LIBUSB_ERROR_INTERRUPTED:
			return "System call interrupted (perhaps due to signal)";
		case LIBUSB_ERROR_NO_MEM:
			return "Insufficient memory";
		case LIBUSB_ERROR_NOT_SUPPORTED:
			return "Operation not supported or unimplemented on this platform";
		case LIBUSB_ERROR_OTHER:
			return "Other error";
	};
	snprintf(unknerr, sizeof(unknerr), "Unknown error code %d / 0x%02x", e, e);
	return unknerr;
}

libusb_device_handle *fs20pcs_find() {
	libusb_device_handle *devh = NULL;
	libusb_device **list;
	ssize_t cnt;
	ssize_t i;
	int err;

	cnt = libusb_get_device_list(NULL, &list);
	if (cnt < 0) {
		fprintf(stderr, "Can't get USB device list: %d\n", (int)cnt);
		return NULL;
	}

	for (i = 0; i < cnt; i++){
		struct libusb_device_descriptor desc;

		err = libusb_get_device_descriptor(list[i], &desc);
		if (err)
			continue;

		if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
			libusb_device *dev = list[i];

			err = libusb_open(dev, &devh);
			if (err) {
				fprintf(stderr, "Can't open device: %s\n", usb_strerror(err));
				return NULL;
			}

			err = libusb_detach_kernel_driver(devh, 0);
			if ((err != 0) && (err != LIBUSB_ERROR_NOT_FOUND)) {
				fprintf(stderr, "Can't detach kernel driver: %s\n", usb_strerror(err));
				return NULL;
			}

			err = libusb_claim_interface(devh, 0);
			if ((err != 0)) {
				fprintf(stderr, "Can't claim interface: %s\n", usb_strerror(err));
				return NULL;
			}

			return devh;
		}

	}

	return NULL;
}

int fs20pcs_send(libusb_device_handle *devh, unsigned char* send_data)
{
	unsigned char recv_data[5] = {0x00, 0x00, 0x00, 0x00, 0x00};
	int err;
	int cnt;
	int i;
	int ret;

	err = libusb_interrupt_transfer(devh, 0x01, send_data, 11, &cnt, 5000);
	if (err) {
		fprintf(stderr, "Can't send data: %s\n", usb_strerror(err));
		return 0;
	}

	err = libusb_interrupt_transfer(devh, 0x81, recv_data, sizeof(recv_data), &cnt, 5000);
	if (err) {
		fprintf(stderr, "Can't receive data: %s\n", usb_strerror(err));
		return 0;
	}

	if ((recv_data[0] != 0x02) ||
	    (recv_data[1] != 0x03) ||
	    (recv_data[2] != 0xa0)) {
	    fprintf(stderr, "Unexpected response: ");
	    for (i = 0; i < cnt; i++) {
		    fprintf(stderr, "0x%02x ", recv_data[i]);
	    }
	    fprintf(stderr, "\n");

	    return 0;
	}

	ret = 1;

	switch(recv_data[3]) {
		case 0x00:
			printf("Success");
			break;
		case 0x01:
			printf("Firmware: V%d.%d", ((recv_data[4] & 0xf0) >> 4) & 0x0f, recv_data[4] & 0x0f);
			break;
		case 0x02:
			printf("Unknown command");
			ret = 0;
			break;
		case 0x03:
			printf("Wrong length");
			ret = 0;
			break;
		case 0x04:
			printf("Aborted sending long press");
			break;
		case 0x05:
			printf("Nothing to stop");
			break;
		default:
			printf("Unknown response: 0x%02x 0x%02x", recv_data[3], recv_data[4]);
			ret = 0;
			break;
	}

	printf("\n");

	return ret;
}

unsigned char *parse_housecode(char *hc)
{
	static unsigned char housecode[2];
	char hc_fixed[9];
	char *ep;
	unsigned long val;
	int i;

	if (hc == NULL)
		return NULL;

	memset(housecode, 0, sizeof(housecode));

	switch(strlen(hc)) {
		case 6:
			if (strncmp(hc, "0x", 2)) {
				fprintf(stderr, "Not a 2 byte hexstring: %s\n", hc);
				return NULL;
			}
		case 4:
			val = strtoul(hc, &ep, 16);
			if (*ep != '\0') {
				fprintf(stderr, "Not a 2 byte hexstring: %s\n", hc);
				return NULL;
			}
			break;
		case 8:
			memset(hc_fixed, 0, sizeof(hc_fixed));
			for (i = 0; i < 8; i++) {
				if ((hc[i] < '1') || (hc[i] > '4')) {
					fprintf(stderr, "Not a valid ELV housecode: %s\n", hc);
					return NULL;
				}
				hc_fixed[i] = hc[i] - 1;
				val = strtoul(hc_fixed, &ep, 4);

				if (*ep != '\0') {
					fprintf(stderr, "Can't parse fixed ELV housecode: %s\n", hc_fixed);
					return NULL;
				}
			}
			break;
		default:
			fprintf(stderr, "Housecode has to be 4 or 8 chars long!\n");
			return NULL;
			break;
	}

	housecode[0] = (val & 0xff00) >> 8;
	housecode[1] = (val & 0xff);

	return housecode;
}

void syntax(char *prog)
{
	fprintf(stderr, "Syntax: %s options\n\n", prog);
	fprintf(stderr, "Possible options:\n");
	fprintf(stderr, "\t-V\t\trequest hardware-version\n");
	fprintf(stderr, "\t-x\t\tabort sending long press\n");
	fprintf(stderr, "\t-h [ELV|hex]\thousecode in ELV- or hex-notation\n");
	fprintf(stderr, "The following actions need an housecode:\n");
	fprintf(stderr, "\t-a n\t\tsend commands to device at address n\n");
	fprintf(stderr, "\t-s hex\t\tsend command byte\n");
	fprintf(stderr, "\t-e hex\t\textension byte for command\n");
	fprintf(stderr, "\t-r n\t\trepeat sending n times\n");
	fprintf(stderr, "\nCommand bytes (without extension byte):\n");
	fprintf(stderr, "0x00\t\tswitch off\n");
	fprintf(stderr, "0x01-0x10\tswitch on dimmed (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%)\n");
	fprintf(stderr, "0x11\t\tswitch on\n");
	fprintf(stderr, "0x12\t\ttoggle\n");
	fprintf(stderr, "0x13\t\tdimup\n");
	fprintf(stderr, "0x14\t\tdimdown\n");
	fprintf(stderr, "0x15\t\tdimup, pause, dimdown, pause, ...\n");
	fprintf(stderr, "0x16\t\tstart/stop programming internal timer\n");
	fprintf(stderr, "0x17\t\tlearn housecode/address\n");
	fprintf(stderr, "0x18\t\toff for internal timer, then back on with current level\n");
	fprintf(stderr, "0x19\t\ton (100%%) for internal timer, then off\n");
	fprintf(stderr, "0x1a\t\ton (old level) for internal timer, then off\n");
	fprintf(stderr, "0x1b\t\tfactory reset\n");
	fprintf(stderr, "0x1e\t\ton (100%%) for internal timer, then old level\n");
	fprintf(stderr, "0x1f\t\ton (old level) for internal timer, then old state\n");
	fprintf(stderr, "\nCommand bytes (with timer as extension byte):\n");
	fprintf(stderr, "0x20\t\tdim down to off while timer is running\n");
	fprintf(stderr, "0x21-0x30\tdim to (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%) while timer is running\n");
	fprintf(stderr, "0x31\t\tdim to last level while timer is running\n");
	fprintf(stderr, "0x32\t\tdim to off, then after timer dim to off\n");
	fprintf(stderr, "0x33\t\tdimup now and switch off after timer\n");
	fprintf(stderr, "0x34\t\tdimdown now and switch off after timer\n");
	fprintf(stderr, "0x35\t\tdimup or dimdown (toggle) and switch off after timer\n");
	fprintf(stderr, "0x36\t\tprogram internal timer\n");
	fprintf(stderr, "0x38\t\toff for timer, then back on with current level\n");
	fprintf(stderr, "0x39\t\ton (100%%) for timer, then off\n");
	fprintf(stderr, "0x3a\t\ton (old level) for timer, then off\n");
	fprintf(stderr, "0x3c\t\tprogram internal ramp-up-time\n");
	fprintf(stderr, "0x3d\t\tprogram internal ramp-down-time\n");
	fprintf(stderr, "0x3e\t\ton (100%%) for timer, then old level\n");
	fprintf(stderr, "0x3f\t\ton (old level) for timer, then old state\n");
};

enum {
	NO_ACTION,
	REQUEST_FIRMWARE,
	SEND_COMMAND,
	ABORT_LONG_PRESS
};

#define DUPLICATE_ACTION	if (action != NO_ACTION) { \
					fprintf(stderr, "duplicate action specified!\n"); \
					exit(EXIT_FAILURE); }

int main(int argc, char **argv)
{
	unsigned char send_data[11];
	unsigned char *housecode = NULL;
	libusb_device_handle *devh = NULL;
	char *ep;
	int err;
	int opt;
	int action = NO_ACTION;
	uint8_t command = 0x00;
	uint8_t extension = 0x00;
	uint8_t repeat = 0;
	int addr = -1;

	memset(send_data, 0, sizeof(send_data));

	send_data[0] = 0x01;

	while ((opt = getopt(argc, argv, "Vxs:h:a:r:e:")) != -1) {
		switch(opt) {
			case 'V':
				DUPLICATE_ACTION;
				action = REQUEST_FIRMWARE;
				break;
			case 'x':
				DUPLICATE_ACTION;
				action = ABORT_LONG_PRESS;
				break;
			case 's':
				DUPLICATE_ACTION;
				action = SEND_COMMAND;

				command = strtoul(optarg, &ep, 16);
				if (*ep != '\0') {
					fprintf(stderr, "Can't parse command!\n");
					exit(EXIT_FAILURE);
				}
#ifdef DEBUG
				printf("Got command: %d\n", command);
#endif
				break;
			case 'h':
				housecode = parse_housecode(optarg);
				if (!housecode) {
					fprintf(stderr, "Can't parse housecode!\n");
					exit(EXIT_FAILURE);
				}
#ifdef DEBUG
				printf("Got housecode: 0x%02x%02x\n", housecode[0], housecode[1]);
#endif
				break;
			case 'a':
				addr = strtoul(optarg, &ep, 10);
				if (*ep != '\0') {
					fprintf(stderr, "Can't parse address!\n");
					exit(EXIT_FAILURE);
				}
#ifdef DEBUG
				printf("Got address: 0x%02x\n", addr);
#endif
				break;
			case 'r':
				repeat = strtoul(optarg, &ep, 10);
				if (*ep != '\0') {
					fprintf(stderr, "Can't parse repeat!\n");
					exit(EXIT_FAILURE);
				}
#ifdef DEBUG
				printf("Got repeat: %d\n", repeat);
#endif
				break;
			case 'e':
				extension = strtoul(optarg, &ep, 16);
				if (*ep != '\0') {
					fprintf(stderr, "Can't parse extension!\n");
					exit(EXIT_FAILURE);
				}
#ifdef DEBUG
				printf("Got extension: %d\n", extension);
#endif
				break;
			case ':':
			case '?':
			default:
				syntax(argv[0]);
				exit(EXIT_FAILURE);
				break;
		}
	}

	switch(action) {
		case REQUEST_FIRMWARE:
			send_data[1] = 0x01;
			send_data[2] = 0xf0;
			printf("Requesting firmware version...\n");

			break;
		case ABORT_LONG_PRESS:
			send_data[1] = 0x01;
			send_data[2] = 0xf3;
			printf("Aborting long press...\n");

			break;
		case SEND_COMMAND:
			if (housecode == NULL) {
				fprintf(stderr, "housecode needed!\n");
				exit(EXIT_FAILURE);
			}
			if (addr == -1) {
				fprintf(stderr, "address needed!\n");
				exit(EXIT_FAILURE);
			}

			if (repeat) {
				send_data[1] = 0x07;
				send_data[2] = 0xf2;
				send_data[8] = repeat;
				printf("Sending 0x%02x 0x%02x to address %d (hc: 0x%02x%02x) (repeated %d times)\n",
					command, extension, addr,
					housecode[0], housecode[1],
					repeat);
			} else {
				send_data[1] = 0x06;
				send_data[2] = 0xf1;
				printf("Sending 0x%02x 0x%02x to address %d (hc: 0x%02x%02x)\n",
					command, extension, addr,
					housecode[0], housecode[1]);
			}
			send_data[3] = housecode[0];
			send_data[4] = housecode[1];
			send_data[5] = addr;
			send_data[6] = command;
			send_data[7] = extension;

			break;
		case NO_ACTION:
		default:
			fprintf(stderr, "No action specified!\n\n");
			syntax(argv[0]);
			exit(EXIT_FAILURE);
			break;
	}

	err = libusb_init(NULL);
	if (err != 0) {
		fprintf(stderr, "Can't initialize libusb: %s\n", usb_strerror(err));
		return EXIT_FAILURE;
	}

	devh = fs20pcs_find();
	if (!devh) {
		fprintf(stderr, "Can't find/open fs20pcs!\n");
		return EXIT_FAILURE;
	}

	if (fs20pcs_send(devh, send_data) == 0) {
		fprintf(stderr, "Can't communicate with fs20pcs!\n");
		return EXIT_FAILURE;
	}

	libusb_close(NULL);

	return EXIT_SUCCESS;
}
Commit	Line	Data
a06d3b72 MG	1	#include <string.h>
	2	#include <stdio.h>
	3	#include <stdint.h>
	4	#include <unistd.h>
	5	#include <stdlib.h>
	6	#include <libusb-1.0/libusb.h>
	7
	8	#define USB_TIMEOUT 10000
	9
	10	#define ID_VENDOR 0x18ef
	11	#define ID_PRODUCT 0xe015
	12
23892620 MG	13	extern char *optarg;
23892620 MG	14
a06d3b72 MG	15	/* Not in all libusb-1.0 versions, so we have to roll our own :-( */
	16	static char * usb_strerror(int e)
	17	{
	18	static char unknerr[256];
	19
	20	switch (e) {
	21	case LIBUSB_SUCCESS:
	22	return "Success";
	23	case LIBUSB_ERROR_IO:
	24	return "Input/output error";
	25	case LIBUSB_ERROR_INVALID_PARAM:
	26	return "Invalid parameter";
	27	case LIBUSB_ERROR_ACCESS:
	28	return "Access denied (insufficient permissions)";
	29	case LIBUSB_ERROR_NO_DEVICE:
	30	return "No such device (it may have been disconnected)";
	31	case LIBUSB_ERROR_NOT_FOUND:
	32	return "Entity not found";
	33	case LIBUSB_ERROR_BUSY:
	34	return "Resource busy";
	35	case LIBUSB_ERROR_TIMEOUT:
	36	return "Operation timed out";
	37	case LIBUSB_ERROR_OVERFLOW:
	38	return "Overflow";
	39	case LIBUSB_ERROR_PIPE:
	40	return "Pipe error";
	41	case LIBUSB_ERROR_INTERRUPTED:
	42	return "System call interrupted (perhaps due to signal)";
	43	case LIBUSB_ERROR_NO_MEM:
	44	return "Insufficient memory";
	45	case LIBUSB_ERROR_NOT_SUPPORTED:
	46	return "Operation not supported or unimplemented on this platform";
	47	case LIBUSB_ERROR_OTHER:
	48	return "Other error";
	49	};
	50	snprintf(unknerr, sizeof(unknerr), "Unknown error code %d / 0x%02x", e, e);
	51	return unknerr;
	52	}
	53
	54	libusb_device_handle *fs20pcs_find() {
	55	libusb_device_handle *devh = NULL;
	56	libusb_device **list;
	57	ssize_t cnt;
	58	ssize_t i;
	59	int err;
	60
	61	cnt = libusb_get_device_list(NULL, &list);
	62	if (cnt < 0) {
	63	fprintf(stderr, "Can't get USB device list: %d\n", (int)cnt);
	64	return NULL;
	65	}
	66
	67	for (i = 0; i < cnt; i++){
	68	struct libusb_device_descriptor desc;
	69
	70	err = libusb_get_device_descriptor(list[i], &desc);
	71	if (err)
	72	continue;
	73
	74	if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
	75	libusb_device *dev = list[i];
	76
	77	err = libusb_open(dev, &devh);
	78	if (err) {
79	fprintf(stderr, "Can't open device: %s\n", usb_strerror(err));
80	return NULL;
81	}
82
83	err = libusb_detach_kernel_driver(devh, 0);
84	if ((err != 0) && (err != LIBUSB_ERROR_NOT_FOUND)) {
85	fprintf(stderr, "Can't detach kernel driver: %s\n", usb_strerror(err));
86	return NULL;
87	}
88
89	err = libusb_claim_interface(devh, 0);
90	if ((err != 0)) {
91	fprintf(stderr, "Can't claim interface: %s\n", usb_strerror(err));
92	return NULL;
93	}
94
95	return devh;
96	}
97
98	}
99
100	return NULL;
101	}
102
103	int fs20pcs_send(libusb_device_handle devh, unsigned char send_data)
104	{
105	unsigned char recv_data[5] = {0x00, 0x00, 0x00, 0x00, 0x00};
106	int err;
107	int cnt;
108	int i;
2b257333	109	int ret;
a06d3b72 MG	110
	111	err = libusb_interrupt_transfer(devh, 0x01, send_data, 11, &cnt, 5000);
	112	if (err) {
	113	fprintf(stderr, "Can't send data: %s\n", usb_strerror(err));
	114	return 0;
	115	}
	116
	117	err = libusb_interrupt_transfer(devh, 0x81, recv_data, sizeof(recv_data), &cnt, 5000);
	118	if (err) {
	119	fprintf(stderr, "Can't receive data: %s\n", usb_strerror(err));
	120	return 0;
	121	}
	122
2b257333 MG	123	if ((recv_data[0] != 0x02) \|\|
	124	(recv_data[1] != 0x03) \|\|
	125	(recv_data[2] != 0xa0)) {
	126	fprintf(stderr, "Unexpected response: ");
	127	for (i = 0; i < cnt; i++) {
	128	fprintf(stderr, "0x%02x ", recv_data[i]);
	129	}
	130	fprintf(stderr, "\n");
	131
	132	return 0;
	133	}
	134
	135	ret = 1;
	136
	137	switch(recv_data[3]) {
	138	case 0x00:
	139	printf("Success");
	140	break;
	141	case 0x01:
23892620	142	printf("Firmware: V%d.%d", ((recv_data[4] & 0xf0) >> 4) & 0x0f, recv_data[4] & 0x0f);
2b257333 MG	143	break;
	144	case 0x02:
	145	printf("Unknown command");
	146	ret = 0;
	147	break;
	148	case 0x03:
	149	printf("Wrong length");
	150	ret = 0;
	151	break;
	152	case 0x04:
	153	printf("Aborted sending long press");
	154	break;
	155	case 0x05:
	156	printf("Nothing to stop");
	157	break;
	158	default:
	159	printf("Unknown response: 0x%02x 0x%02x", recv_data[3], recv_data[4]);
	160	ret = 0;
	161	break;
a06d3b72	162	}
2b257333	163
a06d3b72 MG	164	printf("\n");
a06d3b72 MG	165
2b257333	166	return ret;
a06d3b72 MG	167	}
a06d3b72 MG	168
23892620 MG	169	unsigned char parse_housecode(char hc)
	170	{
	171	static unsigned char housecode[2];
	172	char hc_fixed[9];
	173	char *ep;
	174	unsigned long val;
	175	int i;
	176
	177	if (hc == NULL)
	178	return NULL;
	179
	180	memset(housecode, 0, sizeof(housecode));
	181
	182	switch(strlen(hc)) {
	183	case 6:
	184	if (strncmp(hc, "0x", 2)) {
	185	fprintf(stderr, "Not a 2 byte hexstring: %s\n", hc);
	186	return NULL;
	187	}
	188	case 4:
	189	val = strtoul(hc, &ep, 16);
	190	if (*ep != '\0') {
	191	fprintf(stderr, "Not a 2 byte hexstring: %s\n", hc);
	192	return NULL;
	193	}
	194	break;
	195	case 8:
	196	memset(hc_fixed, 0, sizeof(hc_fixed));
	197	for (i = 0; i < 8; i++) {
	198	if ((hc[i] < '1') \|\| (hc[i] > '4')) {
	199	fprintf(stderr, "Not a valid ELV housecode: %s\n", hc);
	200	return NULL;
	201	}
	202	hc_fixed[i] = hc[i] - 1;
	203	val = strtoul(hc_fixed, &ep, 4);
	204
	205	if (*ep != '\0') {
	206	fprintf(stderr, "Can't parse fixed ELV housecode: %s\n", hc_fixed);
	207	return NULL;
	208	}
	209	}
	210	break;
	211	default:
	212	fprintf(stderr, "Housecode has to be 4 or 8 chars long!\n");
	213	return NULL;
	214	break;
	215	}
	216
	217	housecode[0] = (val & 0xff00) >> 8;
	218	housecode[1] = (val & 0xff);
	219
	220	return housecode;
	221	}
	222
	223	void syntax(char *prog)
	224	{
	225	fprintf(stderr, "Syntax: %s options\n\n", prog);
	226	fprintf(stderr, "Possible options:\n");
	227	fprintf(stderr, "\t-V\t\trequest hardware-version\n");
	228	fprintf(stderr, "\t-x\t\tabort sending long press\n");
	229	fprintf(stderr, "\t-h [ELV\|hex]\thousecode in ELV- or hex-notation\n");
	230	fprintf(stderr, "The following actions need an housecode:\n");
	231	fprintf(stderr, "\t-a n\t\tsend commands to device at address n\n");
	232	fprintf(stderr, "\t-s hex\t\tsend command byte\n");
233	fprintf(stderr, "\t-e hex\t\textension byte for command\n");
234	fprintf(stderr, "\t-r n\t\trepeat sending n times\n");
235	fprintf(stderr, "\nCommand bytes (without extension byte):\n");
236	fprintf(stderr, "0x00\t\tswitch off\n");
237	fprintf(stderr, "0x01-0x10\tswitch on dimmed (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%)\n");
238	fprintf(stderr, "0x11\t\tswitch on\n");
239	fprintf(stderr, "0x12\t\ttoggle\n");
240	fprintf(stderr, "0x13\t\tdimup\n");
241	fprintf(stderr, "0x14\t\tdimdown\n");
242	fprintf(stderr, "0x15\t\tdimup, pause, dimdown, pause, ...\n");
243	fprintf(stderr, "0x16\t\tstart/stop programming internal timer\n");
244	fprintf(stderr, "0x17\t\tlearn housecode/address\n");
245	fprintf(stderr, "0x18\t\toff for internal timer, then back on with current level\n");
246	fprintf(stderr, "0x19\t\ton (100%%) for internal timer, then off\n");
247	fprintf(stderr, "0x1a\t\ton (old level) for internal timer, then off\n");
248	fprintf(stderr, "0x1b\t\tfactory reset\n");
249	fprintf(stderr, "0x1e\t\ton (100%%) for internal timer, then old level\n");
250	fprintf(stderr, "0x1f\t\ton (old level) for internal timer, then old state\n");
251	fprintf(stderr, "\nCommand bytes (with timer as extension byte):\n");
252	fprintf(stderr, "0x20\t\tdim down to off while timer is running\n");
253	fprintf(stderr, "0x21-0x30\tdim to (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%) while timer is running\n");
254	fprintf(stderr, "0x31\t\tdim to last level while timer is running\n");
255	fprintf(stderr, "0x32\t\tdim to off, then after timer dim to off\n");
256	fprintf(stderr, "0x33\t\tdimup now and switch off after timer\n");
257	fprintf(stderr, "0x34\t\tdimdown now and switch off after timer\n");
258	fprintf(stderr, "0x35\t\tdimup or dimdown (toggle) and switch off after timer\n");
259	fprintf(stderr, "0x36\t\tprogram internal timer\n");
260	fprintf(stderr, "0x38\t\toff for timer, then back on with current level\n");
261	fprintf(stderr, "0x39\t\ton (100%%) for timer, then off\n");
262	fprintf(stderr, "0x3a\t\ton (old level) for timer, then off\n");
263	fprintf(stderr, "0x3c\t\tprogram internal ramp-up-time\n");
264	fprintf(stderr, "0x3d\t\tprogram internal ramp-down-time\n");
265	fprintf(stderr, "0x3e\t\ton (100%%) for timer, then old level\n");
266	fprintf(stderr, "0x3f\t\ton (old level) for timer, then old state\n");
267	};
268
269	enum {
270	NO_ACTION,
271	REQUEST_FIRMWARE,
272	SEND_COMMAND,
273	ABORT_LONG_PRESS
274	};
275
276	#define DUPLICATE_ACTION if (action != NO_ACTION) { \
277	fprintf(stderr, "duplicate action specified!\n"); \
278	exit(EXIT_FAILURE); }
279
a06d3b72 MG	280	int main(int argc, char **argv)
	281	{
	282	unsigned char send_data[11];
23892620	283	unsigned char *housecode = NULL;
a06d3b72	284	libusb_device_handle *devh = NULL;
23892620	285	char *ep;
a06d3b72	286	int err;
23892620 MG	287	int opt;
	288	int action = NO_ACTION;
	289	uint8_t command = 0x00;
	290	uint8_t extension = 0x00;
	291	uint8_t repeat = 0;
	292	int addr = -1;
a06d3b72	293
23892620 MG	294	memset(send_data, 0, sizeof(send_data));
	295
	296	send_data[0] = 0x01;
	297
	298	while ((opt = getopt(argc, argv, "Vxs:h:a:r:e:")) != -1) {
	299	switch(opt) {
	300	case 'V':
	301	DUPLICATE_ACTION;
	302	action = REQUEST_FIRMWARE;
	303	break;
	304	case 'x':
	305	DUPLICATE_ACTION;
	306	action = ABORT_LONG_PRESS;
	307	break;
	308	case 's':
	309	DUPLICATE_ACTION;
	310	action = SEND_COMMAND;
	311
	312	command = strtoul(optarg, &ep, 16);
	313	if (*ep != '\0') {
	314	fprintf(stderr, "Can't parse command!\n");
	315	exit(EXIT_FAILURE);
	316	}
	317	#ifdef DEBUG
	318	printf("Got command: %d\n", command);
	319	#endif
	320	break;
	321	case 'h':
	322	housecode = parse_housecode(optarg);
	323	if (!housecode) {
	324	fprintf(stderr, "Can't parse housecode!\n");
	325	exit(EXIT_FAILURE);
	326	}
	327	#ifdef DEBUG
	328	printf("Got housecode: 0x%02x%02x\n", housecode[0], housecode[1]);
	329	#endif
	330	break;
	331	case 'a':
	332	addr = strtoul(optarg, &ep, 10);
	333	if (*ep != '\0') {
	334	fprintf(stderr, "Can't parse address!\n");
	335	exit(EXIT_FAILURE);
	336	}
	337	#ifdef DEBUG
	338	printf("Got address: 0x%02x\n", addr);
	339	#endif
	340	break;
	341	case 'r':
	342	repeat = strtoul(optarg, &ep, 10);
	343	if (*ep != '\0') {
	344	fprintf(stderr, "Can't parse repeat!\n");
	345	exit(EXIT_FAILURE);
	346	}
	347	#ifdef DEBUG
	348	printf("Got repeat: %d\n", repeat);
	349	#endif
	350	break;
	351	case 'e':
	352	extension = strtoul(optarg, &ep, 16);
	353	if (*ep != '\0') {
	354	fprintf(stderr, "Can't parse extension!\n");
	355	exit(EXIT_FAILURE);
	356	}
	357	#ifdef DEBUG
358	printf("Got extension: %d\n", extension);
359	#endif
360	break;
361	case ':':
362	case '?':
363	default:
364	syntax(argv[0]);
365	exit(EXIT_FAILURE);
366	break;
367	}
a06d3b72 MG	368	}
a06d3b72 MG	369
23892620 MG	370	switch(action) {
	371	case REQUEST_FIRMWARE:
	372	send_data[1] = 0x01;
	373	send_data[2] = 0xf0;
	374	printf("Requesting firmware version...\n");
	375
	376	break;
	377	case ABORT_LONG_PRESS:
	378	send_data[1] = 0x01;
	379	send_data[2] = 0xf3;
	380	printf("Aborting long press...\n");
	381
	382	break;
	383	case SEND_COMMAND:
	384	if (housecode == NULL) {
	385	fprintf(stderr, "housecode needed!\n");
	386	exit(EXIT_FAILURE);
	387	}
	388	if (addr == -1) {
	389	fprintf(stderr, "address needed!\n");
	390	exit(EXIT_FAILURE);
	391	}
	392
	393	if (repeat) {
	394	send_data[1] = 0x07;
	395	send_data[2] = 0xf2;
	396	send_data[8] = repeat;
	397	printf("Sending 0x%02x 0x%02x to address %d (hc: 0x%02x%02x) (repeated %d times)\n",
	398	command, extension, addr,
	399	housecode[0], housecode[1],
	400	repeat);
	401	} else {
	402	send_data[1] = 0x06;
	403	send_data[2] = 0xf1;
	404	printf("Sending 0x%02x 0x%02x to address %d (hc: 0x%02x%02x)\n",
	405	command, extension, addr,
	406	housecode[0], housecode[1]);
	407	}
	408	send_data[3] = housecode[0];
	409	send_data[4] = housecode[1];
	410	send_data[5] = addr;
	411	send_data[6] = command;
	412	send_data[7] = extension;
	413
	414	break;
	415	case NO_ACTION:
	416	default:
	417	fprintf(stderr, "No action specified!\n\n");
	418	syntax(argv[0]);
	419	exit(EXIT_FAILURE);
	420	break;
a06d3b72 MG	421	}
	422
	423	err = libusb_init(NULL);
	424	if (err != 0) {
	425	fprintf(stderr, "Can't initialize libusb: %s\n", usb_strerror(err));
	426	return EXIT_FAILURE;
	427	}
	428
	429	devh = fs20pcs_find();
	430	if (!devh) {
	431	fprintf(stderr, "Can't find/open fs20pcs!\n");
	432	return EXIT_FAILURE;
	433	}
	434
	435	if (fs20pcs_send(devh, send_data) == 0) {
	436	fprintf(stderr, "Can't communicate with fs20pcs!\n");
	437	return EXIT_FAILURE;
	438	}
	439
	440	libusb_close(NULL);
	441
	442	return EXIT_SUCCESS;
	443	}