add experimental influxdb support

include/config.h

 #define AUTO_LOG_ON_MASS_STORAGE
 #endif // NDEBUG
 
+//#define INFLUXDB_HOST "IP_V4_HERE"
+//#define INFLUXDB_PORT 8086
+//#define INFLUXDB_DATABASE "db_name"
+
 #define WATCHDOG_PERIOD_MS 1000
 #define FLASH_LOCK_TIMEOUT_MS 500
 

include/wifi.h

 
 void wifi_run(void);
 
+void wifi_tcp_send(const char *ip, uint16_t port, const char *packet, unsigned int len);
+
 #endif // __WIFI_H__

src/log.c

 static uint8_t log_buff[4096] = {0};
 static struct ring_buffer log_rb = RB_INIT(log_buff, sizeof(log_buff), 1);
 
-static uint8_t line_buff[256] = {0};
+static uint8_t line_buff[512] = {0};
 static volatile bool got_input = false;
 
 #ifndef PICOWOTA

src/wifi.c

 #include "pico/cyw43_arch.h"
 #include "lwip/netif.h"
 #include "lwip/ip4_addr.h"
+#include "lwip/tcp.h"
 #include "dhcpserver.h"
 
 #include "config.h"
 static char curr_ssid[WIFI_MAX_NAME_LEN + 1] = {0};
 static char curr_pass[WIFI_MAX_PASS_LEN + 1] = {0};
 
+struct wifi_tcp_cache {
+    bool in_use;
+    bool clear; // TODO
+    ip4_addr_t ip;
+    uint16_t port;
+    struct tcp_pcb *tpcb;
+    char data[512];
+    unsigned int len;
+};
+
+static struct wifi_tcp_cache cache[4] = {0};
+
 static void wifi_ap(void) {
     cyw43_thread_enter();
 
     return NULL;
 }
 
+static err_t wifi_tcp_connect(void *arg, struct tcp_pcb *tpcb, err_t err) {
+    (void)err;
+    int c = (int)arg;
+
+    err_t e = tcp_write(tpcb, cache[c].data, cache[c].len, TCP_WRITE_FLAG_COPY);
+    if (e) {
+        debug("tcp_write error %d", e);
+        cache[c].clear = true;
+        return ERR_OK;
+    }
+
+    e = tcp_output(tpcb);
+    if (e) {
+        debug("tcp_output error %d", e);
+        cache[c].clear = true;
+        return ERR_OK;
+    }
+
+    return ERR_OK;
+}
+
+static void wifi_tcp_error(void *arg, err_t err) {
+    int c = (int)arg;
+    debug("tcp err %d", err);
+    cache[c].in_use = false; // lwip already freed the tpcb
+}
+
+static err_t wifi_tcp_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
+    (void)tpcb;
+    (void)err;
+    int c = (int)arg;
+    if (p == NULL) {
+        debug("remote closed conn");
+        cache[c].clear = true;
+    } else {
+        debug("tcp rx %d: %s", pbuf_clen(p), (char *)p->payload);
+        cache[c].clear = true;
+    }
+    return ERR_OK;
+}
+
+static err_t wifi_tcp_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) {
+    (void)tpcb;
+    int c = (int)arg;
+    if (len == cache[c].len) {
+        debug("tcp tx success");
+        cache[c].clear = true;
+    }
+    return ERR_OK;
+}
+
+void wifi_tcp_send(const char *ip, uint16_t port, const char *packet, unsigned int len) {
+    cyw43_arch_lwip_begin();
+
+    ip4_addr_t val;
+    if (!ip4addr_aton(ip, &val)) {
+        debug("invalid IP: %s", ip);
+        cyw43_arch_lwip_end();
+        return;
+    }
+
+    int c = -1;
+    for (unsigned int i = 0; i < (sizeof(cache) / sizeof(cache[0])); i++) {
+        if (!cache[i].in_use) {
+            c = i;
+        }
+    }
+    if (c < 0) {
+        debug("no space in cache");
+        cyw43_arch_lwip_end();
+        return;
+    }
+
+    cache[c].in_use = true;
+    cache[c].clear = false;
+    cache[c].ip = val;
+    cache[c].port = port;
+    cache[c].tpcb = tcp_new();
+
+    if (len > sizeof(cache[c].data)) {
+        len = sizeof(cache[c].data);
+    }
+
+    cache[c].len = len;
+    memcpy(cache[c].data, packet, len);
+
+    tcp_arg(cache[c].tpcb, (void *)c);
+    tcp_err(cache[c].tpcb, wifi_tcp_error);
+    tcp_recv(cache[c].tpcb, wifi_tcp_recv);
+    tcp_sent(cache[c].tpcb, wifi_tcp_sent);
+    tcp_connect(cache[c].tpcb, &val, port, wifi_tcp_connect);
+
+    cyw43_arch_lwip_end();
+}
+
 void wifi_run(void) {
     cyw43_thread_enter();
 
         }
     }
 
+    for (unsigned int c = 0; c < (sizeof(cache) / sizeof(cache[0])); c++) {
+        if (cache[c].in_use && cache[c].clear) {
+            tcp_close(cache[c].tpcb);
+            cache[c].in_use = false;
+        }
+    }
+
     cyw43_thread_exit();
 }

src/workflow.c

 #include "volcano.h"
 #include "workflow.h"
 
+#if defined(INFLUXDB_HOST) && defined(INFLUXDB_PORT) && defined(INFLUXDB_DATABASE)
+#include "usb_descriptors.h"
+#include "wifi.h"
+#define VOLCANO_INFLUX_DB
+#endif
+
 #ifdef WF_CONFIRM_WRITES
 #define DO_WHILE(x, y) \
     do {               \
 static uint16_t start_val = 0;
 static uint16_t curr_val = 0;
 
+#ifdef VOLCANO_INFLUX_DB
+static void influxdb_send(const char *name, double value) {
+    if (!wifi_ready()) {
+        debug("skip influx, no wifi (\"%s\" %.2lf)", name, value);
+        return;
+    }
+
+    char payload[128] = {0};
+    size_t len = 0;
+    len = snprintf(payload, sizeof(payload) - 1,
+                   "volcano,device=%s %s=%lf",
+                   string_pico_serial, name, value);
+
+
+    char packet[256] = {0};
+    size_t n = 0;
+    n = snprintf(packet, sizeof(packet) - 1,
+                  "POST /write?db=%s HTTP/1.0\r\n"
+                  "Host: %s\r\n"
+                  "Content-Length: %d\r\n"
+                  "\r\n"
+                  "%s",
+                  INFLUXDB_DATABASE, INFLUXDB_HOST,
+                 len, payload);
+
+    debug("write influx \"%s\": %.2lf", name, value);
+    wifi_tcp_send(INFLUXDB_HOST, INFLUXDB_PORT, packet, n);
+}
+#endif // VOLCANO_INFLUX_DB
+
 static void do_step(void) {
     switch (mem_data()->wf[wf_i].steps[step].op) {
     case OP_SET_TEMPERATURE:
         start_val = volcano_get_current_temp();
         DO_WHILE(volcano_set_target_temp(mem_data()->wf[wf_i].steps[step].val),
                  volcano_get_target_temp() != mem_data()->wf[wf_i].steps[step].val);
+#ifdef VOLCANO_INFLUX_DB
+        influxdb_send("target", mem_data()->wf[wf_i].steps[step].val);
+#endif // VOLCANO_INFLUX_DB
         break;
 
     case OP_PUMP_TIME:
         start_t = to_ms_since_boot(get_absolute_time());
         start_val = 0;
         debug("workflow pump %.3f s", mem_data()->wf[wf_i].steps[step].val / 1000.0);
+#ifdef VOLCANO_INFLUX_DB
+        influxdb_send("pump", 1);
+#endif // VOLCANO_INFLUX_DB
         break;
 
     case OP_WAIT_TIME:
              !(volcano_get_state() & VOLCANO_STATE_HEATER));
     volcano_discover_characteristics(true, false);
 
+#ifdef VOLCANO_INFLUX_DB
+    influxdb_send("heater", 1);
+#endif // VOLCANO_INFLUX_DB
+
     do_step();
 }
 
     case OP_WAIT_TEMPERATURE: {
         uint16_t temp = volcano_get_current_temp();
 
+#ifdef VOLCANO_INFLUX_DB
+        static uint16_t last_temp = 0;
+        if (last_temp != temp) {
+            influxdb_send("current", temp);
+            last_temp = temp;
+        }
+#endif // VOLCANO_INFLUX_DB
+
         // volcano does not provide a temperature when cold
         if (start_val == 0) {
             start_val = temp;
         if (mem_data()->wf[wf_i].steps[step].op == OP_PUMP_TIME) {
             DO_WHILE(volcano_set_pump_state(false),
                      volcano_get_state() & VOLCANO_STATE_PUMP);
+#ifdef VOLCANO_INFLUX_DB
+            influxdb_send("pump", 0);
+#endif // VOLCANO_INFLUX_DB
         }
 
         step++;
             DO_WHILE(volcano_set_heater_state(false),
                      volcano_get_state() & VOLCANO_STATE_HEATER);
             debug("workflow finished");
+
+#ifdef VOLCANO_INFLUX_DB
+            influxdb_send("heater", 0);
+#endif // VOLCANO_INFLUX_DB
         } else {
             do_step();
         }