try to save more energy and reduce hangs

compile_commands.json

-.pio/build/lorarx/compile_commands.json
+.pio/build/loratx/compile_commands.json

include/lora.h

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

platformio.ini

   -DFEATURE_LORA
   -DFEATURE_SML
   -DFEATURE_DISABLE_WIFI
+  -DDISABLE_SENSORS
 lib_deps =
     https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
     https://github.com/rlogiacco/CircularBuffer.git#f29cf01b6e8603422f3668d51036ac124f803404

src/lora.cpp

 
 #include <Arduino.h>
 
-// Turns the 'PRG' button into the power button, long press is off
-// this also increases deep sleep power usage!
-#ifndef FEATURE_SML
+#ifdef FEATURE_SML
+#define HELTEC_NO_DISPLAY
+#else // FEATURE_SML
 #define HELTEC_POWER_BUTTON
-#endif // ! FEATURE_SML
+#endif // FEATURE_SML
 
 #include <heltec_unofficial.h>
 
 
 #ifdef FEATURE_SML
 #define LORA_LED_BRIGHTNESS 0 // in percent, 50% brightness is plenty for this LED
-#define OLED_BAT_INTERVAL (2UL * 60UL * 1000UL) // in ms
-#define FORCE_BAT_SEND_AT_OLED_INTERVAL
-#define DEEP_SLEEP_TIMEOUT_MS (1UL * 60UL * 1000UL) // gather data for 1min
-#define DEEP_SLEEP_ABORT_NO_DATA_MS (20UL * 1000UL) // if no data appears, abort after 20s
-#define DEEP_SLEEP_DURATION_S (5UL * 60UL) // then sleep for 5min
+#define DEEP_SLEEP_DURATION_S 60
+#define DEEP_SLEEP_TIMEOUT_MS (30UL * 1000UL)
+#define DEEP_SLEEP_ABORT_NO_DATA_MS DEEP_SLEEP_TIMEOUT_MS
 #else // FEATURE_SML
 #define LORA_LED_BRIGHTNESS 25 // in percent, 50% brightness is plenty for this LED
 #endif // FEATURE_SML
 static unsigned long tx_time = 0, minimum_pause = 0;
 static volatile bool rx_flag = false;
 
+#ifndef LORA_KEEP_SENDING_CACHE
+RTC_DATA_ATTR static uint8_t last_tx_msg = LORA_SML_HELLO;
+#endif // ! LORA_KEEP_SENDING_CACHE
+
 #ifdef FEATURE_SML
 
 struct sml_cache {
 }
 
 void lora_oled_print(String s) {
+#ifndef FEATURE_SML
     display.print(s);
+#endif // ! FEATURE_SML
 }
 
 static void print_bat(void) {
     return *((double *)data);
 }
 
+#ifdef LORA_CLIENT_CHECKSUM
 // adapted from "Hacker's Delight"
 static uint32_t calc_checksum(const uint8_t *data, size_t len) {
     uint32_t c = 0xFFFFFFFF;
 
     return ~c;
 }
+#endif // LORA_CLIENT_CHECKSUM
 
 static void lora_rx(void) {
     rx_flag = true;
     struct lora_sml_msg msg;
     msg.type = type;
     msg.value = value;
+
+#ifdef LORA_CLIENT_CHECKSUM
     msg.checksum = calc_checksum((uint8_t *)&msg, offsetof(struct lora_sml_msg, checksum));
+#endif // LORA_CLIENT_CHECKSUM
 
     uint8_t *data = (uint8_t *)&msg;
     const size_t len = sizeof(struct lora_sml_msg);
     for (size_t i = 0; i < len; i++) {
         data[i] ^= LORA_XOR_KEY[i];
     }
-#endif
+#endif // LORA_XOR_KEY
 
     radio.clearDio1Action();
 
 }
 
 #ifdef FEATURE_SML
-static bool lora_sml_cache_send(enum lora_sml_type msg) {
-    return lora_tx(msg, cache[msg].value);
-}
 
+#ifdef LORA_KEEP_SENDING_CACHE
 static void lora_sml_handle_cache(void) {
     // find smallest message counter that is ready
     unsigned long min_counter = ULONG_MAX;
     // try to transmit next value with lowest counter
     for (int i = 0; i < LORA_SML_NUM_MESSAGES; i++) {
         if (cache[i].ready && (cache[i].counter == min_counter)) {
-            if (lora_sml_cache_send((enum lora_sml_type)i)) {
+            enum lora_sml_type msg = (enum lora_sml_type)i;
+            if (lora_tx(msg, cache[msg].value)) {
                 if (cache[i].has_next) {
                     cache[i].has_next = false;
                     cache[i].value = cache[i].next_value;
         }
     }
 }
+#endif // LORA_KEEP_SENDING_CACHE
 
 void lora_sml_send(enum lora_sml_type msg, double value, unsigned long counter) {
     if (cache[msg].ready) {
         cache[msg].counter = counter;
     }
 }
+
+void lora_sml_done(void) {
+#ifndef LORA_KEEP_SENDING_CACHE
+    // turn off Ve external 3.3V to Smart Meter reader
+    heltec_ve(false);
+
+    // select next message from cache
+    uint8_t n = 0;
+    do {
+        last_tx_msg++;
+        n++;
+        if (last_tx_msg >= LORA_SML_NUM_MESSAGES) {
+            last_tx_msg = 0;
+        }
+    } while ((!cache[last_tx_msg].ready) && (n < LORA_SML_NUM_MESSAGES + 1));
+
+    // transmit it
+    if (cache[last_tx_msg].ready) {
+        enum lora_sml_type msg = (enum lora_sml_type)last_tx_msg;
+        lora_tx(msg, cache[msg].value);
+    }
+
+    heltec_deep_sleep(DEEP_SLEEP_DURATION_S < (minimum_pause / 1000) ? (minimum_pause / 1000) : DEEP_SLEEP_DURATION_S);
+#endif // ! LORA_KEEP_SENDING_CACHE
+}
+
 #endif // FEATURE_SML
 
 void lora_init(void) {
         cache[i].counter = 0;
         cache[i].next_counter = 0;
     }
-#endif // FEATURE_SML
 
-    print_bat();
+    //print_bat();
+#endif // FEATURE_SML
 
     bool success = true;
 
 #ifdef FEATURE_SML
     // turn on Ve external 3.3V to power Smart Meter reader
     heltec_ve(true);
-
-    // send hello msg after boot
-    lora_sml_send(LORA_SML_HELLO, heltec_temperature(), 0);
 #endif // FEATURE_SML
 }
 
     bool got_sml = sml_data_received();
     if ((got_sml && (time >= DEEP_SLEEP_TIMEOUT_MS))
             || ((!got_sml) && (time >= DEEP_SLEEP_ABORT_NO_DATA_MS))) {
-        heltec_deep_sleep(DEEP_SLEEP_DURATION_S);
+        heltec_deep_sleep(DEEP_SLEEP_DURATION_S < (minimum_pause / 1000) ? (minimum_pause / 1000) : DEEP_SLEEP_DURATION_S);
     }
 #endif // DEEP_SLEEP_TIMEOUT_MS && DEEP_SLEEP_DURATION_S
 
 #endif
 
             struct lora_sml_msg *msg = (struct lora_sml_msg *)data;
+
+#ifdef LORA_CLIENT_CHECKSUM
             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 {
                 debug.printf("  CRC: OK 0x%08X\n", checksum);
+#endif // LORA_CLIENT_CHECKSUM
 
 #ifdef ENABLE_INFLUXDB_LOGGING
                 if (data[0] == LORA_SML_BAT_V) {
                     writeSensorDatum("environment", "sml", SENSOR_LOCATION, key, msg->value);
                 }
 #endif // ENABLE_INFLUXDB_LOGGING
+
+#ifdef LORA_CLIENT_CHECKSUM
             }
+#endif // LORA_CLIENT_CHECKSUM
         }
 
 #ifndef FEATURE_SML
 #endif // ! FEATURE_SML
     }
 
-#ifdef FEATURE_SML
+#ifdef LORA_KEEP_SENDING_CACHE
     lora_sml_handle_cache();
-#endif // FEATURE_SML
+#endif // LORA_KEEP_SENDING_CACHE
 
+#ifndef FEATURE_SML
     if (button.isSingleClick()) {
         // In case of button click, tell user to wait
         bool tx_legal = millis() > last_tx + minimum_pause;
             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
         lora_tx(LORA_SML_HELLO, heltec_temperature());
-#endif // FEATURE_SML
     }
+#endif // ! FEATURE_SML
 }
 
 #endif // FEATURE_LORA

src/main.cpp

 #include <ESP8266WiFi.h>
 #elif defined(ARDUINO_ARCH_ESP32)
 #include <WiFi.h>
+#include <esp_task_wdt.h>
 #elif defined(ARDUINO_ARCH_AVR)
 #include <UnoWiFiDevEdSerial1.h>
 #include <WiFiLink.h>
 
     debug.println(F("Initializing..."));
 
+#ifndef FEATURE_LORA
     // Blink LED for init
     for (int i = 0; i < 2; i++) {
         digitalWrite(BUILTIN_LED_PIN, LOW); // LED on
         digitalWrite(BUILTIN_LED_PIN, HIGH); // LED off
         delay(LED_INIT_BLINK_INTERVAL);
     }
+#endif // ! FEATURE_SML
 
 #ifdef FEATURE_UI
     debug.println(F("UI"));
     moisture_init();
 #endif // FEATURE_MOISTURE
 
+#ifndef DISABLE_SENSORS
     debug.println(F("Sensors"));
     initSensors();
+#endif // ! DISABLE_SENSORS
 
 #ifdef FEATURE_LORA
     debug.println(F("LoRa"));
 
 #elif defined(ARDUINO_ARCH_ESP32)
 
+    // add generous 30s watchdog
+    esp_task_wdt_init(30, true);
+    esp_task_wdt_add(NULL);
+
     // Set hostname workaround
     WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE);
     WiFi.setHostname(hostname.c_str());
 }
 
 void loop() {
+#ifdef ARDUINO_ARCH_ESP32
+    esp_task_wdt_reset();
+#endif // ARDUINO_ARCH_ESP32
+
+#ifndef DISABLE_SENSORS
     runSensors();
+#endif // ! DISABLE_SENSORS
 
 #ifdef FEATURE_SML
     sml_run();
     lora_run();
 #endif // FEATURE_LORA
 
+#ifndef FEATURE_LORA
     // blink heartbeat LED
     unsigned long time = millis();
     if ((time - last_led_blink_time) >= LED_BLINK_INTERVAL) {
         last_led_blink_time = time;
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
     }
+#endif // ! FEATURE_LORA
 }

src/smart_meter.cpp

 #define SML_PARAM SWSERIAL_8N1
 
 static EspSoftwareSerial::UART port1, port2;
-static unsigned long counter = 0;
+RTC_DATA_ATTR static unsigned long counter = 0;
 
 static double SumWh = NAN, T1Wh = NAN, T2Wh = NAN;
 static double SumW = NAN, L1W = NAN, L2W = NAN, L3W = NAN;
 
         // update own battery state with each sml readout
         lora_sml_send(LORA_SML_BAT_V, lora_get_mangled_bat(), counter);
+
+        lora_sml_done();
 #endif // FEATURE_LORA
     }
 }