arexxd.c

   1 /*
   2  *      Linux Interfece for Arexx Data Loggers
   3  *
   4  *      (c) 2011-2012 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdarg.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <math.h>
  14 #include <time.h>
  15 #include <getopt.h>
  16 #include <syslog.h>
  17 #include <signal.h>
  18 #include <sys/stat.h>
  19 #include <libusb-1.0/libusb.h>
  20 #include <rrd.h>
  21
  22 #define DEFAULT_LOG_DIR "/var/log/arexxd"
  23
  24 typedef unsigned char byte;
  25 static libusb_context *usb_ctxt;
  26 static libusb_device_handle *devh;
  27
  28 static int use_syslog;
  29 static int debug_mode;
  30 static int debug_packets;
  31 static int debug_raw_data;
  32 static int debug_usb;
  33 static char *log_dir = DEFAULT_LOG_DIR;
  34
  35 static void die(char *fmt, ...)
  36 {
  37         va_list args;
  38         va_start(args, fmt);
  39         if (use_syslog)
  40                 vsyslog(LOG_CRIT, fmt, args);
  41         else {
  42                 vfprintf(stderr, fmt, args);
  43                 fprintf(stderr, "\n");
  44         }
  45         va_end(args);
  46         exit(1);
  47 }
  48
  49 static void log_error(char *fmt, ...)
  50 {
  51         va_list args;
  52         va_start(args, fmt);
  53         if (use_syslog)
  54                 vsyslog(LOG_ERR, fmt, args);
  55         else {
  56                 vfprintf(stderr, fmt, args);
  57                 fprintf(stderr, "\n");
  58         }
  59         va_end(args);
  60 }
  61
  62 static void log_info(char *fmt, ...)
  63 {
  64         va_list args;
  65         va_start(args, fmt);
  66         if (use_syslog)
  67                 vsyslog(LOG_INFO, fmt, args);
  68         else {
  69                 vfprintf(stderr, fmt, args);
  70                 fprintf(stderr, "\n");
  71         }
  72         va_end(args);
  73 }
  74
  75 static void log_pkt(char *fmt, ...)
  76 {
  77         if (!debug_packets)
  78                 return;
  79         va_list args;
  80         va_start(args, fmt);
  81         vprintf(fmt, args);
  82         va_end(args);
  83 }
  84
  85 /*** RRD interface ***/
  86
  87 #define MAX_ARGS 20
  88 #define MAX_ARG_SIZE 1024
  89
  90 static int arg_cnt;
  91 static char *arg_ptr[MAX_ARGS+1];
  92 static char arg_buf[MAX_ARG_SIZE];
  93 static int arg_pos;
  94
  95 static void arg_new(void)
  96 {
  97         arg_cnt = 1;
  98         arg_pos = 0;
  99         arg_ptr[0] = "rrdtool";
 100 }
 101
 102 static void arg_push(const char *fmt, ...)
 103 {
 104         if (arg_cnt >= MAX_ARGS)
 105                 die("MAX_ARGS exceeded");
 106         va_list va;
 107         va_start(va, fmt);
 108         int len = 1 + vsnprintf(arg_buf + arg_pos, MAX_ARG_SIZE - arg_pos, fmt, va);
 109         if (arg_pos + len > MAX_ARG_SIZE)
 110                 die("MAX_ARG_SIZE exceeded");
 111         arg_ptr[arg_cnt++] = arg_buf + arg_pos;
 112         arg_ptr[arg_cnt] = NULL;
 113         arg_pos += len;
 114 }
 115
 116 static void rrd_point(time_t t, const char *name, double val, char *unit)
 117 {
 118         char rr_name[256];
 119         snprintf(rr_name, sizeof(rr_name), "sensor-%s.rrd", name);
 120
 121         struct stat st;
 122         if (stat(rr_name, &st) < 0 || !st.st_size) {
 123                 // We have to create the RRD
 124                 log_info("Creating %s", rr_name);
 125                 arg_new();
 126                 arg_push(rr_name);
 127                 arg_push("--start");
 128                 arg_push("%d", (int) time(NULL) - 28*86400);
 129                 arg_push("--step");
 130                 arg_push("60");
 131                 if (!strcmp(unit, "%RH"))
 132                         arg_push("DS:rh:GAUGE:300:0:100");
 133                 else if (!strcmp(unit, "ppm"))
 134                         arg_push("DS:ppm:GAUGE:300:0:1000000");
 135                 else
 136                         arg_push("DS:temp:GAUGE:300:-200:200");
 137                 arg_push("RRA:AVERAGE:0.25:1:20160");           // Last 14 days with full resolution
 138                 arg_push("RRA:AVERAGE:0.25:60:88800");          // Last 10 years with 1h resolution
 139                 arg_push("RRA:MIN:0.25:60:88800");              // including minima and maxima
 140                 arg_push("RRA:MAX:0.25:60:88800");
 141                 rrd_create(arg_cnt, arg_ptr);
 142                 if (rrd_test_error()) {
 143                         log_error("rrd_create on %s failed: %s", rr_name, rrd_get_error());
 144                         rrd_clear_error();
 145                         return;
 146                 }
 147         }
 148
 149         arg_new();
 150         arg_push(rr_name);
 151         arg_push("%d:%f", t, val);
 152         rrd_update(arg_cnt, arg_ptr);
 153         if (rrd_test_error()) {
 154                 log_error("rrd_update on %s failed: %s", rr_name, rrd_get_error());
 155                 rrd_clear_error();
 156         }
 157 }
 158
 159 /*** Transforms ***/
 160
 161 #define TIME_OFFSET 946681200           // Timestamp of 2000-01-01 00:00:00
 162
 163 static int data_point_counter;          // Since last log message
 164
 165 static double correct_point(int id, double val, const char **name)
 166 {
 167         /*
 168          *  Manually calculated corrections and renames for my sensors.
 169          *  Replace with your formulae.
 170          */
 171         switch (id) {
 172                 case 10415:
 173                         *name = "ursarium";
 174                         return val - 0.93;
 175                 case 10707:
 176                         *name = "balcony";
 177                         return val - 0.71;
 178                 case 19246:
 179                         *name = "catarium";
 180                         return val + 0.49;
 181                 case 19247:
 182                         *name = "catarium-rh";
 183                         return val;
 184                 case 12133:
 185                         *name = "outside";
 186                         return val + 0.44;
 187                 default:
 188                         return val;
 189         }
 190 }
 191
 192 static void cooked_point(time_t t, int id, double val, char *unit, int q)
 193 {
 194         char namebuf[16];
 195         snprintf(namebuf, sizeof(namebuf), "%d", id);
 196         const char *name = namebuf;
 197
 198         double val2 = correct_point(id, val, &name);
 199
 200         if (debug_raw_data) {
 201                 struct tm tm;
 202                 localtime_r(&t, &tm);
 203                 char tbuf[64];
 204                 strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm);
 205                 printf("== %s id=%d name=%s val=%.3f val2=%.3f unit=%s q=%d\n", tbuf, id, name, val, val2, unit, q);
 206         }
 207
 208         data_point_counter++;
 209         rrd_point(t, name, val2, unit);
 210 }
 211
 212 static void raw_point(int t, int id, int raw, int q)
 213 {
 214         /*
 215          *  The binary blob provided by Arexx contains an embedded XML fragment
 216          *  with descriptions of all known sensor types. If you want to see it,
 217          *  grep the blob for "<deviceinfo>". The meanings of the parameters are
 218          *  as follows:
 219          *
 220          *      m1, m2          Device type matches if (raw_sensor_id & m1) == m2
 221          *      type            Unit measured by the sensor (1=Celsius, 2=RH%, 3=CO2 ppm)
 222          *      dm              User-visible sensor ID = raw_sensor_id & dm
 223          *      i               1 if the raw value is signed
 224          *      p[]             Coefficients of transformation polynomial (x^0 first)
 225          *      vLo, vUp        Upper and lower bound on the final value
 226          *      scale           Scaling function:
 227          *                              0 = identity (default)
 228          *                              1 = 10^x
 229          *                              2 = exp(x)
 230          *                              3 = (x < 0) ? 0 : log10(x)
 231          *                              4 = (x < 0) ? 0 : log(x)
 232          *
 233          *  The raw values are transformed this way:
 234          *      - sign-extend if signed
 235          *      - apply the transformation polynomial
 236          *      - apply the scaling function
 237          *      - drop if outside the interval [vLo,vUp]
 238          *
 239          *  This function applies the necessary transform for sensors we've
 240          *  seen in the wild. We deliberately ignore the "dm" parameter as we want
 241          *  to report different channels of a single sensor as multiple sensors.
 242          */
 243
 244         double z = raw;
 245         double hi, lo;
 246         char *unit;
 247         int idhi = id & 0xf000;
 248
 249         if (idhi == 0x1000) {
 250                 z = 0.02*z - 273.15;
 251                 lo = -200;
 252                 hi = 600;
 253                 unit = "C";
 254         } else if (idhi == 0x2000) {
 255                 if (raw >= 0x8000)
 256                         z -= 0x10000;
 257                 z /= 128;
 258                 lo = -60;
 259                 hi = 125;
 260                 unit = "C";
 261         } else if (idhi == 0x4000) {
 262                 if (!(id & 1)) {
 263                         z = z/100 - 39.6;
 264                         lo = -60;
 265                         hi = 125;
 266                         unit = "C";
 267                 } else {
 268                         z = -2.8e-6*z*z + 0.0405*z - 4;
 269                         lo = 0;
 270                         hi = 100.1;
 271                         unit = "%RH";
 272                 }
 273         } else if (idhi == 0x6000) {
 274                 if (!(id & 1)) {
 275                         if (raw >= 0x8000)
 276                                 z -= 0x10000;
 277                         z /= 128;
 278                         lo = -60;
 279                         hi = 125;
 280                         unit = "C";
 281                 } else {
 282                         z = -3.8123e-11*z;
 283                         z = (z + 1.9184e-7) * z;
 284                         z = (z - 1.0998e-3) * z;
 285                         z += 6.56;
 286                         z = pow(10, z);
 287                         lo = 0;
 288                         hi = 1e6;
 289                         unit = "ppm";
 290                 }
 291         } else {
 292                 log_error("Unknown sensor type 0x%04x", id);
 293                 return;
 294         }
 295
 296         if (z < lo || z > hi) {
 297                 log_error("Sensor %d: value %f out of range", id, z);
 298                 return;
 299         }
 300
 301         cooked_point(t + TIME_OFFSET, id, z, unit, q);
 302 }
 303
 304 /*** USB interface ***/
 305
 306 static int rx_endpoint, tx_endpoint;
 307
 308 static int parse_descriptors(libusb_device *dev)
 309 {
 310         int err;
 311         struct libusb_config_descriptor *desc;
 312
 313         if (err = libusb_get_active_config_descriptor(dev, &desc)) {
 314                 log_error("libusb_get_config_descriptor failed: error %d", err);
 315                 return 0;
 316         }
 317         if (desc->bNumInterfaces != 1) {
 318                 log_error("Unexpected number of interfaces: %d", desc->bNumInterfaces);
 319                 goto failed;
 320         }
 321
 322         const struct libusb_interface *iface = &desc->interface[0];
 323         if (iface->num_altsetting != 1) {
 324                 log_error("Unexpected number of alternate interface settings: %d", iface->num_altsetting);
 325                 goto failed;
 326         }
 327
 328         const struct libusb_interface_descriptor *ifd = &iface->altsetting[0];
 329         if (ifd->bNumEndpoints != 2) {
 330                 log_error("Unexpected number of endpoints: %d", ifd->bNumEndpoints);
 331                 goto failed;
 332         }
 333
 334         rx_endpoint = tx_endpoint = -1;
 335         for (int i=0; i<2; i++) {
 336                 const struct libusb_endpoint_descriptor *epd = &ifd->endpoint[i];
 337                 if (epd->bEndpointAddress & 0x80)
 338                         rx_endpoint = epd->bEndpointAddress;
 339                 else
 340                         tx_endpoint = epd->bEndpointAddress;
 341         }
 342         if (rx_endpoint < 0 || tx_endpoint < 0) {
 343                 log_error("Failed to identify endpoints");
 344                 goto failed;
 345         }
 346
 347         log_pkt("Found endpoints: rx==%02x tx=%02x\n", rx_endpoint, tx_endpoint);
 348         libusb_free_config_descriptor(desc);
 349         return 1;
 350
 351 failed:
 352         libusb_free_config_descriptor(desc);
 353         return 0;
 354 }
 355
 356 static int find_device(void)
 357 {
 358         libusb_device **devlist;
 359         ssize_t devn = libusb_get_device_list(usb_ctxt, &devlist);
 360         if (devn < 0) {
 361                 log_error("Cannot enumerate USB devices: error %d", (int) devn);
 362                 return 0;
 363         }
 364
 365         for (ssize_t i=0; i<devn; i++) {
 366                 struct libusb_device_descriptor desc;
 367                 libusb_device *dev = devlist[i];
 368                 if (!libusb_get_device_descriptor(dev, &desc)) {
 369                         if (desc.idVendor == 0x0451 && desc.idProduct == 0x3211) {
 370                                 log_info("Arexx data logger found at usb%d.%d", libusb_get_bus_number(dev), libusb_get_device_address(dev));
 371                                 if (!parse_descriptors(dev))
 372                                         continue;
 373                                 int err;
 374                                 if (err = libusb_open(dev, &devh)) {
 375                                         log_error("libusb_open() failed: error %d", err);
 376                                         goto failed;
 377                                 }
 378                                 if (err = libusb_claim_interface(devh, 0)) {
 379                                         log_error("libusb_claim_interface() failed: error %d", err);
 380                                         libusb_close(devh);
 381                                         goto failed;
 382                                 }
 383                                 libusb_free_device_list(devlist, 1);
 384                                 return 1;
 385                         }
 386                 }
 387         }
 388
 389 failed:
 390         libusb_free_device_list(devlist, 1);
 391         return 0;
 392 }
 393
 394 static void release_device(void)
 395 {
 396         libusb_release_interface(devh, 0);
 397         libusb_reset_device(devh);
 398         libusb_close(devh);
 399         devh = NULL;
 400 }
 401
 402 static void dump_packet(byte *pkt)
 403 {
 404         for (int i=0; i<64; i++) {
 405                 if (!(i % 16))
 406                         log_pkt("\t%02x:", i);
 407                 log_pkt(" %02x", pkt[i]);
 408                 if (i % 16 == 15)
 409                         log_pkt("\n");
 410         }
 411 }
 412
 413 static void my_msleep(int ms)
 414 {
 415         struct timespec ts = { .tv_sec = ms/1000, .tv_nsec = (ms%1000) * 1000000 };
 416         nanosleep(&ts, NULL);
 417 }
 418
 419 static int send_and_receive(byte *req, byte *reply)
 420 {
 421         if (debug_packets) {
 422                 time_t t = time(NULL);
 423                 struct tm tm;
 424                 localtime_r(&t, &tm);
 425
 426                 char tbuf[64];
 427                 strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm);
 428                 log_pkt("## %s\n", tbuf);
 429         }
 430
 431         int err, transferred;
 432         if (err = libusb_bulk_transfer(devh, tx_endpoint, req, 64, &transferred, 200)) {
 433                 if (err == LIBUSB_ERROR_TIMEOUT) {
 434                         log_pkt(">> xmit timed out\n");
 435                         return 0;
 436                 }
 437                 log_pkt(">> xmit error %d\n", err);
 438                 log_error("Transmit error: %d", err);
 439                 return err;
 440         }
 441         if (debug_packets) {
 442                 log_pkt(">> xmit %d bytes\n", transferred);
 443                 dump_packet(req);
 444         }
 445         my_msleep(1);
 446         if (err = libusb_bulk_transfer(devh, rx_endpoint, reply, 64, &transferred, 200)) {
 447                 if (err == LIBUSB_ERROR_TIMEOUT) {
 448                         log_pkt("<< recv timed out\n");
 449                         return 0;
 450                 }
 451                 log_pkt("<< recv error %d\n", err);
 452                 log_error("Receive error: %d", err);
 453                 return err;
 454         }
 455         if (debug_packets)
 456                 log_pkt("<< recv %d bytes\n", transferred);
 457         while (transferred < 64)
 458                 reply[transferred++] = 0xff;
 459         if (debug_packets)
 460                 dump_packet(reply);
 461         return 1;
 462 }
 463
 464 static unsigned int get_be16(byte *p)
 465 {
 466         return p[1] | (p[0] << 8);
 467 }
 468
 469 static unsigned int get_le16(byte *p)
 470 {
 471         return p[0] | (p[1] << 8);
 472 }
 473
 474 static unsigned int get_le32(byte *p)
 475 {
 476         return get_le16(p) | (get_le16(p+2) << 16);
 477 }
 478
 479 static void put_le16(byte *p, unsigned int x)
 480 {
 481         p[0] = x;
 482         p[1] = x >> 8;
 483 }
 484
 485 static void put_le32(byte *p, unsigned int x)
 486 {
 487         put_le16(p, x);
 488         put_le16(p+2, x>>16);
 489 }
 490
 491 static int parse_packet(byte *reply)
 492 {
 493         if (reply[0]) {
 494                 log_error("Unknown packet type %02x", reply[0]);
 495                 return 0;
 496         }
 497
 498         int pos = 1;
 499         int points = 0;
 500         while (pos < 64) {
 501                 byte *p = reply + pos;
 502                 int len = p[0];
 503                 if (!len || len == 0xff)
 504                         break;
 505                 if (len < 9 || len > 10) {
 506                         log_error("Unknown tuple length %02x", len);
 507                         break;
 508                 }
 509                 if (pos + len > 64) {
 510                         log_error("Tuple truncated");
 511                         break;
 512                 }
 513                 int id = get_le16(p+1);
 514                 int raw = get_be16(p+3);
 515                 int t = get_le32(p+5);
 516                 int q = (len > 9) ? p[9] : -1;
 517                 if (debug_raw_data) {
 518                         printf("... %02x: id=%d raw=%d t=%d", len, id, raw, t);
 519                         if (len > 9)
 520                                 printf(" q=%d", q);
 521                         printf("\n");
 522                 }
 523                 raw_point(t, id, raw, q);
 524                 pos += len;
 525                 points++;
 526         }
 527
 528         return points;
 529 }
 530
 531 static void set_clock(void)
 532 {
 533         byte req[64], reply[64];
 534         memset(req, 0, 64);
 535         req[0] = 4;
 536         time_t t = time(NULL);
 537         put_le32(req+1, t-TIME_OFFSET);
 538         send_and_receive(req, reply);
 539
 540 #if 0
 541         /*
 542          *  Original software also sends a packet with type 3 and the timestamp,
 543          *  but it does not make any sense, especially as they ignore the sensor
 544          *  readings in the answer.
 545          */
 546         req[0] = 3;
 547         send_and_receive(req, reply);
 548         parse_packet(reply);
 549 #endif
 550 }
 551
 552 /*** Main ***/
 553
 554 static sigset_t term_sigs;
 555 static volatile sig_atomic_t want_shutdown;
 556
 557 static void sigterm_handler(int sig __attribute__((unused)))
 558 {
 559         want_shutdown = 1;
 560 }
 561
 562 static void interruptible_msleep(int ms)
 563 {
 564         sigprocmask(SIG_UNBLOCK, &term_sigs, NULL);
 565         my_msleep(ms);
 566         sigprocmask(SIG_BLOCK, &term_sigs, NULL);
 567 }
 568
 569 static const struct option long_options[] = {
 570         { "debug",              0, NULL, 'd' },
 571         { "log-dir",            1, NULL, 'l' },
 572         { "debug-packets",      0, NULL, 'p' },
 573         { "debug-raw",          0, NULL, 'r' },
 574         { "version",            0, NULL, 'V' },
 575         { NULL,                 0, NULL, 0 },
 576 };
 577
 578 static void usage(void)
 579 {
 580         fprintf(stderr, "\n\
 581 Usage: arexxd <options>\n\
 582 \n\
 583 Options:\n\
 584 -d, --debug             Debug mode (no chdir, no fork, no syslog)\n\
 585 -l, --log-dir=<dir>     Directory where all received data should be stored\n\
 586 -p, --debug-packets     Log all packets sent and received\n\
 587 -r, --debug-raw         Log conversion from raw values\n\
 588 -u, --debug-usb         Enable libusb debug messages (to stdout/stderr)\n\
 589 -V, --version           Show daemon version\n\
 590 ");
 591         exit(1);
 592 }
 593
 594 int main(int argc, char **argv)
 595 {
 596         int opt;
 597         while ((opt = getopt_long(argc, argv, "dl:pruV", long_options, NULL)) >= 0)
 598                 switch (opt) {
 599                         case 'd':
 600                                 debug_mode++;
 601                                 break;
 602                         case 'l':
 603                                 log_dir = optarg;
 604                                 break;
 605                         case 'p':
 606                                 debug_packets++;
 607                                 break;
 608                         case 'r':
 609                                 debug_raw_data++;
 610                                 break;
 611                         case 'u':
 612                                 debug_usb++;
 613                                 break;
 614                         case 'V':
 615                                 printf("arexxd " AREXXD_VERSION "\n");
 616                                 printf("(c) 2011-2012 Martin Mares <mj@ucw.cz>\n");
 617                                 return 0;
 618                         default:
 619                                 usage();
 620                 }
 621         if (optind < argc)
 622                 usage();
 623
 624         int err;
 625         if (err = libusb_init(&usb_ctxt))
 626                 die("Cannot initialize libusb: error %d", err);
 627         if (debug_usb)
 628                 libusb_set_debug(usb_ctxt, 3);
 629
 630         if (!debug_mode) {
 631                 if (chdir(log_dir) < 0)
 632                         die("Cannot change directory to %s: %m", log_dir);
 633                 if (debug_packets || debug_raw_data) {
 634                         close(1);
 635                         if (open("debug", O_WRONLY | O_CREAT | O_APPEND, 0666) < 0)
 636                                 die("Cannot open debug log: %m");
 637                         setlinebuf(stdout);
 638                 }
 639                 openlog("arexxd", LOG_NDELAY, LOG_DAEMON);
 640                 pid_t pid = fork();
 641                 if (pid < 0)
 642                         die("fork() failed: %m");
 643                 if (pid)
 644                         return 0;
 645                 setsid();
 646                 use_syslog = 1;
 647         }
 648
 649         struct sigaction sa = { .sa_handler = sigterm_handler };
 650         sigaction(SIGTERM, &sa, NULL);
 651         sigaction(SIGINT, &sa, NULL);
 652
 653         sigemptyset(&term_sigs);
 654         sigaddset(&term_sigs, SIGTERM);
 655         sigaddset(&term_sigs, SIGINT);
 656         sigprocmask(SIG_BLOCK, &term_sigs, NULL);
 657
 658         int inited = 0;
 659         while (!want_shutdown) {
 660                 if (!find_device()) {
 661                         if (!inited) {
 662                                 inited = 1;
 663                                 log_error("Data logger not connected, waiting until it appears");
 664                         }
 665                         interruptible_msleep(30000);
 666                         continue;
 667                 }
 668                 log_info("Listening");
 669
 670                 time_t last_sync = 0;
 671                 time_t last_show = 0;
 672                 int want_stats = 0;
 673                 int want_sleep = 0;
 674                 data_point_counter = 0;
 675                 while (!want_shutdown) {
 676                         time_t now = time(NULL);
 677                         if (now > last_sync + 900) {
 678                                 log_info("Synchronizing data logger time");
 679                                 set_clock();
 680                                 last_sync = now;
 681                         }
 682                         if (want_stats && now > last_show + 300) {
 683                                 log_info("Stats: received %d data points", data_point_counter);
 684                                 data_point_counter = 0;
 685                                 last_show = now;
 686                         }
 687
 688                         byte req[64], reply[64];
 689                         memset(req, 0, sizeof(req));
 690                         req[0] = 3;
 691                         err = send_and_receive(req, reply);
 692                         if (err < 0)
 693                                 break;
 694                         want_sleep = 1;
 695                         if (err > 0 && parse_packet(reply))
 696                                 want_sleep = 0;
 697                         if (want_sleep) {
 698                                 interruptible_msleep(4000);
 699                                 want_stats = 1;
 700                         } else
 701                                 interruptible_msleep(5);
 702                 }
 703
 704                 log_info("Disconnecting data logger");
 705                 release_device();
 706                 inited = 0;
 707                 interruptible_msleep(10000);
 708         }
 709
 710         log_info("Terminated");
 711         return 0;
 712 }