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