[fs20pcs] / fs20pcs.c

/* FS20PCS libusb-driver
 *
 * Copyright (c) 2013 Michael Gernoth <michael@gernoth.net>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

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

#define USB_TIMEOUT		10000

#define ID_VENDOR	0x18ef
#define ID_PRODUCT	0xe015

#define EXT_TO_SEC(ext) ((1 << ((ext & 0xf0) >> 4)) * (ext & 0x0f) * 0.25)

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, USB_TIMEOUT);
	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, USB_TIMEOUT);
	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 in hex (1234, 0x1234) or ELV (12341234) format!\n");
			return NULL;
			break;
	}

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

	return housecode;
}

int parse_addr(char *ad)
{
	int addr = -1;
	char ad_fixed[5];
	char *ep;
	unsigned long val;
	int i;

	if (ad == NULL)
		return -1;

	switch(strlen(ad)) {
		case 4:
			if (strncmp(ad, "0x", 2)) {
				memset(ad_fixed, 0, sizeof(ad_fixed));
				for (i = 0; i < 4; i++) {
					if ((ad[i] < '1') || (ad[i] > '4')) {
						fprintf(stderr, "Not a valid ELV address: %s\n", ad);
						return -1;
					}
					ad_fixed[i] = ad[i] - 1;
					val = strtoul(ad_fixed, &ep, 4);

					if (*ep != '\0') {
						fprintf(stderr, "Can't parse fixed ELV housecode: %s\n", ad_fixed);
						return -1;
					}
				}

				break;
			}
		case 2:
			val = strtoul(ad, &ep, 16);
			if (*ep != '\0') {
				fprintf(stderr, "Not a 1 byte hexstring: %s\n", ad);
				return -1;
			}
			break;
		default:
			fprintf(stderr, "Address has to be in hex (01, 0x01) or ELV (1112) format!\n");
			return -1;
			break;
	}

	addr = val & 0xff;

	return addr;
}

int parse_command(char *cmd)
{
	int command = -1;
	char *ep;
	unsigned long val;

	if (cmd == NULL)
		return -1;

	if (!strcasecmp(cmd, "off")) {
		command = 0x00;
	} else if (!strcasecmp(cmd, "on")) {
		command = 0x11;
	} else if (!strcasecmp(cmd, "toggle")) {
		command = 0x12;
	} else if (!strcasecmp(cmd, "dimup")) {
		command = 0x13;
	} else if (!strcasecmp(cmd, "dimdown")) {
		command = 0x14;
	} else if (!strcasecmp(cmd, "on-for-timer")) {
		command = 0x39;
	} else {
		val = strtoul(cmd, &ep, 16);
		if (*ep != '\0') {
			fprintf(stderr, "Not a 1 byte hexstring or alias: %s\n", cmd);
			return -1;
		}

		command = val & 0xff;
	}

	return command;
}

int parse_extension(char *ext)
{
	int extension = -1;
	char *ep;

	if (ext == NULL)
		return -1;

	if ((ext[strlen(ext)-1] == 's') ||
	    (ext[strlen(ext)-1] == 'S')) {
	    	double t;
		double diff = 1;
		uint8_t high = 0;
		uint8_t low = 0;
	    	uint8_t i;

		t = strtod(ext, &ep);
		if ((*ep != 's') && (*ep != 'S')) {
			fprintf(stderr, "Not a valid time in seconds: %s\n", ext);
			return -1;
		}

		/* time = 2^(high nibble) * (low nibble) * 0.25 , high may only be 12 */
		t /= 0.25;
#ifdef DEBUG
		printf("t: %f\n", t);
#endif

		for(i = 1; i <= 0xf; i++) {
			double h;
			double l;
			uint8_t i_l;
			double d;

#ifdef DEBUG
			printf("i: 0x%01x\n", i);
#endif

			h = t / i;
#ifdef DEBUG
			printf("h: %f\n", h);
#endif

			l = log2(h);
#ifdef DEBUG
			printf("l: %f\n", l);
#endif

			i_l = l;
			if (i_l > 12)
				i_l = 12;

			d = fabs(l - i_l);

#ifdef DEBUG
			printf("d: %f\n", d);
#endif

			if (d < diff) {
#ifdef DEBUG
				printf("Current best match!\n");
#endif
				diff = d;
				high = i_l;
				low = i;
			}
		}

#ifdef DEBUG
		printf("Got: %f, high: %01x, low: %01x\n", t, high, low);
#endif

		if ((high == 0) && (low == 0)) {
			fprintf(stderr, "Can't find extension byte for %s!\n", ext);
			return -1;
		}

		extension = ((high & 0xf) << 4) | (low & 0xf);
	} else {
		unsigned long val;

		val = strtoul(ext, &ep, 16);
		if (*ep != '\0') {
			fprintf(stderr, "Not a 1 byte hexstring or time: %s\n", ext);
			return -1;
		}

		extension = val & 0xff;
	}

	return extension;
}

void syntax(char *prog)
{
	fprintf(stderr, "Syntax: %s options\n\n", prog);
	fprintf(stderr, "Possible options:\n");
	fprintf(stderr, "\t-V\t\trequest firmware-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 options need an housecode:\n");
	fprintf(stderr, "\t-a [ELV|hex]\tdestination address\n");
	fprintf(stderr, "\t-s [hex|alias]\tsend command byte\n");
	fprintf(stderr, "\t-e [hex|time]\textension byte for command or time in seconds (e.g. 10s)\n");
	fprintf(stderr, "\t-r n\t\trepeat sending n times\n");
	fprintf(stderr, "\nCommand bytes (without extension byte):\n");
	fprintf(stderr, "hex\t\talias\tdescription\n");
	fprintf(stderr, "0x00\t\toff\tswitch off\n");
	fprintf(stderr, "0x01-0x10\t\tswitch on dimmed (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%)\n");
	fprintf(stderr, "0x11\t\ton\tswitch on\n");
	fprintf(stderr, "0x12\t\ttoggle\ttoggle\n");
	fprintf(stderr, "0x13\t\tdimup\tdimup\n");
	fprintf(stderr, "0x14\t\tdimdown\tdimdown\n");
	fprintf(stderr, "0x15\t\t\tdimup, pause, dimdown, pause, ...\n");
	fprintf(stderr, "0x16\t\t\tstart/stop programming internal timer\n");
	fprintf(stderr, "0x17\t\t\tlearn housecode/address\n");
	fprintf(stderr, "0x18\t\t\toff for internal timer, then back on with current level\n");
	fprintf(stderr, "0x19\t\t\ton (100%%) for internal timer, then off\n");
	fprintf(stderr, "0x1a\t\t\ton (old level) for internal timer, then off\n");
	fprintf(stderr, "0x1b\t\t\tfactory reset\n");
	fprintf(stderr, "0x1e\t\t\ton (100%%) for internal timer, then old level\n");
	fprintf(stderr, "0x1f\t\t\ton (old level) for internal timer, then old state\n");
	fprintf(stderr, "\nCommand bytes (with timer as extension byte):\n");
	fprintf(stderr, "hex\t\talias\tdescription\n");
	fprintf(stderr, "0x20\t\t\tdim down to off while timer is running\n");
	fprintf(stderr, "0x21-0x30\t\tdim to (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%) while timer is running\n");
	fprintf(stderr, "0x31\t\t\tdim to last level while timer is running\n");
	fprintf(stderr, "0x32\t\t\tdim to off, then after timer dim to off\n");
	fprintf(stderr, "0x33\t\t\tdimup now and switch off after timer\n");
	fprintf(stderr, "0x34\t\t\tdimdown now and switch off after timer\n");
	fprintf(stderr, "0x35\t\t\tdimup or dimdown (toggle) and switch off after timer\n");
	fprintf(stderr, "0x36\t\t\tprogram internal timer\n");
	fprintf(stderr, "0x38\t\t\toff for timer, then back on with current level\n");
	fprintf(stderr, "0x39\ton-for-timer\ton (100%%) for timer, then off\n");
	fprintf(stderr, "0x3a\t\t\ton (old level) for timer, then off\n");
	fprintf(stderr, "0x3c\t\t\tprogram internal ramp-up-time\n");
	fprintf(stderr, "0x3d\t\t\tprogram internal ramp-down-time\n");
	fprintf(stderr, "0x3e\t\t\ton (100%%) for timer, then old level\n");
	fprintf(stderr, "0x3f\t\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;
	int command = -1;
	int extension = 0;
	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 = parse_command(optarg);
				if (command == -1) {
					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 = parse_addr(optarg);
				if (addr == -1) {
					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 = parse_extension(optarg);
				if (extension == -1) {
					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 (%.2fs) to address %d (hc: 0x%02x%02x) (repeated %d times)\n",
					command, extension, EXT_TO_SEC(extension), addr,
					housecode[0], housecode[1],
					repeat);
			} else {
				send_data[1] = 0x06;
				send_data[2] = 0xf1;
				printf("Sending 0x%02x 0x%02x (%.2fs) to address %d (hc: 0x%02x%02x)\n",
					command, extension, EXT_TO_SEC(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
f54ebf89 MG	1	/* FS20PCS libusb-driver
	2	*
	3	* Copyright (c) 2013 Michael Gernoth <michael@gernoth.net>
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining a copy
	6	* of this software and associated documentation files (the "Software"), to
	7	* deal in the Software without restriction, including without limitation the
	8	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	9	* sell copies of the Software, and to permit persons to whom the Software is
	10	* furnished to do so, subject to the following conditions:
	11	*
	12	* The above copyright notice and this permission notice shall be included in
	13	* all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	21	* IN THE SOFTWARE.
	22	*/
	23
a06d3b72 MG	24	#include <string.h>
	25	#include <stdio.h>
	26	#include <stdint.h>
	27	#include <unistd.h>
	28	#include <stdlib.h>
f6d105d6	29	#include <math.h>
a06d3b72 MG	30	#include <libusb-1.0/libusb.h>
	31
	32	#define USB_TIMEOUT 10000
	33
	34	#define ID_VENDOR 0x18ef
	35	#define ID_PRODUCT 0xe015
	36
f6d105d6 MG	37	#define EXT_TO_SEC(ext) ((1 << ((ext & 0xf0) >> 4)) * (ext & 0x0f) * 0.25)
f6d105d6 MG	38
23892620 MG	39	extern char *optarg;
23892620 MG	40
a06d3b72 MG	41	/* Not in all libusb-1.0 versions, so we have to roll our own :-( */
	42	static char * usb_strerror(int e)
	43	{
	44	static char unknerr[256];
	45
	46	switch (e) {
	47	case LIBUSB_SUCCESS:
	48	return "Success";
	49	case LIBUSB_ERROR_IO:
	50	return "Input/output error";
	51	case LIBUSB_ERROR_INVALID_PARAM:
	52	return "Invalid parameter";
	53	case LIBUSB_ERROR_ACCESS:
	54	return "Access denied (insufficient permissions)";
	55	case LIBUSB_ERROR_NO_DEVICE:
	56	return "No such device (it may have been disconnected)";
	57	case LIBUSB_ERROR_NOT_FOUND:
	58	return "Entity not found";
	59	case LIBUSB_ERROR_BUSY:
	60	return "Resource busy";
	61	case LIBUSB_ERROR_TIMEOUT:
	62	return "Operation timed out";
	63	case LIBUSB_ERROR_OVERFLOW:
	64	return "Overflow";
	65	case LIBUSB_ERROR_PIPE:
	66	return "Pipe error";
	67	case LIBUSB_ERROR_INTERRUPTED:
	68	return "System call interrupted (perhaps due to signal)";
	69	case LIBUSB_ERROR_NO_MEM:
	70	return "Insufficient memory";
	71	case LIBUSB_ERROR_NOT_SUPPORTED:
	72	return "Operation not supported or unimplemented on this platform";
	73	case LIBUSB_ERROR_OTHER:
	74	return "Other error";
	75	};
	76	snprintf(unknerr, sizeof(unknerr), "Unknown error code %d / 0x%02x", e, e);
	77	return unknerr;
	78	}
	79
	80	libusb_device_handle *fs20pcs_find() {
	81	libusb_device_handle *devh = NULL;
	82	libusb_device **list;
	83	ssize_t cnt;
	84	ssize_t i;
	85	int err;
	86
	87	cnt = libusb_get_device_list(NULL, &list);
	88	if (cnt < 0) {
	89	fprintf(stderr, "Can't get USB device list: %d\n", (int)cnt);
	90	return NULL;
	91	}
	92
	93	for (i = 0; i < cnt; i++){
	94	struct libusb_device_descriptor desc;
	95
	96	err = libusb_get_device_descriptor(list[i], &desc);
	97	if (err)
	98	continue;
	99
	100	if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
	101	libusb_device *dev = list[i];
	102
	103	err = libusb_open(dev, &devh);
	104	if (err) {
105	fprintf(stderr, "Can't open device: %s\n", usb_strerror(err));
106	return NULL;
107	}
108
109	err = libusb_detach_kernel_driver(devh, 0);
110	if ((err != 0) && (err != LIBUSB_ERROR_NOT_FOUND)) {
111	fprintf(stderr, "Can't detach kernel driver: %s\n", usb_strerror(err));
112	return NULL;
113	}
114
115	err = libusb_claim_interface(devh, 0);
116	if ((err != 0)) {
117	fprintf(stderr, "Can't claim interface: %s\n", usb_strerror(err));
118	return NULL;
119	}
120
121	return devh;
122	}
123
124	}
125
126	return NULL;
127	}
128
129	int fs20pcs_send(libusb_device_handle devh, unsigned char send_data)
130	{
131	unsigned char recv_data[5] = {0x00, 0x00, 0x00, 0x00, 0x00};
132	int err;
133	int cnt;
134	int i;
2b257333	135	int ret;
a06d3b72	136
f6d105d6	137	err = libusb_interrupt_transfer(devh, 0x01, send_data, 11, &cnt, USB_TIMEOUT);
a06d3b72 MG	138	if (err) {
	139	fprintf(stderr, "Can't send data: %s\n", usb_strerror(err));
	140	return 0;
	141	}
	142
f6d105d6	143	err = libusb_interrupt_transfer(devh, 0x81, recv_data, sizeof(recv_data), &cnt, USB_TIMEOUT);
a06d3b72 MG	144	if (err) {
	145	fprintf(stderr, "Can't receive data: %s\n", usb_strerror(err));
	146	return 0;
	147	}
	148
2b257333 MG	149	if ((recv_data[0] != 0x02) \|\|
	150	(recv_data[1] != 0x03) \|\|
	151	(recv_data[2] != 0xa0)) {
	152	fprintf(stderr, "Unexpected response: ");
	153	for (i = 0; i < cnt; i++) {
	154	fprintf(stderr, "0x%02x ", recv_data[i]);
	155	}
	156	fprintf(stderr, "\n");
	157
	158	return 0;
	159	}
	160
	161	ret = 1;
	162
	163	switch(recv_data[3]) {
	164	case 0x00:
	165	printf("Success");
	166	break;
	167	case 0x01:
23892620	168	printf("Firmware: V%d.%d", ((recv_data[4] & 0xf0) >> 4) & 0x0f, recv_data[4] & 0x0f);
2b257333 MG	169	break;
	170	case 0x02:
	171	printf("Unknown command");
	172	ret = 0;
	173	break;
	174	case 0x03:
	175	printf("Wrong length");
	176	ret = 0;
	177	break;
	178	case 0x04:
	179	printf("Aborted sending long press");
	180	break;
	181	case 0x05:
	182	printf("Nothing to stop");
	183	break;
	184	default:
	185	printf("Unknown response: 0x%02x 0x%02x", recv_data[3], recv_data[4]);
	186	ret = 0;
	187	break;
a06d3b72	188	}
2b257333	189
a06d3b72 MG	190	printf("\n");
a06d3b72 MG	191
2b257333	192	return ret;
a06d3b72 MG	193	}
a06d3b72 MG	194
23892620 MG	195	unsigned char parse_housecode(char hc)
	196	{
	197	static unsigned char housecode[2];
	198	char hc_fixed[9];
	199	char *ep;
	200	unsigned long val;
	201	int i;
	202
	203	if (hc == NULL)
	204	return NULL;
	205
	206	memset(housecode, 0, sizeof(housecode));
	207
	208	switch(strlen(hc)) {
	209	case 6:
	210	if (strncmp(hc, "0x", 2)) {
	211	fprintf(stderr, "Not a 2 byte hexstring: %s\n", hc);
	212	return NULL;
	213	}
	214	case 4:
	215	val = strtoul(hc, &ep, 16);
	216	if (*ep != '\0') {
	217	fprintf(stderr, "Not a 2 byte hexstring: %s\n", hc);
	218	return NULL;
	219	}
	220	break;
	221	case 8:
	222	memset(hc_fixed, 0, sizeof(hc_fixed));
	223	for (i = 0; i < 8; i++) {
	224	if ((hc[i] < '1') \|\| (hc[i] > '4')) {
	225	fprintf(stderr, "Not a valid ELV housecode: %s\n", hc);
	226	return NULL;
	227	}
	228	hc_fixed[i] = hc[i] - 1;
	229	val = strtoul(hc_fixed, &ep, 4);
	230
	231	if (*ep != '\0') {
	232	fprintf(stderr, "Can't parse fixed ELV housecode: %s\n", hc_fixed);
	233	return NULL;
	234	}
	235	}
	236	break;
	237	default:
6c7fff3b	238	fprintf(stderr, "Housecode has to be in hex (1234, 0x1234) or ELV (12341234) format!\n");
23892620 MG	239	return NULL;
	240	break;
	241	}
	242
	243	housecode[0] = (val & 0xff00) >> 8;
	244	housecode[1] = (val & 0xff);
	245
	246	return housecode;
	247	}
	248
6c7fff3b MG	249	int parse_addr(char *ad)
	250	{
	251	int addr = -1;
	252	char ad_fixed[5];
	253	char *ep;
	254	unsigned long val;
	255	int i;
	256
	257	if (ad == NULL)
	258	return -1;
	259
	260	switch(strlen(ad)) {
	261	case 4:
	262	if (strncmp(ad, "0x", 2)) {
	263	memset(ad_fixed, 0, sizeof(ad_fixed));
	264	for (i = 0; i < 4; i++) {
	265	if ((ad[i] < '1') \|\| (ad[i] > '4')) {
	266	fprintf(stderr, "Not a valid ELV address: %s\n", ad);
	267	return -1;
	268	}
	269	ad_fixed[i] = ad[i] - 1;
	270	val = strtoul(ad_fixed, &ep, 4);
	271
	272	if (*ep != '\0') {
	273	fprintf(stderr, "Can't parse fixed ELV housecode: %s\n", ad_fixed);
	274	return -1;
	275	}
	276	}
	277
	278	break;
	279	}
	280	case 2:
	281	val = strtoul(ad, &ep, 16);
	282	if (*ep != '\0') {
	283	fprintf(stderr, "Not a 1 byte hexstring: %s\n", ad);
	284	return -1;
	285	}
	286	break;
	287	default:
	288	fprintf(stderr, "Address has to be in hex (01, 0x01) or ELV (1112) format!\n");
	289	return -1;
	290	break;
	291	}
	292
	293	addr = val & 0xff;
	294
	295	return addr;
	296	}
	297
4636e355 MG	298	int parse_command(char *cmd)
	299	{
	300	int command = -1;
	301	char *ep;
	302	unsigned long val;
	303
	304	if (cmd == NULL)
	305	return -1;
	306
	307	if (!strcasecmp(cmd, "off")) {
	308	command = 0x00;
	309	} else if (!strcasecmp(cmd, "on")) {
	310	command = 0x11;
	311	} else if (!strcasecmp(cmd, "toggle")) {
	312	command = 0x12;
	313	} else if (!strcasecmp(cmd, "dimup")) {
	314	command = 0x13;
	315	} else if (!strcasecmp(cmd, "dimdown")) {
	316	command = 0x14;
	317	} else if (!strcasecmp(cmd, "on-for-timer")) {
	318	command = 0x39;
	319	} else {
	320	val = strtoul(cmd, &ep, 16);
	321	if (*ep != '\0') {
	322	fprintf(stderr, "Not a 1 byte hexstring or alias: %s\n", cmd);
	323	return -1;
	324	}
	325
	326	command = val & 0xff;
	327	}
	328
	329	return command;
	330	}
	331
f6d105d6 MG	332	int parse_extension(char *ext)
	333	{
	334	int extension = -1;
	335	char *ep;
	336
	337	if (ext == NULL)
	338	return -1;
	339
	340	if ((ext[strlen(ext)-1] == 's') \|\|
	341	(ext[strlen(ext)-1] == 'S')) {
	342	double t;
	343	double diff = 1;
	344	uint8_t high = 0;
	345	uint8_t low = 0;
	346	uint8_t i;
	347
3ca85394	348	t = strtod(ext, &ep);
f6d105d6 MG	349	if ((ep != 's') && (ep != 'S')) {
	350	fprintf(stderr, "Not a valid time in seconds: %s\n", ext);
	351	return -1;
	352	}
	353
	354	/* time = 2^(high nibble) * (low nibble) * 0.25 , high may only be 12 */
	355	t /= 0.25;
	356	#ifdef DEBUG
	357	printf("t: %f\n", t);
	358	#endif
	359
	360	for(i = 1; i <= 0xf; i++) {
	361	double h;
	362	double l;
	363	uint8_t i_l;
	364	double d;
	365
	366	#ifdef DEBUG
	367	printf("i: 0x%01x\n", i);
	368	#endif
	369
	370	h = t / i;
	371	#ifdef DEBUG
	372	printf("h: %f\n", h);
	373	#endif
	374
	375	l = log2(h);
	376	#ifdef DEBUG
	377	printf("l: %f\n", l);
	378	#endif
	379
	380	i_l = l;
	381	if (i_l > 12)
	382	i_l = 12;
	383
3ca85394	384	d = fabs(l - i_l);
f6d105d6 MG	385
	386	#ifdef DEBUG
	387	printf("d: %f\n", d);
	388	#endif
	389
	390	if (d < diff) {
	391	#ifdef DEBUG
	392	printf("Current best match!\n");
	393	#endif
	394	diff = d;
cbd3f0ba	395	high = i_l;
f6d105d6 MG	396	low = i;
	397	}
	398	}
	399
	400	#ifdef DEBUG
	401	printf("Got: %f, high: %01x, low: %01x\n", t, high, low);
	402	#endif
	403
	404	if ((high == 0) && (low == 0)) {
	405	fprintf(stderr, "Can't find extension byte for %s!\n", ext);
	406	return -1;
	407	}
	408
	409	extension = ((high & 0xf) << 4) \| (low & 0xf);
	410	} else {
	411	unsigned long val;
	412
	413	val = strtoul(ext, &ep, 16);
	414	if (*ep != '\0') {
	415	fprintf(stderr, "Not a 1 byte hexstring or time: %s\n", ext);
	416	return -1;
	417	}
	418
	419	extension = val & 0xff;
	420	}
	421
	422	return extension;
	423	}
	424
23892620 MG	425	void syntax(char *prog)
	426	{
	427	fprintf(stderr, "Syntax: %s options\n\n", prog);
	428	fprintf(stderr, "Possible options:\n");
f4f53d0f	429	fprintf(stderr, "\t-V\t\trequest firmware-version\n");
23892620 MG	430	fprintf(stderr, "\t-x\t\tabort sending long press\n");
23892620 MG	431	fprintf(stderr, "\t-h [ELV\|hex]\thousecode in ELV- or hex-notation\n");
11007e95	432	fprintf(stderr, "The following options need an housecode:\n");
4636e355 MG	433	fprintf(stderr, "\t-a [ELV\|hex]\tdestination address\n");
4636e355 MG	434	fprintf(stderr, "\t-s [hex\|alias]\tsend command byte\n");
f6d105d6	435	fprintf(stderr, "\t-e [hex\|time]\textension byte for command or time in seconds (e.g. 10s)\n");
23892620 MG	436	fprintf(stderr, "\t-r n\t\trepeat sending n times\n");
23892620 MG	437	fprintf(stderr, "\nCommand bytes (without extension byte):\n");
4636e355 MG	438	fprintf(stderr, "hex\t\talias\tdescription\n");
	439	fprintf(stderr, "0x00\t\toff\tswitch off\n");
	440	fprintf(stderr, "0x01-0x10\t\tswitch on dimmed (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%)\n");
	441	fprintf(stderr, "0x11\t\ton\tswitch on\n");
	442	fprintf(stderr, "0x12\t\ttoggle\ttoggle\n");
	443	fprintf(stderr, "0x13\t\tdimup\tdimup\n");
	444	fprintf(stderr, "0x14\t\tdimdown\tdimdown\n");
	445	fprintf(stderr, "0x15\t\t\tdimup, pause, dimdown, pause, ...\n");
	446	fprintf(stderr, "0x16\t\t\tstart/stop programming internal timer\n");
	447	fprintf(stderr, "0x17\t\t\tlearn housecode/address\n");
	448	fprintf(stderr, "0x18\t\t\toff for internal timer, then back on with current level\n");
	449	fprintf(stderr, "0x19\t\t\ton (100%%) for internal timer, then off\n");
	450	fprintf(stderr, "0x1a\t\t\ton (old level) for internal timer, then off\n");
	451	fprintf(stderr, "0x1b\t\t\tfactory reset\n");
	452	fprintf(stderr, "0x1e\t\t\ton (100%%) for internal timer, then old level\n");
	453	fprintf(stderr, "0x1f\t\t\ton (old level) for internal timer, then old state\n");
23892620	454	fprintf(stderr, "\nCommand bytes (with timer as extension byte):\n");
4636e355 MG	455	fprintf(stderr, "hex\t\talias\tdescription\n");
	456	fprintf(stderr, "0x20\t\t\tdim down to off while timer is running\n");
	457	fprintf(stderr, "0x21-0x30\t\tdim to (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%) while timer is running\n");
	458	fprintf(stderr, "0x31\t\t\tdim to last level while timer is running\n");
	459	fprintf(stderr, "0x32\t\t\tdim to off, then after timer dim to off\n");
	460	fprintf(stderr, "0x33\t\t\tdimup now and switch off after timer\n");
	461	fprintf(stderr, "0x34\t\t\tdimdown now and switch off after timer\n");
	462	fprintf(stderr, "0x35\t\t\tdimup or dimdown (toggle) and switch off after timer\n");
	463	fprintf(stderr, "0x36\t\t\tprogram internal timer\n");
	464	fprintf(stderr, "0x38\t\t\toff for timer, then back on with current level\n");
	465	fprintf(stderr, "0x39\ton-for-timer\ton (100%%) for timer, then off\n");
	466	fprintf(stderr, "0x3a\t\t\ton (old level) for timer, then off\n");
	467	fprintf(stderr, "0x3c\t\t\tprogram internal ramp-up-time\n");
	468	fprintf(stderr, "0x3d\t\t\tprogram internal ramp-down-time\n");
	469	fprintf(stderr, "0x3e\t\t\ton (100%%) for timer, then old level\n");
	470	fprintf(stderr, "0x3f\t\t\ton (old level) for timer, then old state\n");
23892620 MG	471	};
	472
	473	enum {
	474	NO_ACTION,
	475	REQUEST_FIRMWARE,
	476	SEND_COMMAND,
	477	ABORT_LONG_PRESS
	478	};
	479
	480	#define DUPLICATE_ACTION if (action != NO_ACTION) { \
	481	fprintf(stderr, "duplicate action specified!\n"); \
	482	exit(EXIT_FAILURE); }
	483
a06d3b72 MG	484	int main(int argc, char **argv)
	485	{
	486	unsigned char send_data[11];
23892620	487	unsigned char *housecode = NULL;
a06d3b72	488	libusb_device_handle *devh = NULL;
23892620	489	char *ep;
a06d3b72	490	int err;
23892620 MG	491	int opt;
23892620 MG	492	int action = NO_ACTION;
4636e355	493	int command = -1;
f6d105d6	494	int extension = 0;
23892620 MG	495	uint8_t repeat = 0;
23892620 MG	496	int addr = -1;
a06d3b72	497
23892620 MG	498	memset(send_data, 0, sizeof(send_data));
	499
	500	send_data[0] = 0x01;
	501
	502	while ((opt = getopt(argc, argv, "Vxs:h:a:r:e:")) != -1) {
	503	switch(opt) {
	504	case 'V':
	505	DUPLICATE_ACTION;
	506	action = REQUEST_FIRMWARE;
	507	break;
	508	case 'x':
	509	DUPLICATE_ACTION;
	510	action = ABORT_LONG_PRESS;
	511	break;
	512	case 's':
	513	DUPLICATE_ACTION;
	514	action = SEND_COMMAND;
	515
4636e355 MG	516	command = parse_command(optarg);
4636e355 MG	517	if (command == -1) {
23892620 MG	518	fprintf(stderr, "Can't parse command!\n");
	519	exit(EXIT_FAILURE);
	520	}
	521	#ifdef DEBUG
	522	printf("Got command: %d\n", command);
	523	#endif
	524	break;
	525	case 'h':
	526	housecode = parse_housecode(optarg);
	527	if (!housecode) {
	528	fprintf(stderr, "Can't parse housecode!\n");
	529	exit(EXIT_FAILURE);
	530	}
	531	#ifdef DEBUG
	532	printf("Got housecode: 0x%02x%02x\n", housecode[0], housecode[1]);
	533	#endif
	534	break;
	535	case 'a':
6c7fff3b MG	536	addr = parse_addr(optarg);
6c7fff3b MG	537	if (addr == -1) {
23892620 MG	538	fprintf(stderr, "Can't parse address!\n");
	539	exit(EXIT_FAILURE);
	540	}
	541	#ifdef DEBUG
	542	printf("Got address: 0x%02x\n", addr);
	543	#endif
	544	break;
	545	case 'r':
	546	repeat = strtoul(optarg, &ep, 10);
	547	if (*ep != '\0') {
	548	fprintf(stderr, "Can't parse repeat!\n");
	549	exit(EXIT_FAILURE);
	550	}
	551	#ifdef DEBUG
	552	printf("Got repeat: %d\n", repeat);
	553	#endif
	554	break;
	555	case 'e':
f6d105d6 MG	556	extension = parse_extension(optarg);
f6d105d6 MG	557	if (extension == -1) {
23892620 MG	558	fprintf(stderr, "Can't parse extension!\n");
	559	exit(EXIT_FAILURE);
	560	}
	561	#ifdef DEBUG
	562	printf("Got extension: %d\n", extension);
	563	#endif
	564	break;
	565	case ':':
	566	case '?':
	567	default:
	568	syntax(argv[0]);
	569	exit(EXIT_FAILURE);
	570	break;
	571	}
a06d3b72 MG	572	}
a06d3b72 MG	573
23892620 MG	574	switch(action) {
	575	case REQUEST_FIRMWARE:
	576	send_data[1] = 0x01;
	577	send_data[2] = 0xf0;
	578	printf("Requesting firmware version...\n");
	579
	580	break;
	581	case ABORT_LONG_PRESS:
	582	send_data[1] = 0x01;
	583	send_data[2] = 0xf3;
	584	printf("Aborting long press...\n");
	585
	586	break;
	587	case SEND_COMMAND:
	588	if (housecode == NULL) {
	589	fprintf(stderr, "housecode needed!\n");
	590	exit(EXIT_FAILURE);
	591	}
	592	if (addr == -1) {
	593	fprintf(stderr, "address needed!\n");
	594	exit(EXIT_FAILURE);
	595	}
	596
	597	if (repeat) {
	598	send_data[1] = 0x07;
	599	send_data[2] = 0xf2;
	600	send_data[8] = repeat;
f6d105d6 MG	601	printf("Sending 0x%02x 0x%02x (%.2fs) to address %d (hc: 0x%02x%02x) (repeated %d times)\n",
f6d105d6 MG	602	command, extension, EXT_TO_SEC(extension), addr,
23892620 MG	603	housecode[0], housecode[1],
	604	repeat);
	605	} else {
	606	send_data[1] = 0x06;
	607	send_data[2] = 0xf1;
f6d105d6 MG	608	printf("Sending 0x%02x 0x%02x (%.2fs) to address %d (hc: 0x%02x%02x)\n",
f6d105d6 MG	609	command, extension, EXT_TO_SEC(extension), addr,
23892620 MG	610	housecode[0], housecode[1]);
	611	}
	612	send_data[3] = housecode[0];
	613	send_data[4] = housecode[1];
	614	send_data[5] = addr;
	615	send_data[6] = command;
	616	send_data[7] = extension;
	617
	618	break;
	619	case NO_ACTION:
	620	default:
	621	fprintf(stderr, "No action specified!\n\n");
	622	syntax(argv[0]);
	623	exit(EXIT_FAILURE);
	624	break;
a06d3b72 MG	625	}
	626
	627	err = libusb_init(NULL);
	628	if (err != 0) {
	629	fprintf(stderr, "Can't initialize libusb: %s\n", usb_strerror(err));
	630	return EXIT_FAILURE;
	631	}
	632
	633	devh = fs20pcs_find();
	634	if (!devh) {
	635	fprintf(stderr, "Can't find/open fs20pcs!\n");
	636	return EXIT_FAILURE;
	637	}
	638
	639	if (fs20pcs_send(devh, send_data) == 0) {
	640	fprintf(stderr, "Can't communicate with fs20pcs!\n");
	641	return EXIT_FAILURE;
	642	}
	643
	644	libusb_close(NULL);
	645
	646	return EXIT_SUCCESS;
	647	}