include/SimpleUpdater.h

 public:
     SimpleUpdater(String _uri = String("/update"));
     void setup(UPDATE_WEB_SERVER *_server);
-    
+    void run(void);
+
 private:
 
 #if defined(ARDUINO_ARCH_ESP8266)
-    
+
     ESP8266HTTPUpdateServer updateServer;
 
 #elif defined(ARDUINO_ARCH_ESP32)
-    
+
     void get(void);
     void postResult(void);
     void postUpload(void);
-    
+
 #endif
-    
+
     String uri;
     UPDATE_WEB_SERVER *server;
 };

include/config.h

 #define INFLUXDB_DATABASE "roomsensorsdiy"
 //#define INFLUX_MAX_ERRORS_RESET 10
 
+// LoRa SML Bridge "Crypto"
+// needs to be sizeof(struct lora_sml_msg) bytes long
+#define LORA_XOR_KEY "_SUPER_SECRET_KEY_HERE_"
+
 // all given in milliseconds
 #define SERVER_HANDLE_INTERVAL 10
 #define SENSOR_HANDLE_INTERVAL (5 * 1000)

include/lora.h

     LORA_SML_NUM_MESSAGES
 };
 
+struct lora_sml_msg {
+    uint8_t type; // enum lora_sml_type
+    double value;
+    uint32_t checksum;
+} __attribute__ ((packed));
+
 #ifdef FEATURE_SML
 void lora_sml_send(enum lora_sml_type msg, double value, unsigned long counter);
 #endif // FEATURE_SML

platformio.ini

 framework = arduino
 upload_protocol = esptool
 upload_port = /dev/ttyUSB2
+# TODO neither web ota nor arduino ota work on heltec esp32?!
+#upload_protocol = espota
+#upload_port = lora-testing
 monitor_port = /dev/ttyUSB2
 monitor_speed = 115200
 extra_scripts = pre:extra_script.py

src/SimpleUpdater.cpp

 #include <ESP8266HTTPUpdateServer.h>
 #elif defined(ARDUINO_ARCH_ESP32)
 #include <Update.h>
+#include <ArduinoOTA.h>
 #endif
 
 #include "config.h"
         get();
     });
 
+    ArduinoOTA.setMdnsEnabled(false);
+
+    ArduinoOTA.onStart([]() {
+        String type;
+        if (ArduinoOTA.getCommand() == U_FLASH) {
+            type = "sketch";
+        } else {  // U_SPIFFS
+            type = "filesystem";
+        }
+
+        // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
+        Serial.println("Start updating " + type);
+    })
+    .onEnd([]() {
+        Serial.println("\nEnd");
+    })
+    .onProgress([](unsigned int progress, unsigned int total) {
+        Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+    })
+    .onError([](ota_error_t error) {
+        Serial.printf("Error[%u]: ", error);
+        if (error == OTA_AUTH_ERROR) {
+            Serial.println("Auth Failed");
+        } else if (error == OTA_BEGIN_ERROR) {
+            Serial.println("Begin Failed");
+        } else if (error == OTA_CONNECT_ERROR) {
+            Serial.println("Connect Failed");
+        } else if (error == OTA_RECEIVE_ERROR) {
+            Serial.println("Receive Failed");
+        } else if (error == OTA_END_ERROR) {
+            Serial.println("End Failed");
+        }
+    });
+
+    ArduinoOTA.begin();
+
 #endif
 }
 
     server = NULL;
 }
 
+void SimpleUpdater::run(void) {
+#ifdef ARDUINO_ARCH_ESP32
+    ArduinoOTA.handle();
+#endif
+}
+
 #endif

src/influx.cpp

 
     ms.addValue(key, value);
 
-    debug.printf("Writing %s %s %s %s %.2lf\n", measurement.c_str(), sensor.c_str(), placement.c_str(), key.c_str(), value);
+    debug.print("Writing ");
+    debug.print(measurement);
+    debug.print(" ");
+    debug.print(sensor);
+    debug.print(" ");
+    debug.print(placement);
+    debug.print(" ");
+    debug.print(key);
+    debug.print(" ");
+    debug.printf("%.2lf\n", value);
     writeMeasurement(ms);
     debug.println(F("Done!"));
 }

src/lora.cpp

 #include "influx.h"
 #include "lora.h"
 
-// define LORA_TEST_TX to periodically transmit a test message
-//#define LORA_TEST_TX
-
 //#define DEBUG_LORA_RX_HEXDUMP
 
 #ifdef FEATURE_SML
 #define LORA_LED_BRIGHTNESS 25 // in percent, 50% brightness is plenty for this LED
 #endif // FEATURE_SML
 
-#ifdef LORA_TEST_TX
-// Pause between transmited packets in seconds.
-// Set to zero to only transmit a packet when pressing the user button
-// Will not exceed 1% duty cycle, even if you set a lower value.
-#define PAUSE               10
-#endif // LORA_TEST_TX
-
 // Frequency in MHz. Keep the decimal point to designate float.
 // Check your own rules and regulations to see what is legal where you are.
 #define FREQUENCY           866.3       // for Europe
 
 #endif // FEATURE_SML
 
-#ifdef LORA_TEST_TX
-static unsigned long test_counter = 0;
-#endif // LORA_TEST_TX
-
 void lora_oled_init(void) {
     heltec_setup();
 }
     return *((double *)data);
 }
 
+// adapted from "Hacker's Delight"
+static uint32_t calc_checksum(const uint8_t *data, size_t len) {
+    uint32_t c = 0xFFFFFFFF;
+    for (size_t i = 0; i < len; i++) {
+        c ^= data[i];
+        for (size_t j = 0; j < 8; j++) {
+            uint32_t mask = -(c & 1);
+            c = (c >> 1) ^ (0xEDB88320 & mask);
+        }
+    }
+
+    return ~c;
+}
+
 static void lora_rx(void) {
     rx_flag = true;
 }
 
-static bool lora_tx(uint8_t *data, size_t len) {
+static bool lora_tx(enum lora_sml_type type, double value) {
     bool tx_legal = millis() > (last_tx + minimum_pause);
     if (!tx_legal) {
         //debug.printf("Legal limit, wait %i sec.\n", (int)((minimum_pause - (millis() - last_tx)) / 1000) + 1);
         return false;
     }
 
+    struct lora_sml_msg msg;
+    msg.type = type;
+    msg.value = value;
+    msg.checksum = calc_checksum((uint8_t *)&msg, offsetof(struct lora_sml_msg, checksum));
+
+    uint8_t *data = (uint8_t *)&msg;
+    const size_t len = sizeof(struct lora_sml_msg);
+
+#ifdef LORA_XOR_KEY
+    for (size_t i = 0; i < len; i++) {
+        data[i] ^= LORA_XOR_KEY[i];
+    }
+#endif
+
     debug.printf("TX [%d] (%lu) ", data[0], len);
     radio.clearDio1Action();
 
 
 #ifdef FEATURE_SML
 static bool lora_sml_cache_send(enum lora_sml_type msg) {
-    const size_t len = sizeof(double) + 1;
-    uint8_t data[len];
-    data[0] = (uint8_t)msg;
-    memcpy(data + 1, &cache[msg].value, sizeof(double));
-    return lora_tx(data, len);
+    return lora_tx(msg, cache[msg].value);
 }
 
 static void lora_sml_handle_cache(void) {
         rx_flag = false;
 
         bool success = true;
-        uint8_t data[sizeof(double) + 1];
+        uint8_t data[sizeof(struct lora_sml_msg)];
         RADIOLIB_CHECK(radio.readData(data, sizeof(data)));
         if (success) {
+#ifdef LORA_XOR_KEY
+            for (size_t i = 0; i < sizeof(data); i++) {
+                data[i] ^= LORA_XOR_KEY[i];
+            }
+#endif
+
             debug.printf("RX [%i]\n", data[0]);
             debug.printf("  RSSI: %.2f dBm\n", radio.getRSSI());
             debug.printf("  SNR: %.2f dB\n", radio.getSNR());
 
 #if defined(DEBUG_LORA_RX_HEXDUMP) || (!defined(ENABLE_INFLUXDB_LOGGING))
             for (int i = 0; i < sizeof(data); i++) {
-                debug.printf("%02X", data[i]);
+                debug.printf("  %02X", data[i]);
                 if (i < (sizeof(data) - 1)) {
                     debug.print(" ");
                 } else {
             }
 #endif
 
-#ifdef ENABLE_INFLUXDB_LOGGING
-            if (data[0] == LORA_SML_BAT_V) {
-                float vbat = NAN;
-                int percent = -1;
-                memcpy(&vbat, data + 1, sizeof(float));
-                memcpy(&percent, data + 1 + sizeof(float), sizeof(int));
-                debug.printf("  Vbat: %.2f (%d%%)\n", vbat, percent);
-
-                writeSensorDatum("environment", "sml", SENSOR_LOCATION, "vbat", vbat);
-                writeSensorDatum("environment", "sml", SENSOR_LOCATION, "percent", percent);
+            struct lora_sml_msg *msg = (struct lora_sml_msg *)data;
+            uint32_t checksum = calc_checksum(data, offsetof(struct lora_sml_msg, checksum));
+            if (checksum != msg->checksum) {
+                debug.printf("  CRC: 0x%08X != 0x%08X\n", msg->checksum, checksum);
             } else {
-                double val = NAN;
-                memcpy(&val, data + 1, sizeof(double));
-                debug.printf("  Value: %.2f\n", val);
-
-                String key;
-                switch (data[0]) {
-                    case LORA_SML_HELLO:
-                        key = "hello";
-                        break;
-
-                    case LORA_SML_SUM_WH:
-                        key = "Sum_Wh";
-                        break;
-
-                    case LORA_SML_T1_WH:
-                        key = "T1_Wh";
-                        break;
-
-                    case LORA_SML_T2_WH:
-                        key = "T2_Wh";
-                        break;
-
-                    case LORA_SML_SUM_W:
-                        key = "Sum_W";
-                        break;
-
-                    case LORA_SML_L1_W:
-                        key = "L1_W";
-                        break;
-
-                    case LORA_SML_L2_W:
-                        key = "L2_W";
-                        break;
-
-                    case LORA_SML_L3_W:
-                        key = "L3_W";
-                        break;
-
-                    default:
-                        key = "unknown";
-                        break;
-                }
+                debug.printf("  CRC: OK 0x%08X\n", checksum);
 
-                writeSensorDatum("environment", "sml", SENSOR_LOCATION, key, val);
-            }
+#ifdef ENABLE_INFLUXDB_LOGGING
+                if (data[0] == LORA_SML_BAT_V) {
+                    // extract mangled float and int from double
+                    float vbat = NAN;
+                    int percent = -1;
+                    memcpy(&vbat, data + offsetof(struct lora_sml_msg, value), sizeof(float));
+                    memcpy(&percent, data + offsetof(struct lora_sml_msg, value) + sizeof(float), sizeof(int));
+                    debug.printf("  Vbat: %.2f (%d%%)\n", vbat, percent);
+
+                    writeSensorDatum("environment", "sml", SENSOR_LOCATION, "vbat", vbat);
+                    writeSensorDatum("environment", "sml", SENSOR_LOCATION, "percent", percent);
+                } else {
+                    debug.printf("  Value: %.2f\n", msg->value);
+
+                    String key;
+                    switch (data[0]) {
+                        case LORA_SML_HELLO:
+                            key = "hello";
+                            break;
+
+                        case LORA_SML_SUM_WH:
+                            key = "Sum_Wh";
+                            break;
+
+                        case LORA_SML_T1_WH:
+                            key = "T1_Wh";
+                            break;
+
+                        case LORA_SML_T2_WH:
+                            key = "T2_Wh";
+                            break;
+
+                        case LORA_SML_SUM_W:
+                            key = "Sum_W";
+                            break;
+
+                        case LORA_SML_L1_W:
+                            key = "L1_W";
+                            break;
+
+                        case LORA_SML_L2_W:
+                            key = "L2_W";
+                            break;
+
+                        case LORA_SML_L3_W:
+                            key = "L3_W";
+                            break;
+
+                        default:
+                            key = "unknown";
+                            break;
+                    }
+
+                    writeSensorDatum("environment", "sml", SENSOR_LOCATION, key, msg->value);
+                }
 #endif // ENABLE_INFLUXDB_LOGGING
+            }
         }
 
         success = true;
     lora_sml_handle_cache();
 #endif // FEATURE_SML
 
-    bool tx_legal = millis() > last_tx + minimum_pause;
-
-#ifdef LORA_TEST_TX
-    // Transmit a packet every PAUSE seconds or when the button is pressed
-    if ((PAUSE && tx_legal && millis() - last_tx > (PAUSE * 1000)) || button.isSingleClick()) {
-        // In case of button click, tell user to wait
-        if (!tx_legal) {
-            debug.printf("Legal limit, wait %i sec.\n", (int)((minimum_pause - (millis() - last_tx)) / 1000) + 1);
-            return;
-        }
-
-        String s = String(test_counter++);
-        lora_tx(s.c_str(), s.length());
-    }
-#else // LORA_TEST_TX
     if (button.isSingleClick()) {
         // In case of button click, tell user to wait
+        bool tx_legal = millis() > last_tx + minimum_pause;
         if (!tx_legal) {
             debug.printf("Legal limit, wait %i sec.\n", (int)((minimum_pause - (millis() - last_tx)) / 1000) + 1);
             return;
         }
 
+        // send test hello message on lorarx target, or battery state on loratx target
 #ifdef FEATURE_SML
         lora_sml_send(LORA_SML_BAT_V, lora_get_mangled_bat(), 0);
 #else // FEATURE_SML
-        uint8_t data[sizeof(double) + 1];
-        data[0] = LORA_SML_HELLO;
-        double tmp = -23.42;
-        memcpy(data + 1, &tmp, sizeof(double));
-        lora_tx(data, sizeof(data));
+        lora_tx(LORA_SML_HELLO, -23.42);
 #endif // FEATURE_SML
     }
-#endif // LORA_TEST_TX
 }
 
 #endif // FEATURE_LORA

src/main.cpp

 #endif // FEATURE_UI
     }
     debug.println(F("\nWiFi connected!"));
+
+    debug.printf("IP: %s\n", WiFi.localIP().toString().c_str());
+    debug.printf("Hostname: %s\n", hostname.c_str());
+
 #ifdef FEATURE_UI
     ui_progress(UI_WIFI_CONNECTED);
 #endif // FEATURE_UI
 #endif // FEATURE_UI
     }
     debug.println(F("\nWiFi connected!"));
+
+    debug.printf("IP: %s\n", WiFi.localIP().toString().c_str());
+    debug.printf("Hostname: %s\n", hostname.c_str());
+
 #ifdef FEATURE_UI
     ui_progress(UI_WIFI_CONNECTED);
 #endif // FEATURE_UI

src/servers.cpp

 static void handleServers() {
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
     server.handleClient();
+    updater.run();
 #else
     http_server();
 #endif
-    
+
 #if defined(ARDUINO_ARCH_ESP8266)
     MDNS.update();
 #endif