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