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 in hex (1234, 0x1234) or ELV (12341234) format!\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 int parse_addr(char *ad)
 224 {
 225         int addr = -1;
 226         char ad_fixed[5];
 227         char *ep;
 228         unsigned long val;
 229         int i;
 230
 231         if (ad == NULL)
 232                 return -1;
 233
 234         switch(strlen(ad)) {
 235                 case 4:
 236                         if (strncmp(ad, "0x", 2)) {
 237                                 memset(ad_fixed, 0, sizeof(ad_fixed));
 238                                 for (i = 0; i < 4; i++) {
 239                                         if ((ad[i] < '1') || (ad[i] > '4')) {
 240                                                 fprintf(stderr, "Not a valid ELV address: %s\n", ad);
 241                                                 return -1;
 242                                         }
 243                                         ad_fixed[i] = ad[i] - 1;
 244                                         val = strtoul(ad_fixed, &ep, 4);
 245
 246                                         if (*ep != '\0') {
 247                                                 fprintf(stderr, "Can't parse fixed ELV housecode: %s\n", ad_fixed);
 248                                                 return -1;
 249                                         }
 250                                 }
 251
 252                                 break;
 253                         }
 254                 case 2:
 255                         val = strtoul(ad, &ep, 16);
 256                         if (*ep != '\0') {
 257                                 fprintf(stderr, "Not a 1 byte hexstring: %s\n", ad);
 258                                 return -1;
 259                         }
 260                         break;
 261                 default:
 262                         fprintf(stderr, "Address has to be in hex (01, 0x01) or ELV (1112) format!\n");
 263                         return -1;
 264                         break;
 265         }
 266
 267         addr = val & 0xff;
 268
 269         return addr;
 270 }
 271
 272 void syntax(char *prog)
 273 {
 274         fprintf(stderr, "Syntax: %s options\n\n", prog);
 275         fprintf(stderr, "Possible options:\n");
 276         fprintf(stderr, "\t-V\t\trequest firmware-version\n");
 277         fprintf(stderr, "\t-x\t\tabort sending long press\n");
 278         fprintf(stderr, "\t-h [ELV|hex]\thousecode in ELV- or hex-notation\n");
 279         fprintf(stderr, "The following options need an housecode:\n");
 280         fprintf(stderr, "\t-a [ELV|hex]\tsend commands to device at specified address\n");
 281         fprintf(stderr, "\t-s hex\t\tsend command byte\n");
 282         fprintf(stderr, "\t-e hex\t\textension byte for command\n");
 283         fprintf(stderr, "\t-r n\t\trepeat sending n times\n");
 284         fprintf(stderr, "\nCommand bytes (without extension byte):\n");
 285         fprintf(stderr, "0x00\t\tswitch off\n");
 286         fprintf(stderr, "0x01-0x10\tswitch on dimmed (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%)\n");
 287         fprintf(stderr, "0x11\t\tswitch on\n");
 288         fprintf(stderr, "0x12\t\ttoggle\n");
 289         fprintf(stderr, "0x13\t\tdimup\n");
 290         fprintf(stderr, "0x14\t\tdimdown\n");
 291         fprintf(stderr, "0x15\t\tdimup, pause, dimdown, pause, ...\n");
 292         fprintf(stderr, "0x16\t\tstart/stop programming internal timer\n");
 293         fprintf(stderr, "0x17\t\tlearn housecode/address\n");
 294         fprintf(stderr, "0x18\t\toff for internal timer, then back on with current level\n");
 295         fprintf(stderr, "0x19\t\ton (100%%) for internal timer, then off\n");
 296         fprintf(stderr, "0x1a\t\ton (old level) for internal timer, then off\n");
 297         fprintf(stderr, "0x1b\t\tfactory reset\n");
 298         fprintf(stderr, "0x1e\t\ton (100%%) for internal timer, then old level\n");
 299         fprintf(stderr, "0x1f\t\ton (old level) for internal timer, then old state\n");
 300         fprintf(stderr, "\nCommand bytes (with timer as extension byte):\n");
 301         fprintf(stderr, "0x20\t\tdim down to off while timer is running\n");
 302         fprintf(stderr, "0x21-0x30\tdim to (0x01: 6.25%%, 0x02: 12.5%%, ..., 0x10: 100%%) while timer is running\n");
 303         fprintf(stderr, "0x31\t\tdim to last level while timer is running\n");
 304         fprintf(stderr, "0x32\t\tdim to off, then after timer dim to off\n");
 305         fprintf(stderr, "0x33\t\tdimup now and switch off after timer\n");
 306         fprintf(stderr, "0x34\t\tdimdown now and switch off after timer\n");
 307         fprintf(stderr, "0x35\t\tdimup or dimdown (toggle) and switch off after timer\n");
 308         fprintf(stderr, "0x36\t\tprogram internal timer\n");
 309         fprintf(stderr, "0x38\t\toff for timer, then back on with current level\n");
 310         fprintf(stderr, "0x39\t\ton (100%%) for timer, then off\n");
 311         fprintf(stderr, "0x3a\t\ton (old level) for timer, then off\n");
 312         fprintf(stderr, "0x3c\t\tprogram internal ramp-up-time\n");
 313         fprintf(stderr, "0x3d\t\tprogram internal ramp-down-time\n");
 314         fprintf(stderr, "0x3e\t\ton (100%%) for timer, then old level\n");
 315         fprintf(stderr, "0x3f\t\ton (old level) for timer, then old state\n");
 316 };
 317
 318 enum {
 319         NO_ACTION,
 320         REQUEST_FIRMWARE,
 321         SEND_COMMAND,
 322         ABORT_LONG_PRESS
 323 };
 324
 325 #define DUPLICATE_ACTION        if (action != NO_ACTION) { \
 326                                         fprintf(stderr, "duplicate action specified!\n"); \
 327                                         exit(EXIT_FAILURE); }
 328
 329 int main(int argc, char **argv)
 330 {
 331         unsigned char send_data[11];
 332         unsigned char *housecode = NULL;
 333         libusb_device_handle *devh = NULL;
 334         char *ep;
 335         int err;
 336         int opt;
 337         int action = NO_ACTION;
 338         uint8_t command = 0x00;
 339         uint8_t extension = 0x00;
 340         uint8_t repeat = 0;
 341         int addr = -1;
 342
 343         memset(send_data, 0, sizeof(send_data));
 344
 345         send_data[0] = 0x01;
 346
 347         while ((opt = getopt(argc, argv, "Vxs:h:a:r:e:")) != -1) {
 348                 switch(opt) {
 349                         case 'V':
 350                                 DUPLICATE_ACTION;
 351                                 action = REQUEST_FIRMWARE;
 352                                 break;
 353                         case 'x':
 354                                 DUPLICATE_ACTION;
 355                                 action = ABORT_LONG_PRESS;
 356                                 break;
 357                         case 's':
 358                                 DUPLICATE_ACTION;
 359                                 action = SEND_COMMAND;
 360
 361                                 command = strtoul(optarg, &ep, 16);
 362                                 if (*ep != '\0') {
 363                                         fprintf(stderr, "Can't parse command!\n");
 364                                         exit(EXIT_FAILURE);
 365                                 }
 366 #ifdef DEBUG
 367                                 printf("Got command: %d\n", command);
 368 #endif
 369                                 break;
 370                         case 'h':
 371                                 housecode = parse_housecode(optarg);
 372                                 if (!housecode) {
 373                                         fprintf(stderr, "Can't parse housecode!\n");
 374                                         exit(EXIT_FAILURE);
 375                                 }
 376 #ifdef DEBUG
 377                                 printf("Got housecode: 0x%02x%02x\n", housecode[0], housecode[1]);
 378 #endif
 379                                 break;
 380                         case 'a':
 381                                 addr = parse_addr(optarg);
 382                                 if (addr == -1) {
 383                                         fprintf(stderr, "Can't parse address!\n");
 384                                         exit(EXIT_FAILURE);
 385                                 }
 386 #ifdef DEBUG
 387                                 printf("Got address: 0x%02x\n", addr);
 388 #endif
 389                                 break;
 390                         case 'r':
 391                                 repeat = strtoul(optarg, &ep, 10);
 392                                 if (*ep != '\0') {
 393                                         fprintf(stderr, "Can't parse repeat!\n");
 394                                         exit(EXIT_FAILURE);
 395                                 }
 396 #ifdef DEBUG
 397                                 printf("Got repeat: %d\n", repeat);
 398 #endif
 399                                 break;
 400                         case 'e':
 401                                 extension = strtoul(optarg, &ep, 16);
 402                                 if (*ep != '\0') {
 403                                         fprintf(stderr, "Can't parse extension!\n");
 404                                         exit(EXIT_FAILURE);
 405                                 }
 406 #ifdef DEBUG
 407                                 printf("Got extension: %d\n", extension);
 408 #endif
 409                                 break;
 410                         case ':':
 411                         case '?':
 412                         default:
 413                                 syntax(argv[0]);
 414                                 exit(EXIT_FAILURE);
 415                                 break;
 416                 }
 417         }
 418
 419         switch(action) {
 420                 case REQUEST_FIRMWARE:
 421                         send_data[1] = 0x01;
 422                         send_data[2] = 0xf0;
 423                         printf("Requesting firmware version...\n");
 424
 425                         break;
 426                 case ABORT_LONG_PRESS:
 427                         send_data[1] = 0x01;
 428                         send_data[2] = 0xf3;
 429                         printf("Aborting long press...\n");
 430
 431                         break;
 432                 case SEND_COMMAND:
 433                         if (housecode == NULL) {
 434                                 fprintf(stderr, "housecode needed!\n");
 435                                 exit(EXIT_FAILURE);
 436                         }
 437                         if (addr == -1) {
 438                                 fprintf(stderr, "address needed!\n");
 439                                 exit(EXIT_FAILURE);
 440                         }
 441
 442                         if (repeat) {
 443                                 send_data[1] = 0x07;
 444                                 send_data[2] = 0xf2;
 445                                 send_data[8] = repeat;
 446                                 printf("Sending 0x%02x 0x%02x to address %d (hc: 0x%02x%02x) (repeated %d times)\n",
 447                                         command, extension, addr,
 448                                         housecode[0], housecode[1],
 449                                         repeat);
 450                         } else {
 451                                 send_data[1] = 0x06;
 452                                 send_data[2] = 0xf1;
 453                                 printf("Sending 0x%02x 0x%02x to address %d (hc: 0x%02x%02x)\n",
 454                                         command, extension, addr,
 455                                         housecode[0], housecode[1]);
 456                         }
 457                         send_data[3] = housecode[0];
 458                         send_data[4] = housecode[1];
 459                         send_data[5] = addr;
 460                         send_data[6] = command;
 461                         send_data[7] = extension;
 462
 463                         break;
 464                 case NO_ACTION:
 465                 default:
 466                         fprintf(stderr, "No action specified!\n\n");
 467                         syntax(argv[0]);
 468                         exit(EXIT_FAILURE);
 469                         break;
 470         }
 471
 472         err = libusb_init(NULL);
 473         if (err != 0) {
 474                 fprintf(stderr, "Can't initialize libusb: %s\n", usb_strerror(err));
 475                 return EXIT_FAILURE;
 476         }
 477
 478         devh = fs20pcs_find();
 479         if (!devh) {
 480                 fprintf(stderr, "Can't find/open fs20pcs!\n");
 481                 return EXIT_FAILURE;
 482         }
 483
 484         if (fs20pcs_send(devh, send_data) == 0) {
 485                 fprintf(stderr, "Can't communicate with fs20pcs!\n");
 486                 return EXIT_FAILURE;
 487         }
 488
 489         libusb_close(NULL);
 490
 491         return EXIT_SUCCESS;
 492 }