git.zerfleddert.de Git - fs20pcs/blob - fs20pcs.c

   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
  13 extern char *optarg;
  14
  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;
 109         int ret;
 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
 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:
 142                         printf("Firmware: V%d.%d", ((recv_data[4] & 0xf0) >> 4) & 0x0f, recv_data[4] & 0x0f);
 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;
 162         }
 163
 164         printf("\n");
 165
 166         return ret;
 167 }
 168
 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 firmware-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
 280 int main(int argc, char **argv)
 281 {
 282         unsigned char send_data[11];
 283         unsigned char *housecode = NULL;
 284         libusb_device_handle *devh = NULL;
 285         char *ep;
 286         int err;
 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;
 293
 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                 }
 368         }
 369
 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;
 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 }