arexxd.c

   1 /*
   2  *      Linux Interfece for Arexx Data Loggers
   3  *
   4  *      (c) 2011 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 LOG_PATH "/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
  33 static void die(char *fmt, ...)
  34 {
  35         va_list args;
  36         va_start(args, fmt);
  37         if (use_syslog)
  38                 vsyslog(LOG_CRIT, fmt, args);
  39         else {
  40                 vfprintf(stderr, fmt, args);
  41                 fprintf(stderr, "\n");
  42         }
  43         va_end(args);
  44         exit(1);
  45 }
  46
  47 static void log_error(char *fmt, ...)
  48 {
  49         va_list args;
  50         va_start(args, fmt);
  51         if (use_syslog)
  52                 vsyslog(LOG_ERR, fmt, args);
  53         else {
  54                 vfprintf(stderr, fmt, args);
  55                 fprintf(stderr, "\n");
  56         }
  57         va_end(args);
  58 }
  59
  60 static void log_info(char *fmt, ...)
  61 {
  62         va_list args;
  63         va_start(args, fmt);
  64         if (use_syslog)
  65                 vsyslog(LOG_INFO, fmt, args);
  66         else {
  67                 vfprintf(stderr, fmt, args);
  68                 fprintf(stderr, "\n");
  69         }
  70         va_end(args);
  71 }
  72
  73 static void log_pkt(char *fmt, ...)
  74 {
  75         if (!debug_packets)
  76                 return;
  77         va_list args;
  78         va_start(args, fmt);
  79         vprintf(fmt, args);
  80         va_end(args);
  81 }
  82
  83 /*** RRD interface ***/
  84
  85 #define SLOT_SIZE 10                                    // 10 seconds per averaging slot
  86 #define MAX_ARGS 20
  87 #define MAX_ARG_SIZE 1024
  88
  89 static int arg_cnt;
  90 static char *arg_ptr[MAX_ARGS+1];
  91 static char arg_buf[MAX_ARG_SIZE];
  92 static int arg_pos;
  93
  94 static void arg_new(void)
  95 {
  96         arg_cnt = 1;
  97         arg_pos = 0;
  98         arg_ptr[0] = "rrdtool";
  99 }
 100
 101 static void arg_push(const char *fmt, ...)
 102 {
 103         if (arg_cnt >= MAX_ARGS)
 104                 die("MAX_ARGS exceeded");
 105         va_list va;
 106         va_start(va, fmt);
 107         int len = 1 + vsnprintf(arg_buf + arg_pos, MAX_ARG_SIZE - arg_pos, fmt, va);
 108         if (arg_pos + len > MAX_ARG_SIZE)
 109                 die("MAX_ARG_SIZE exceeded");
 110         arg_ptr[arg_cnt++] = arg_buf + arg_pos;
 111         arg_ptr[arg_cnt] = NULL;
 112         arg_pos += len;
 113 }
 114
 115 static void rrd_point(time_t t, int id, double val)
 116 {
 117         char rr_name[256];
 118         snprintf(rr_name, sizeof(rr_name), "sensor-%d.rrd", id);
 119
 120         struct stat st;
 121         if (stat(rr_name, &st) < 0 || !st.st_size) {
 122                 // We have to create the RRD
 123                 log_info("Creating %s", rr_name);
 124                 arg_new();
 125                 arg_push(rr_name);
 126                 arg_push("--start");
 127                 arg_push("%d", (int) time(NULL) - 28*86400);
 128                 arg_push("--step");
 129                 arg_push("60");
 130                 arg_push("DS:temp:GAUGE:300:0:10000");          // Anything over 10 kW is considered a ghost
 131                 arg_push("RRA:AVERAGE:0.25:1:20160");           // Last 14 days with full resolution
 132                 arg_push("RRA:AVERAGE:0.25:60:88800");          // Last 10 years with 1h resolution
 133                 rrd_create(arg_cnt, arg_ptr);
 134                 if (rrd_test_error()) {
 135                         log_error("rrd_create on %s failed: %s", rr_name, rrd_get_error());
 136                         return;
 137                 }
 138         }
 139
 140         arg_new();
 141         arg_push(rr_name);
 142         arg_push("%d:%f", t, val);
 143         rrd_update(arg_cnt, arg_ptr);
 144         if (rrd_test_error())
 145                 log_error("rrd_update on %s failed: %s", rr_name, rrd_get_error());
 146 }
 147
 148 /*** Transforms ***/
 149
 150 #define TIME_OFFSET 946681200           // Timestamp of 2000-01-01 00:00:00
 151
 152 static int data_point_counter;
 153
 154 static void cooked_point(time_t t, int id, double val, char *unit, int q)
 155 {
 156         if (debug_raw_data) {
 157                 struct tm tm;
 158                 localtime_r(&t, &tm);
 159                 char tbuf[64];
 160                 strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm);
 161                 printf("== %s id=%d val=%.3f unit=%s q=%d\n", tbuf, id, val, unit, q);
 162         }
 163
 164         data_point_counter++;
 165         rrd_point(t, id, val);
 166 }
 167
 168 static void raw_point(int t, int id, int raw, int q)
 169 {
 170         /*
 171          *  The binary blob provided by Arexx contains an embedded XML fragment
 172          *  with descriptions of all known sensor types. If you want to see it,
 173          *  grep the blob for "<deviceinfo>". The meanings of the parameters are
 174          *  as follows:
 175          *
 176          *      m1, m2          Device type matches if (raw_sensor_id & m1) == m2
 177          *      type            Unit measured by the sensor (1=Celsius, 2=RH%, 3=CO2 ppm)
 178          *      dm              User-visible sensor ID = raw_sensor_id & dm
 179          *      i               1 if the raw value is signed
 180          *      p[]             Coefficients of transformation polynomial (x^0 first)
 181          *      vLo, vUp        Upper and lower bound on the final value
 182          *      scale           Scaling function:
 183          *                              0 = identity (default)
 184          *                              1 = 10^x
 185          *                              2 = exp(x)
 186          *                              3 = (x < 0) ? 0 : log10(x)
 187          *                              4 = (x < 0) ? 0 : log(x)
 188          *
 189          *  The raw values are transformed this way:
 190          *      - sign-extend if signed
 191          *      - apply the transformation polynomial
 192          *      - apply the scaling function
 193          *      - drop if outside the interval [vLo,vUp]
 194          *
 195          *  This function applies the necessary transform for sensors we've
 196          *  seen in the wild. We deliberately ignore the "dm" parameter as we want
 197          *  to report different channels of a single sensor as multiple sensors.
 198          */
 199
 200         double z = raw;
 201         double hi, lo;
 202         char *unit;
 203         int idhi = id & 0xf000;
 204
 205         if (idhi == 0x1000) {
 206                 z = 0.02*z - 273.15;
 207                 lo = -200;
 208                 hi = 600;
 209                 unit = "C";
 210         } else if (idhi == 0x2000) {
 211                 if (raw >= 0x8000)
 212                         z -= 0x10000;
 213                 z /= 128;
 214                 lo = -60;
 215                 hi = 125;
 216                 unit = "C";
 217         } else if (idhi == 0x4000) {
 218                 if (!(id & 1)) {
 219                         z = z/100 - 39.6;
 220                         lo = -60;
 221                         hi = 125;
 222                         unit = "C";
 223                 } else {
 224                         z = -2.8e-6*z*z + 0.0405*z - 4;
 225                         lo = 0;
 226                         hi = 100.1;
 227                         unit = "%RH";
 228                 }
 229         } else if (idhi == 0x6000) {
 230                 if (!(id & 1)) {
 231                         if (raw >= 0x8000)
 232                                 z -= 0x10000;
 233                         z /= 128;
 234                         lo = -60;
 235                         hi = 125;
 236                         unit = "C";
 237                 } else {
 238                         z = -3.8123e-11*z;
 239                         z = (z + 1.9184e-7) * z;
 240                         z = (z - 1.0998e-3) * z;
 241                         z += 6.56;
 242                         z = pow(10, z);
 243                         lo = 0;
 244                         hi = 1e6;
 245                         unit = "ppm";
 246                 }
 247         } else {
 248                 log_error("Unknown sensor type 0x%04x", id);
 249                 return;
 250         }
 251
 252         if (z < lo || z > hi) {
 253                 log_error("Sensor %d: value %f out of range", id, z);
 254                 return;
 255         }
 256
 257         cooked_point(t + TIME_OFFSET, id, z, unit, q);
 258 }
 259
 260 /*** USB interface ***/
 261
 262 static int find_device(void)
 263 {
 264         libusb_device **devlist;
 265         ssize_t devn = libusb_get_device_list(usb_ctxt, &devlist);
 266         if (devn < 0) {
 267                 log_error("Cannot enumerate USB devices: error %d", (int) devn);
 268                 return 0;
 269         }
 270
 271         for (ssize_t i=0; i<devn; i++) {
 272                 struct libusb_device_descriptor desc;
 273                 libusb_device *dev = devlist[i];
 274                 if (!libusb_get_device_descriptor(dev, &desc)) {
 275                         if (desc.idVendor == 0x0451 && desc.idProduct == 0x3211) {
 276                                 log_info("Arexx data logger found at usb%d.%d", libusb_get_bus_number(dev), libusb_get_device_address(dev));
 277                                 int err;
 278                                 if (err = libusb_open(dev, &devh)) {
 279                                         log_error("libusb_open() failed: error %d", err);
 280                                         goto failed;
 281                                 }
 282                                 if (err = libusb_claim_interface(devh, 0)) {
 283                                         log_error("libusb_claim_interface() failed: error %d", err);
 284                                         libusb_close(devh);
 285                                         goto failed;
 286                                 }
 287                                 libusb_free_device_list(devlist, 1);
 288                                 return 1;
 289                         }
 290                 }
 291         }
 292
 293 failed:
 294         libusb_free_device_list(devlist, 1);
 295         return 0;
 296 }
 297
 298 static void release_device(void)
 299 {
 300         libusb_close(devh);
 301         devh = NULL;
 302 }
 303
 304 static void dump_packet(byte *pkt)
 305 {
 306         for (int i=0; i<64; i++) {
 307                 if (!(i % 16))
 308                         log_pkt("\t%02x:", i);
 309                 log_pkt(" %02x", pkt[i]);
 310                 if (i % 16 == 15)
 311                         log_pkt("\n");
 312         }
 313 }
 314
 315 static int send_and_receive(byte *req, byte *reply)
 316 {
 317         if (debug_packets) {
 318                 time_t t = time(NULL);
 319                 struct tm tm;
 320                 localtime_r(&t, &tm);
 321
 322                 char tbuf[64];
 323                 strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm);
 324                 log_pkt("## %s\n", tbuf);
 325         }
 326
 327         int err, transferred;
 328         if (err = libusb_bulk_transfer(devh, 0x01, req, 64, &transferred, 200)) {
 329                 if (err == LIBUSB_ERROR_TIMEOUT) {
 330                         log_pkt(">> xmit timed out\n");
 331                         return 0;
 332                 }
 333                 log_pkt(">> xmit error %d\n", err);
 334                 log_error("Transmit error: %d", err);
 335                 return err;
 336         }
 337         if (debug_packets) {
 338                 log_pkt(">> xmit %d bytes\n", transferred);
 339                 dump_packet(req);
 340         }
 341         if (err = libusb_bulk_transfer(devh, 0x81, reply, 64, &transferred, 200)) {
 342                 if (err == LIBUSB_ERROR_TIMEOUT) {
 343                         log_pkt("<< recv timed out\n");
 344                         return 0;
 345                 }
 346                 log_pkt("<< recv error %d\n", err);
 347                 log_error("Receive error: %d", err);
 348                 return err;
 349         }
 350         if (debug_packets)
 351                 log_pkt("<< recv %d bytes\n", transferred);
 352         while (transferred < 64)
 353                 reply[transferred++] = 0xff;
 354         if (debug_packets)
 355                 dump_packet(reply);
 356         return 1;
 357 }
 358
 359 static unsigned int get_be16(byte *p)
 360 {
 361         return p[1] | (p[0] << 8);
 362 }
 363
 364 static unsigned int get_le16(byte *p)
 365 {
 366         return p[0] | (p[1] << 8);
 367 }
 368
 369 static unsigned int get_le32(byte *p)
 370 {
 371         return get_le16(p) | (get_le16(p+2) << 16);
 372 }
 373
 374 static void put_le16(byte *p, unsigned int x)
 375 {
 376         p[0] = x;
 377         p[1] = x >> 8;
 378 }
 379
 380 static void put_le32(byte *p, unsigned int x)
 381 {
 382         put_le16(p, x);
 383         put_le16(p+2, x>>16);
 384 }
 385
 386 static int parse_packet(byte *reply)
 387 {
 388         if (reply[0]) {
 389                 log_error("Unknown packet type %02x", reply[0]);
 390                 return 0;
 391         }
 392
 393         int pos = 1;
 394         int points = 0;
 395         while (pos < 64) {
 396                 byte *p = reply + pos;
 397                 int len = p[0];
 398                 if (!len || len == 0xff)
 399                         break;
 400                 if (len < 9 || len > 10) {
 401                         log_error("Unknown tuple length %02x", len);
 402                         break;
 403                 }
 404                 if (pos + len > 64) {
 405                         log_error("Tuple truncated");
 406                         break;
 407                 }
 408                 int id = get_le16(p+1);
 409                 int raw = get_be16(p+3);
 410                 int t = get_le32(p+5);
 411                 int q = (len > 9) ? p[9] : -1;
 412                 if (debug_raw_data) {
 413                         printf("... %02x: id=%d raw=%d t=%d", len, id, raw, t);
 414                         if (len > 9)
 415                                 printf(" q=%d", q);
 416                         printf("\n");
 417                 }
 418                 raw_point(t, id, raw, q);
 419                 pos += len;
 420                 points++;
 421         }
 422
 423         return points;
 424 }
 425
 426 static void set_clock(void)
 427 {
 428         byte req[64], reply[64];
 429         memset(req, 0, 64);
 430         req[0] = 4;
 431         time_t t = time(NULL);
 432         put_le32(req+1, t-TIME_OFFSET);
 433         send_and_receive(req, reply);
 434
 435 #if 0
 436         /*
 437          *  Original software also sends a packet with type 3 and the timestamp,
 438          *  but it does not make any sense, especially as they ignore the sensor
 439          *  readings in the answer.
 440          */
 441         req[0] = 3;
 442         send_and_receive(req, reply);
 443         parse_packet(reply);
 444 #endif
 445 }
 446
 447 /*** Main ***/
 448
 449 static volatile sig_atomic_t want_shutdown;
 450
 451 static void sigterm_handler(int sig __attribute__((unused)))
 452 {
 453         want_shutdown = 1;
 454 }
 455
 456 static const struct option long_options[] = {
 457         { "debug",              0, NULL, 'd' },
 458         { "log-packets",        0, NULL, 'p' },
 459         { NULL,                 0, NULL, 0 },
 460 };
 461
 462 static void usage(void)
 463 {
 464         fprintf(stderr, "Usage: arexxd [--debug] [--log-packets]\n");
 465         exit(1);
 466 }
 467
 468 int main(int argc, char **argv)
 469 {
 470         int opt;
 471         while ((opt = getopt_long(argc, argv, "dp", long_options, NULL)) >= 0)
 472                 switch (opt) {
 473                         case 'd':
 474                                 debug_mode++;
 475                                 break;
 476                         case 'p':
 477                                 debug_packets++;
 478                                 debug_raw_data++;
 479                                 break;
 480                         default:
 481                                 usage();
 482                 }
 483         if (optind < argc)
 484                 usage();
 485
 486         int err;
 487         if (err = libusb_init(&usb_ctxt))
 488                 die("Cannot initialize libusb: error %d", err);
 489         // libusb_set_debug(usb_ctxt, 3);
 490
 491         if (!debug_mode) {
 492                 if (chdir(LOG_PATH) < 0)
 493                         die("Cannot change directory to %s: %m", LOG_PATH);
 494                 if (debug_packets || debug_raw_data) {
 495                         close(1);
 496                         if (open("debug", O_WRONLY | O_CREAT | O_APPEND, 0666) < 0)
 497                                 die("Cannot open debug log: %m");
 498                         setlinebuf(stdout);
 499                 }
 500                 openlog("arexxd", LOG_NDELAY, LOG_DAEMON);
 501                 pid_t pid = fork();
 502                 if (pid < 0)
 503                         die("fork() failed: %m");
 504                 if (pid)
 505                         return 0;
 506                 setsid();
 507                 use_syslog = 1;
 508         }
 509
 510         struct sigaction sa = { .sa_handler = sigterm_handler };
 511         sigaction(SIGTERM, &sa, NULL);
 512         sigaction(SIGINT, &sa, NULL);
 513
 514         sigset_t term_sigs;
 515         sigemptyset(&term_sigs);
 516         sigaddset(&term_sigs, SIGTERM);
 517         sigaddset(&term_sigs, SIGINT);
 518         sigprocmask(SIG_BLOCK, &term_sigs, NULL);
 519
 520         int inited = 0;
 521         while (!want_shutdown) {
 522                 if (!find_device()) {
 523                         if (!inited) {
 524                                 inited = 1;
 525                                 log_error("Data logger not connected, waiting until it appears");
 526                         }
 527                         sleep(30);
 528                         continue;
 529                 }
 530                 log_info("Listening");
 531
 532                 time_t last_sync = 0;
 533                 time_t last_show = 0;
 534                 int want_stats = 0;
 535                 int want_sleep = 0;
 536                 data_point_counter = 0;
 537                 while (!want_shutdown) {
 538                         time_t now = time(NULL);
 539                         if (now > last_sync + 900) {
 540                                 log_info("Synchronizing data logger time");
 541                                 set_clock();
 542                                 last_sync = now;
 543                         }
 544                         if (want_stats && now > last_show + 300) {
 545                                 log_info("Stats: received %d data points", data_point_counter);
 546                                 data_point_counter = 0;
 547                                 last_show = now;
 548                         }
 549
 550                         byte req[64], reply[64];
 551                         memset(req, 0, sizeof(req));
 552                         req[0] = 3;
 553                         err = send_and_receive(req, reply);
 554                         if (err < 0)
 555                                 break;
 556                         want_sleep = 1;
 557                         if (err > 0 && parse_packet(reply))
 558                                 want_sleep = 0;
 559                         want_stats = 1;
 560                         sigprocmask(SIG_UNBLOCK, &term_sigs, NULL);
 561                         sleep(4);
 562                         sigprocmask(SIG_BLOCK, &term_sigs, NULL);
 563                 }
 564
 565                 log_info("Disconnecting data logger");
 566                 release_device();
 567                 inited = 0;
 568         }
 569
 570         log_info("Terminated");
 571         return 0;
 572 }