ssr/host/burrow-ssrd.c

   1 /*
   2  *      A MQTT Gateway Daemon for the Solid State Relay module
   3  *
   4  *      (c) 2018 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include <ucw/lib.h>
   8 #include <ucw/log.h>
   9 #include <ucw/opt.h>
  10 #include <ucw/strtonum.h>
  11 #include <ucw/unaligned.h>
  12
  13 #include <stdarg.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <syslog.h>
  18 #include <time.h>
  19
  20 #include <libusb-1.0/libusb.h>
  21 #include <mosquitto.h>
  22
  23 static struct libusb_context *usb_ctxt;
  24 static struct libusb_device_handle *devh;
  25
  26 static struct mosquitto *mosq;
  27
  28 static u32 ssr_state;
  29
  30 void open_device(void)
  31 {
  32         int err;
  33         libusb_device **devlist;
  34         ssize_t devn = libusb_get_device_list(usb_ctxt, &devlist);
  35         if (devn < 0)
  36                 die("Cannot enumerate USB devices: error %d", (int) devn);
  37
  38         for (ssize_t i=0; i<devn; i++) {
  39                 struct libusb_device_descriptor desc;
  40                 libusb_device *dev = devlist[i];
  41                 if (!libusb_get_device_descriptor(dev, &desc)) {
  42                         if (desc.idVendor == 0x4242 && desc.idProduct == 0x0002) {
  43                                 msg(L_INFO, "Found SSR module at usb%d.%d", libusb_get_bus_number(dev), libusb_get_device_address(dev));
  44
  45                                 if (err = libusb_open(dev, &devh))
  46                                         die("Cannot open device: error %d", err);
  47                                 libusb_reset_device(devh);
  48                                 if (err = libusb_claim_interface(devh, 0))
  49                                         die("Cannot claim interface: error %d", err);
  50
  51                                 libusb_free_device_list(devlist, 1);
  52                                 return;
  53                         }
  54                 }
  55         }
  56
  57         libusb_free_device_list(devlist, 1);
  58         die("Device not found");
  59 }
  60
  61 static byte req[64], resp[64];
  62
  63 static int transaction(uint req_len, uint resp_len)
  64 {
  65         int err, transferred;
  66         if (err = libusb_bulk_transfer(devh, 0x01, req, req_len, &transferred, 2000))
  67                 die("Transfer failed: error %d\n", err);
  68         // printf("Transferred %d bytes\n", transferred);
  69
  70         int received;
  71         if (err = libusb_bulk_transfer(devh, 0x82, resp, 64, &received, 2000))
  72                 die("Receive failed: error %d\n", err);
  73         // printf("Received %d bytes\n", received);
  74
  75         if ((uint) received < resp_len)
  76                 die("Received short packet (%u out of %u bytes)", received, resp_len);
  77
  78         if (received >= 4) {
  79                 uint status = get_u32_be(resp);
  80                 if (status)
  81                         die("Received error status %08x", status);
  82         }
  83
  84         return received;
  85 }
  86
  87 static void set_relays(void)
  88 {
  89         msg(L_INFO, "Setting relays to %02x", ssr_state);
  90         put_u32_be(req, 1);
  91         put_u32_be(req+4, ssr_state);
  92         transaction(8, 4);
  93 }
  94
  95 static void mqtt_publish(const char *topic, const char *fmt, ...)
  96 {
  97         va_list args;
  98         va_start(args, fmt);
  99         char m[256];
 100         int l = vsnprintf(m, sizeof(m), fmt, args);
 101         if (mosquitto_publish(mosq, NULL, topic, l, m, 0, true) != MOSQ_ERR_SUCCESS)
 102                 msg(L_ERROR, "Mosquitto: publish failed");
 103         va_end(args);
 104 }
 105
 106 static void mqtt_setup(void)
 107 {
 108         if (mosquitto_subscribe(mosq, NULL, "burrow/loft/#", 1) != MOSQ_ERR_SUCCESS)
 109                 die("Mosquitto: subscribe failed");
 110
 111         mqtt_publish("burrow/loft/status", "ok");
 112 }
 113
 114 static void mqtt_log_callback(struct mosquitto *mosq UNUSED, void *obj UNUSED, int level, const char *message)
 115 {
 116         // msg(L_INFO, "MQTT(%d): %s", level, message);
 117 }
 118
 119 static void mqtt_msg_callback(struct mosquitto *mosq UNUSED, void *obj UNUSED, const struct mosquitto_message *m)
 120 {
 121         char val[256];
 122         if (m->payloadlen >= sizeof(val) - 1) {
 123                 msg(L_ERROR, "Invalid value for topic %s", m->topic);
 124                 return;
 125         }
 126         memcpy(val, m->payload, m->payloadlen);
 127         val[m->payloadlen] = 0;
 128         msg(L_DEBUG, "MQTT < %s %s", m->topic, val);
 129
 130         if (!strcmp(m->topic, "burrow/loft/fan")) {
 131                 uint x;
 132                 const char *err;
 133                 if ((err = str_to_uint(&x, val, NULL, 10 | STN_WHOLE)) || x >= 4) {
 134                         msg(L_ERROR, "Received invalid fan setting %s: %s", val, err);
 135                         x = 0;
 136                 }
 137                 msg(L_INFO, "Setting fan level to %u", x);
 138                 ssr_state &= ~7U;
 139                 switch (x) {
 140                         case 1:
 141                                 ssr_state |= 4;
 142                                 break;
 143                         case 2:
 144                                 ssr_state |= 2;
 145                                 break;
 146                         case 3:
 147                                 ssr_state |= 1;
 148                                 break;
 149                 }
 150                 set_relays();
 151         } else if (!strcmp(m->topic, "burrow/loft/circulation")) {
 152                 uint x;
 153                 const char *err;
 154                 if ((err = str_to_uint(&x, val, NULL, 10 | STN_WHOLE)) || x >= 2) {
 155                         msg(L_ERROR, "Received invalid circulation setting %s: %s", val, err);
 156                         x = 0;
 157                 }
 158                 msg(L_INFO, "Setting circulation to %u", x);
 159                 ssr_state &= ~8U;
 160                 if (x)
 161                         ssr_state |= 8;
 162         }
 163 }
 164
 165 static int use_daemon;
 166 static int use_debug;
 167
 168 static struct opt_section options = {
 169         OPT_ITEMS {
 170                 OPT_HELP("A daemon for controlling the solid state relay module via MQTT"),
 171                 OPT_HELP(""),
 172                 OPT_HELP("Options:"),
 173                 OPT_BOOL('d', "debug", use_debug, 0, "\tLog debugging messages"),
 174                 OPT_BOOL(0, "daemon", use_daemon, 0, "\tDaemonize"),
 175                 OPT_HELP_OPTION,
 176                 OPT_CONF_OPTIONS,
 177                 OPT_END
 178         }
 179 };
 180
 181 int main(int argc UNUSED, char **argv)
 182 {
 183         log_init(argv[0]);
 184         opt_parse(&options, argv+1);
 185
 186         if (use_daemon) {
 187                 struct log_stream *ls = log_new_syslog("daemon", LOG_PID);
 188                 log_set_default_stream(ls);
 189         }
 190         if (!use_debug)
 191                 log_default_stream()->levels &= ~(1U << L_DEBUG);
 192
 193         int err;
 194         if (err = libusb_init(&usb_ctxt))
 195                 die("Cannot initialize libusb: error %d", err);
 196         if (use_debug)
 197                 libusb_set_debug(usb_ctxt, 3);
 198         open_device();
 199         set_relays();
 200
 201         mosquitto_lib_init();
 202         mosq = mosquitto_new("ssrd", 1, NULL);
 203         if (!mosq)
 204                 die("Mosquitto: initialization failed");
 205
 206         mosquitto_log_callback_set(mosq, mqtt_log_callback);
 207         mosquitto_message_callback_set(mosq, mqtt_msg_callback);
 208
 209         if (mosquitto_will_set(mosq, "burrow/loft/status", 4, "dead", 0, true) != MOSQ_ERR_SUCCESS)
 210                 die("Mosquitto: unable to set will");
 211
 212         if (mosquitto_connect(mosq, "127.0.0.1", 1883, 60) != MOSQ_ERR_SUCCESS)
 213                 die("Mosquitto: connect failed");
 214
 215         mqtt_setup();
 216
 217         time_t next_run = 0;
 218         for (;;) {
 219                 time_t now = time(NULL);
 220                 if (now < next_run) {
 221                         int err = mosquitto_loop(mosq, (next_run - now) * 1000, 1);
 222                         if (err == MOSQ_ERR_NO_CONN) {
 223                                 err = mosquitto_reconnect(mosq);
 224                                 if (err == MOSQ_ERR_SUCCESS)
 225                                         mqtt_setup();
 226                                 else
 227                                         msg(L_ERROR, "Mosquitto: cannot reconnect, error %d", err);
 228                         } else if (err != MOSQ_ERR_SUCCESS)
 229                                 msg(L_ERROR, "Mosquitto: loop returned error %d", err);
 230                         continue;
 231                 }
 232
 233                 next_run = now + 5;
 234
 235                 put_u32_be(req, 2);
 236                 transaction(8, 8);
 237                 int t = get_u32_be(resp+4);
 238                 msg(L_DEBUG, "Measured raw temperature %d", t);
 239
 240                 mqtt_publish("burrow/loft/temperature", "%.3f", t / 1000.);
 241                 mqtt_publish("burrow/loft/timestamp", "%llu", (unsigned long long) now);
 242         }
 243 }