2 * Linux Interfece for Arexx Data Loggers
4 * (c) 2011-2012 Martin Mares <mj@ucw.cz>
19 #include <libusb-1.0/libusb.h>
22 #define LOG_PATH "/var/log/arexxd"
24 typedef unsigned char byte;
25 static libusb_context *usb_ctxt;
26 static libusb_device_handle *devh;
28 static int use_syslog;
29 static int debug_mode;
30 static int debug_packets;
31 static int debug_raw_data;
33 static void die(char *fmt, ...)
38 vsyslog(LOG_CRIT, fmt, args);
40 vfprintf(stderr, fmt, args);
41 fprintf(stderr, "\n");
47 static void log_error(char *fmt, ...)
52 vsyslog(LOG_ERR, fmt, args);
54 vfprintf(stderr, fmt, args);
55 fprintf(stderr, "\n");
60 static void log_info(char *fmt, ...)
65 vsyslog(LOG_INFO, fmt, args);
67 vfprintf(stderr, fmt, args);
68 fprintf(stderr, "\n");
73 static void log_pkt(char *fmt, ...)
83 /*** RRD interface ***/
85 #define SLOT_SIZE 10 // 10 seconds per averaging slot
87 #define MAX_ARG_SIZE 1024
90 static char *arg_ptr[MAX_ARGS+1];
91 static char arg_buf[MAX_ARG_SIZE];
94 static void arg_new(void)
98 arg_ptr[0] = "rrdtool";
101 static void arg_push(const char *fmt, ...)
103 if (arg_cnt >= MAX_ARGS)
104 die("MAX_ARGS exceeded");
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;
115 static void rrd_point(time_t t, int id, double val, char *unit)
118 snprintf(rr_name, sizeof(rr_name), "sensor-%d.rrd", id);
121 if (stat(rr_name, &st) < 0 || !st.st_size) {
122 // We have to create the RRD
123 log_info("Creating %s", rr_name);
127 arg_push("%d", (int) time(NULL) - 28*86400);
130 if (!strcmp(unit, "%RH"))
131 arg_push("DS:rh:GAUGE:300:0:100");
132 else if (!strcmp(unit, "ppm"))
133 arg_push("DS:ppm:GAUGE:300:0:1000000");
135 arg_push("DS:temp:GAUGE:300:-200:200");
136 arg_push("RRA:AVERAGE:0.25:1:20160"); // Last 14 days with full resolution
137 arg_push("RRA:AVERAGE:0.25:60:88800"); // Last 10 years with 1h resolution
138 arg_push("RRA:MIN:0.25:60:88800"); // including minima and maxima
139 arg_push("RRA:MAX:0.25:60:88800");
140 rrd_create(arg_cnt, arg_ptr);
141 if (rrd_test_error()) {
142 log_error("rrd_create on %s failed: %s", rr_name, rrd_get_error());
149 arg_push("%d:%f", t, val);
150 rrd_update(arg_cnt, arg_ptr);
151 if (rrd_test_error())
152 log_error("rrd_update on %s failed: %s", rr_name, rrd_get_error());
157 #define TIME_OFFSET 946681200 // Timestamp of 2000-01-01 00:00:00
159 static int data_point_counter;
161 static double correct_point(int id, double val)
164 * Manually calculated corrections for my sensors.
165 * Replace with your formulae.
179 static void cooked_point(time_t t, int id, double val, char *unit, int q)
181 double val2 = correct_point(id, val);
183 if (debug_raw_data) {
185 localtime_r(&t, &tm);
187 strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm);
188 printf("== %s id=%d val=%.3f val2=%.3f unit=%s q=%d\n", tbuf, id, val, val2, unit, q);
191 data_point_counter++;
192 rrd_point(t, id, val2, unit);
195 static void raw_point(int t, int id, int raw, int q)
198 * The binary blob provided by Arexx contains an embedded XML fragment
199 * with descriptions of all known sensor types. If you want to see it,
200 * grep the blob for "<deviceinfo>". The meanings of the parameters are
203 * m1, m2 Device type matches if (raw_sensor_id & m1) == m2
204 * type Unit measured by the sensor (1=Celsius, 2=RH%, 3=CO2 ppm)
205 * dm User-visible sensor ID = raw_sensor_id & dm
206 * i 1 if the raw value is signed
207 * p[] Coefficients of transformation polynomial (x^0 first)
208 * vLo, vUp Upper and lower bound on the final value
209 * scale Scaling function:
210 * 0 = identity (default)
213 * 3 = (x < 0) ? 0 : log10(x)
214 * 4 = (x < 0) ? 0 : log(x)
216 * The raw values are transformed this way:
217 * - sign-extend if signed
218 * - apply the transformation polynomial
219 * - apply the scaling function
220 * - drop if outside the interval [vLo,vUp]
222 * This function applies the necessary transform for sensors we've
223 * seen in the wild. We deliberately ignore the "dm" parameter as we want
224 * to report different channels of a single sensor as multiple sensors.
230 int idhi = id & 0xf000;
232 if (idhi == 0x1000) {
237 } else if (idhi == 0x2000) {
244 } else if (idhi == 0x4000) {
251 z = -2.8e-6*z*z + 0.0405*z - 4;
256 } else if (idhi == 0x6000) {
266 z = (z + 1.9184e-7) * z;
267 z = (z - 1.0998e-3) * z;
275 log_error("Unknown sensor type 0x%04x", id);
279 if (z < lo || z > hi) {
280 log_error("Sensor %d: value %f out of range", id, z);
284 cooked_point(t + TIME_OFFSET, id, z, unit, q);
287 /*** USB interface ***/
289 static int find_device(void)
291 libusb_device **devlist;
292 ssize_t devn = libusb_get_device_list(usb_ctxt, &devlist);
294 log_error("Cannot enumerate USB devices: error %d", (int) devn);
298 for (ssize_t i=0; i<devn; i++) {
299 struct libusb_device_descriptor desc;
300 libusb_device *dev = devlist[i];
301 if (!libusb_get_device_descriptor(dev, &desc)) {
302 if (desc.idVendor == 0x0451 && desc.idProduct == 0x3211) {
303 log_info("Arexx data logger found at usb%d.%d", libusb_get_bus_number(dev), libusb_get_device_address(dev));
305 if (err = libusb_open(dev, &devh)) {
306 log_error("libusb_open() failed: error %d", err);
309 if (err = libusb_claim_interface(devh, 0)) {
310 log_error("libusb_claim_interface() failed: error %d", err);
314 libusb_free_device_list(devlist, 1);
321 libusb_free_device_list(devlist, 1);
325 static void release_device(void)
331 static void dump_packet(byte *pkt)
333 for (int i=0; i<64; i++) {
335 log_pkt("\t%02x:", i);
336 log_pkt(" %02x", pkt[i]);
342 static int send_and_receive(byte *req, byte *reply)
345 time_t t = time(NULL);
347 localtime_r(&t, &tm);
350 strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm);
351 log_pkt("## %s\n", tbuf);
354 int err, transferred;
355 if (err = libusb_bulk_transfer(devh, 0x01, req, 64, &transferred, 200)) {
356 if (err == LIBUSB_ERROR_TIMEOUT) {
357 log_pkt(">> xmit timed out\n");
360 log_pkt(">> xmit error %d\n", err);
361 log_error("Transmit error: %d", err);
365 log_pkt(">> xmit %d bytes\n", transferred);
368 if (err = libusb_bulk_transfer(devh, 0x81, reply, 64, &transferred, 200)) {
369 if (err == LIBUSB_ERROR_TIMEOUT) {
370 log_pkt("<< recv timed out\n");
373 log_pkt("<< recv error %d\n", err);
374 log_error("Receive error: %d", err);
378 log_pkt("<< recv %d bytes\n", transferred);
379 while (transferred < 64)
380 reply[transferred++] = 0xff;
386 static unsigned int get_be16(byte *p)
388 return p[1] | (p[0] << 8);
391 static unsigned int get_le16(byte *p)
393 return p[0] | (p[1] << 8);
396 static unsigned int get_le32(byte *p)
398 return get_le16(p) | (get_le16(p+2) << 16);
401 static void put_le16(byte *p, unsigned int x)
407 static void put_le32(byte *p, unsigned int x)
410 put_le16(p+2, x>>16);
413 static int parse_packet(byte *reply)
416 log_error("Unknown packet type %02x", reply[0]);
423 byte *p = reply + pos;
425 if (!len || len == 0xff)
427 if (len < 9 || len > 10) {
428 log_error("Unknown tuple length %02x", len);
431 if (pos + len > 64) {
432 log_error("Tuple truncated");
435 int id = get_le16(p+1);
436 int raw = get_be16(p+3);
437 int t = get_le32(p+5);
438 int q = (len > 9) ? p[9] : -1;
439 if (debug_raw_data) {
440 printf("... %02x: id=%d raw=%d t=%d", len, id, raw, t);
445 raw_point(t, id, raw, q);
453 static void set_clock(void)
455 byte req[64], reply[64];
458 time_t t = time(NULL);
459 put_le32(req+1, t-TIME_OFFSET);
460 send_and_receive(req, reply);
464 * Original software also sends a packet with type 3 and the timestamp,
465 * but it does not make any sense, especially as they ignore the sensor
466 * readings in the answer.
469 send_and_receive(req, reply);
476 static volatile sig_atomic_t want_shutdown;
478 static void sigterm_handler(int sig __attribute__((unused)))
483 static const struct option long_options[] = {
484 { "debug", 0, NULL, 'd' },
485 { "log-packets", 0, NULL, 'p' },
486 { NULL, 0, NULL, 0 },
489 static void usage(void)
491 fprintf(stderr, "Usage: arexxd [--debug] [--log-packets]\n");
495 int main(int argc, char **argv)
498 while ((opt = getopt_long(argc, argv, "dp", long_options, NULL)) >= 0)
514 if (err = libusb_init(&usb_ctxt))
515 die("Cannot initialize libusb: error %d", err);
516 // libusb_set_debug(usb_ctxt, 3);
519 if (chdir(LOG_PATH) < 0)
520 die("Cannot change directory to %s: %m", LOG_PATH);
521 if (debug_packets || debug_raw_data) {
523 if (open("debug", O_WRONLY | O_CREAT | O_APPEND, 0666) < 0)
524 die("Cannot open debug log: %m");
527 openlog("arexxd", LOG_NDELAY, LOG_DAEMON);
530 die("fork() failed: %m");
537 struct sigaction sa = { .sa_handler = sigterm_handler };
538 sigaction(SIGTERM, &sa, NULL);
539 sigaction(SIGINT, &sa, NULL);
542 sigemptyset(&term_sigs);
543 sigaddset(&term_sigs, SIGTERM);
544 sigaddset(&term_sigs, SIGINT);
545 sigprocmask(SIG_BLOCK, &term_sigs, NULL);
548 while (!want_shutdown) {
549 if (!find_device()) {
552 log_error("Data logger not connected, waiting until it appears");
557 log_info("Listening");
559 time_t last_sync = 0;
560 time_t last_show = 0;
563 data_point_counter = 0;
564 while (!want_shutdown) {
565 time_t now = time(NULL);
566 if (now > last_sync + 900) {
567 log_info("Synchronizing data logger time");
571 if (want_stats && now > last_show + 300) {
572 log_info("Stats: received %d data points", data_point_counter);
573 data_point_counter = 0;
577 byte req[64], reply[64];
578 memset(req, 0, sizeof(req));
580 err = send_and_receive(req, reply);
584 if (err > 0 && parse_packet(reply))
586 sigprocmask(SIG_UNBLOCK, &term_sigs, NULL);
591 sigprocmask(SIG_BLOCK, &term_sigs, NULL);
594 log_info("Disconnecting data logger");
599 log_info("Terminated");