lora rx tx test with unofficial lib

include/DebugLog.h

@@ -26,21 +26,24 @@ public:
 #ifdef ENABLE_DEBUGLOG
     String getBuffer(void);
 #endif // ENABLE_DEBUGLOG
-    
+
     void write(char c);
     void print(String s);
     void print(int n);
-    
+
     void println(void);
     void println(String s);
     void println(int n);
-    
+
+    size_t printf(const char * format, ...)  __attribute__ ((format (printf, 2, 3)));
+    size_t printf(const char * format, va_list args);
+
 private:
     void sendToTargets(String s);
-    
+
 #ifdef ENABLE_DEBUGLOG
     void addToBuffer(String s);
-    
+
     CircularBuffer<char, DEBUG_LOG_HISTORY_SIZE> buffer;
 #endif // ENABLE_DEBUGLOG
 };

include/lora.h

@@ -16,6 +16,9 @@
 
 #ifdef FEATURE_LORA
 
+void lora_oled_init(void);
+void lora_oled_print(String s);
+
 void lora_init(void);
 void lora_run(void);
 

platformio.ini

@@ -53,11 +53,12 @@ build_flags =
   -DENABLE_MQTT
   -DNEW_ESP32_LIB
   -DFEATURE_LORA
+  -DFEATURE_DISABLE_WIFI
 lib_deps =
     https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
     https://github.com/rlogiacco/CircularBuffer.git#f29cf01b6e8603422f3668d51036ac124f803404
     https://github.com/Links2004/arduinoWebSockets.git#30d5e136665a52880f641ddd7245b3ba05ecd32b
-    https://github.com/beegee-tokyo/SX126x-Arduino.git#98ef65b5a2e9c35eabfd80a466327a9fdbb8e38e
+    https://github.com/ropg/heltec_esp32_lora_v3.git#9f281354507849755a597ebcce3721582f3b59b8
 
 [env:esp8266env]
 platform = espressif8266

src/DebugLog.cpp

@@ -15,6 +15,7 @@
 
 #include "config.h"
 #include "servers.h"
+#include "lora.h"
 #include "DebugLog.h"
 
 DebugLog debug;
@@ -40,6 +41,10 @@ void DebugLog::addToBuffer(String s) {
 void DebugLog::sendToTargets(String s) {
     Serial.print(s);
 
+#ifdef FEATURE_LORA
+    lora_oled_print(s);
+#endif // FEATURE_LORA
+
     s = "log:" + s;
     wifi_send_websocket(s);
 }
@@ -72,3 +77,29 @@ void DebugLog::println(String s) {
 void DebugLog::println(int n) {
     println(String(n));
 }
+
+size_t DebugLog::printf(const char *format, va_list args) {
+    char line_buff[128];
+    int l = vsnprintf((char *)line_buff, sizeof(line_buff), format, args);
+
+    if (l < 0) {
+        // encoding error
+        l = snprintf((char *)line_buff, sizeof(line_buff), "%s: encoding error\r\n", __func__);
+    } else if (l >= (ssize_t)sizeof(line_buff)) {
+        // not enough space for string
+        l = snprintf((char *)line_buff, sizeof(line_buff), "%s: message too long (%d)\r\n", __func__, l);
+    }
+    if ((l > 0) && (l <= (int)sizeof(line_buff))) {
+        print(String(line_buff));
+    }
+
+    return (l < 0) ? 0 : l;
+}
+
+size_t DebugLog::printf(const char * format, ...) {
+    va_list args;
+    va_start(args, format);
+    size_t r = printf(format, args);
+    va_end(args);
+    return r;
+}

src/lora.cpp

@@ -3,8 +3,6 @@
  *
  * ESP8266 / ESP32 Environmental Sensor
  *
- * https://github.com/beegee-tokyo/SX126x-Arduino/blob/master/examples/PingPongPio/src/main.cpp
- *
  * ----------------------------------------------------------------------------
  * "THE BEER-WARE LICENSE" (Revision 42):
  * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
@@ -16,89 +14,210 @@
 #ifdef FEATURE_LORA
 
 #include <Arduino.h>
-#include <SX126x-Arduino.h>
+
+// Turns the 'PRG' button into the power button, long press is off
+#define HELTEC_POWER_BUTTON
+
+#include <heltec_unofficial.h>
 
 #include "config.h"
 #include "DebugLog.h"
 #include "lora.h"
 
-// Define LoRa parameters
-#define RF_FREQUENCY               868000000 // Hz
-#define TX_OUTPUT_POWER            22 // dBm
-#define LORA_BANDWIDTH             0 // [0: 125 kHz, 1: 250 kHz, 2: 500 kHz, 3: Reserved]
-#define LORA_SPREADING_FACTOR      7 // [SF7..SF12]
-#define LORA_CODINGRATE            1 // [1: 4/5, 2: 4/6,  3: 4/7,  4: 4/8]
-#define LORA_PREAMBLE_LENGTH       8 // Same for Tx and Rx
-#define LORA_SYMBOL_TIMEOUT        0 // Symbols
-#define LORA_FIX_LENGTH_PAYLOAD_ON false
-#define LORA_IQ_INVERSION_ON       false
-#define RX_TIMEOUT_VALUE           3000
-#define TX_TIMEOUT_VALUE           3000
+#define OLED_BAT_INTERVAL (10UL * 1000UL) // in ms
+#define LORA_LED_BRIGHTNESS 25 // in percent, 50% brightness is plenty for this LED
+
+// 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
+
+// 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
+// #define FREQUENCY           905.2       // for US
+
+// LoRa bandwidth. Keep the decimal point to designate float.
+// Allowed values are 7.8, 10.4, 15.6, 20.8, 31.25, 41.7, 62.5, 125.0, 250.0 and 500.0 kHz.
+#define BANDWIDTH           250.0
+
+// Number from 5 to 12. Higher means slower but higher "processor gain",
+// meaning (in nutshell) longer range and more robust against interference.
+#define SPREADING_FACTOR    9
+
+// Transmit power in dBm. 0 dBm = 1 mW, enough for tabletop-testing. This value can be
+// set anywhere between -9 dBm (0.125 mW) to 22 dBm (158 mW). Note that the maximum ERP
+// (which is what your antenna maximally radiates) on the EU ISM band is 25 mW, and that
+// transmissting without an antenna can damage your hardware.
+// 25mW = 14dBm
+#define MAX_TX_POWER        14
+#define ANTENNA_GAIN        5
+#define TRANSMIT_POWER      (MAX_TX_POWER - ANTENNA_GAIN)
+
+#define RADIOLIB_xy(action) \
+    debug.print(#action); \
+    debug.print(" = "); \
+    debug.print(state); \
+    debug.print(" ("); \
+    debug.print(radiolib_result_string(state)); \
+    debug.println(")");
+
+#define RADIOLIB_CHECK(action) do { \
+    int state = action; \
+    if (state != RADIOLIB_ERR_NONE) { \
+        RADIOLIB_xy(action); \
+        success = false; \
+    } \
+} while (false);
+
+static unsigned long last_bat_time = 0;
+static bool use_lora = true;
+static unsigned long last_tx = 0, counter = 0, tx_time = 0, minimum_pause = 0;
+static volatile bool rx_flag = false;
+
+void lora_oled_init(void) {
+    heltec_setup();
+}
+
+void lora_oled_print(String s) {
+    display.print(s);
+}
 
-#define BUFFER_SIZE 64 // Define the payload size here
+static void print_bat(void) {
+    float vbat = heltec_vbat();
+    debug.printf("Vbat: %.2fV (%d%%)\n", vbat, heltec_battery_percent(vbat));
+}
 
-static hw_config hwConfig;
-static RadioEvents_t RadioEvents;
+static void lora_rx(void) {
+    rx_flag = true;
+}
 
 void lora_init(void) {
-    // Define the HW configuration between MCU and SX126x
-    hwConfig.CHIP_TYPE = SX1262_CHIP;
-
-    // TODO pin config!
-    hwConfig.PIN_LORA_RESET = 4;
-    hwConfig.PIN_LORA_NSS = 5;
-    hwConfig.PIN_LORA_SCLK = 18;
-    hwConfig.PIN_LORA_MISO = 19;
-    hwConfig.PIN_LORA_DIO_1 = 21;
-    hwConfig.PIN_LORA_BUSY = 22;
-    hwConfig.PIN_LORA_MOSI = 23;
-    hwConfig.RADIO_TXEN = 26;
-    hwConfig.RADIO_RXEN = 27;
-
-    hwConfig.USE_DIO2_ANT_SWITCH = true;
-    hwConfig.USE_DIO3_TCXO = true;
-    hwConfig.USE_DIO3_ANT_SWITCH = false;
-
-    // Initialize the LoRa chip
-    debug.println("Starting lora_hardware_init");
-    lora_hardware_init(hwConfig);
-
-    // Initialize the Radio callbacks
-    RadioEvents.TxDone = OnTxDone;
-    RadioEvents.RxDone = OnRxDone;
-    RadioEvents.TxTimeout = OnTxTimeout;
-    RadioEvents.RxTimeout = OnRxTimeout;
-    RadioEvents.RxError = OnRxError;
-    RadioEvents.CadDone = OnCadDone;
-
-    // Initialize the Radio
-    Radio.Init(&RadioEvents);
-
-    // Set Radio channel
-    Radio.SetChannel(RF_FREQUENCY);
-
-    // Set Radio TX configuration
-    Radio.SetTxConfig(MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
-                      LORA_SPREADING_FACTOR, LORA_CODINGRATE,
-                      LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
-                      true, 0, 0, LORA_IQ_INVERSION_ON, TX_TIMEOUT_VALUE);
-
-    // Set Radio RX configuration
-    Radio.SetRxConfig(MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
-                      LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
-                      LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
-                      0, true, 0, 0, LORA_IQ_INVERSION_ON, true);
-
-    // Start LoRa
-    debug.println("Starting Radio.Rx");
-    Radio.Rx(RX_TIMEOUT_VALUE);
+    print_bat();
+
+    bool success = true;
+
+    RADIOLIB_CHECK(radio.begin());
+    if (!success) {
+        use_lora = false;
+        return;
+    }
+
+    radio.setDio1Action(lora_rx);
+
+    debug.printf("Frequency: %.2f MHz\n", FREQUENCY);
+    RADIOLIB_CHECK(radio.setFrequency(FREQUENCY));
+    if (!success) {
+        use_lora = false;
+        return;
+    }
+
+    debug.printf("Bandwidth: %.1f kHz\n", BANDWIDTH);
+    RADIOLIB_CHECK(radio.setBandwidth(BANDWIDTH));
+    if (!success) {
+        use_lora = false;
+        return;
+    }
+
+    debug.printf("Spreading Factor: %i\n", SPREADING_FACTOR);
+    RADIOLIB_CHECK(radio.setSpreadingFactor(SPREADING_FACTOR));
+    if (!success) {
+        use_lora = false;
+        return;
+    }
+
+    debug.printf("TX power: %i dBm\n", TRANSMIT_POWER);
+    RADIOLIB_CHECK(radio.setOutputPower(TRANSMIT_POWER));
+    if (!success) {
+        use_lora = false;
+        return;
+    }
+
+    // Start receiving
+    RADIOLIB_CHECK(radio.startReceive(RADIOLIB_SX126X_RX_TIMEOUT_INF));
+    if (!success) {
+        use_lora = false;
+        return;
+    }
 }
 
 void lora_run(void) {
-#ifdef ARDUINO_ARCH_ESP8266
-    // Handle Radio events
-    Radio.IrqProcess();
-#endif // ARDUINO_ARCH_ESP8266
+    heltec_loop();
+
+#ifdef OLED_BAT_INTERVAL
+    unsigned long time = millis();
+    if ((time - last_bat_time) >= OLED_BAT_INTERVAL) {
+        last_bat_time = time;
+        print_bat();
+    }
+#endif
+
+    if (!use_lora) {
+        return;
+    }
+
+    // If a packet was received, display it and the RSSI and SNR
+    if (rx_flag) {
+        rx_flag = false;
+
+        bool success = true;
+        String data;
+        RADIOLIB_CHECK(radio.readData(data));
+        if (success) {
+            debug.printf("RX [%s]\n", data.c_str());
+            debug.printf("  RSSI: %.2f dBm\n", radio.getRSSI());
+            debug.printf("  SNR: %.2f dB\n", radio.getSNR());
+        }
+
+        success = true;
+        RADIOLIB_CHECK(radio.startReceive(RADIOLIB_SX126X_RX_TIMEOUT_INF));
+        if (!success) {
+            use_lora = false;
+            return;
+        }
+    }
+
+    bool tx_legal = millis() > last_tx + minimum_pause;
+
+    // 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;
+        }
+
+        debug.printf("TX [%s] ", String(counter).c_str());
+        radio.clearDio1Action();
+
+        heltec_led(LORA_LED_BRIGHTNESS);
+
+        bool success = true;
+        tx_time = millis();
+        RADIOLIB_CHECK(radio.transmit(String(counter++).c_str()));
+        tx_time = millis() - tx_time;
+
+        heltec_led(0);
+
+        if (success) {
+            debug.printf("OK (%i ms)\n", (int)tx_time);
+        } else {
+            debug.printf("fail (%i)\n", _radiolib_status);
+        }
+
+        // Maximum 1% duty cycle
+        minimum_pause = tx_time * 100;
+        last_tx = millis();
+
+        radio.setDio1Action(lora_rx);
+
+        success = true;
+        RADIOLIB_CHECK(radio.startReceive(RADIOLIB_SX126X_RX_TIMEOUT_INF));
+        if (!success) {
+            use_lora = false;
+            return;
+        }
+    }
 }
 
 #endif // FEATURE_LORA

src/main.cpp

@@ -58,6 +58,10 @@ void setup() {
 
     Serial.begin(115200);
 
+#ifdef FEATURE_LORA
+    lora_oled_init();
+#endif // FEATURE_LORA
+
     debug.println(F("Initializing..."));
 
     // Blink LED for init
@@ -93,7 +97,7 @@ void setup() {
     initSensors();
 
 #ifdef FEATURE_LORA
-    debug.println(F("Lora"));
+    debug.println(F("LoRa"));
     lora_init();
 #endif // FEATURE_LORA