Updated readme

Updated console build
Report battery percentage over BLE battery service
2025-04-05 21:05:44 -04:00 · 2025-01-24 13:21:24 +01:00 · 2025-01-19 22:14:15 +01:00 · 2025-01-18 15:20:58 +01:00 · 2025-01-18 13:12:02 +01:00 · 2025-01-17 17:25:24 +01:00
21 changed files with 1035 additions and 254 deletions
--- a/Bluetooth.h
+++ b/Bluetooth.h
@ -383,6 +383,8 @@ char bt_devname[11];
    }
  }

+  void bt_flush() { if (bt_state == BT_STATE_CONNECTED) { SerialBT.flushTXD(); } }
+
  void bt_disable_pairing() {
    bt_allow_pairing = false;
    bt_ssp_pin = 0;
--- a/Boards.h
+++ b/Boards.h
@ -41,12 +41,12 @@
  #define MODEL_A2            0xA2 // RNode v2.1, 433 MHz
  #define MODEL_A7            0xA7 // RNode v2.1, 868 MHz

-  #define BOARD_RNODE_NG_22   0x42 // RNode hardware revision v2.2 (T3S3)
-  #define MODEL_A1            0xA1 // RNode v2.2, 433 MHz with SX1268
-  #define MODEL_A5            0xA5 // RNode v2.2, 433 MHz with SX1278
-  #define MODEL_A6            0xA6 // RNode v2.2, 868 MHz with SX1262
-  #define MODEL_AA            0xAA // RNode v2.2, 868 MHz with SX1276
-  #define MODEL_AC            0xAC // RNode v2.2, 2.4 GHz with SX1280 and PA
+  #define BOARD_T3S3          0x42 // T3S3 devices
+  #define MODEL_A1            0xA1 // T3S3, 433 MHz with SX1268
+  #define MODEL_A5            0xA5 // T3S3, 433 MHz with SX1278
+  #define MODEL_A6            0xA6 // T3S3, 868 MHz with SX1262
+  #define MODEL_AA            0xAA // T3S3, 868 MHz with SX1276
+  #define MODEL_AC            0xAC // T3S3, 2.4 GHz with SX1280 and PA

  #define PRODUCT_TBEAM       0xE0 // T-Beam devices
  #define BOARD_TBEAM         0x33
@ -92,8 +92,13 @@

  #define PRODUCT_HELTEC_T114 0xC2 // Heltec Mesh Node T114
  #define BOARD_HELTEC_T114   0x3C
-  #define MODEL_C6            0xC6 // Heltec Mesh Node T114, 470-510 MHz (HT-n5262-LF)
-  #define MODEL_C7            0xC7 // Heltec Mesh Node T114, 863-928 MHz (HT-n5262-HF)
+  #define MODEL_C6            0xC6 // Heltec Mesh Node T114, 470-510 MHz
+  #define MODEL_C7            0xC7 // Heltec Mesh Node T114, 863-928 MHz
+
+  #define PRODUCT_TECHO       0x15 // LilyGO T-Echo devices
+  #define BOARD_TECHO         0x44
+  #define MODEL_16            0x16 // T-Echo 433 MHz
+  #define MODEL_17            0x17 // T-Echo 868/915 MHz

  #define PRODUCT_RAK4631     0x10
  #define BOARD_RAK4631       0x51
@ -413,7 +418,7 @@
        #endif
      #endif

-    #elif BOARD_MODEL == BOARD_RNODE_NG_22
+    #elif BOARD_MODEL == BOARD_T3S3
      #define IS_ESP32S3 true
      #define HAS_DISPLAY true
      #define HAS_CONSOLE true
@ -631,6 +636,66 @@
      const int pin_led_tx = LED_GREEN;
      const int pin_tcxo_enable = -1;

+    #elif BOARD_MODEL == BOARD_TECHO
+      #define _PINNUM(port, pin) ((port) * 32 + (pin))
+      #define MODEM SX1262
+      #define HAS_EEPROM false
+      #define HAS_BLUETOOTH false
+      #define HAS_BLE true
+      #define HAS_CONSOLE false
+      #define HAS_PMU true
+      #define HAS_NP false
+      #define HAS_SD false
+      #define HAS_TCXO true
+      #define HAS_BUSY true
+      #define HAS_INPUT true
+      #define HAS_SLEEP true
+      #define BLE_MANUFACTURER "LilyGO"
+      #define BLE_MODEL "T-Echo"
+
+      #define HAS_INPUT true
+      #define EEPROM_SIZE 296
+      #define EEPROM_OFFSET EEPROM_SIZE-EEPROM_RESERVED
+
+      #define CONFIG_UART_BUFFER_SIZE 32768
+      #define CONFIG_QUEUE_SIZE 6144
+      #define CONFIG_QUEUE_MAX_LENGTH 200
+
+      #define HAS_DISPLAY true
+      #define HAS_BACKLIGHT true
+      #define DISPLAY_SCALE 1
+
+      #define LED_ON LOW
+      #define LED_OFF HIGH
+      #define PIN_LED_GREEN _PINNUM(1, 1)
+      #define PIN_LED_RED   _PINNUM(1, 3)
+      #define PIN_LED_BLUE  _PINNUM(0, 14)
+      #define PIN_VEXT_EN _PINNUM(0, 12)
+
+      const int pin_disp_cs = 30;
+      const int pin_disp_dc = 28;
+      const int pin_disp_reset = 2;
+      const int pin_disp_busy = 3;
+      const int pin_disp_en = -1;
+      const int pin_disp_sck = 31;
+      const int pin_disp_mosi = 29;
+      const int pin_disp_miso = -1;
+      const int pin_backlight = 43;
+
+      const int pin_btn_usr1 = _PINNUM(1, 10);
+      const int pin_btn_touch = _PINNUM(0, 11);
+
+      const int pin_reset = 25;
+      const int pin_cs = 24;
+      const int pin_sclk = 19;
+      const int pin_mosi = 22;
+      const int pin_miso = 23;
+      const int pin_busy = 17;
+      const int pin_dio = 20;
+      const int pin_tcxo_enable = 21;
+      const int pin_led_rx = PIN_LED_BLUE;
+      const int pin_led_tx = PIN_LED_RED;
+
    #elif BOARD_MODEL == BOARD_HELTEC_T114
      #define MODEM SX1262
      #define HAS_EEPROM false
@ -638,12 +703,13 @@
      #define HAS_BLUETOOTH false
      #define HAS_BLE true
      #define HAS_CONSOLE false
-      #define HAS_PMU false
+      #define HAS_PMU true
      #define HAS_NP true
      #define HAS_SD false
      #define HAS_TCXO true
      #define HAS_BUSY true
      #define HAS_INPUT true
+      #define HAS_SLEEP true
      #define DIO2_AS_RF_SWITCH true
      #define CONFIG_UART_BUFFER_SIZE 6144
      #define CONFIG_QUEUE_SIZE 6144
@ -651,13 +717,10 @@
      #define EEPROM_SIZE 296
      #define EEPROM_OFFSET EEPROM_SIZE-EEPROM_RESERVED
      #define BLE_MANUFACTURER "Heltec"
-      #define BLE_MODEL "HT-n5262"
+      #define BLE_MODEL "T114"

-      // ADC
      #define PIN_T114_ADC_EN 6
-
-      // External sensors
-      #define PIN_T114_VEXT_EN 21
+      #define PIN_VEXT_EN 21

      // LED
      #define LED_T114_GREEN 3
@ -730,6 +793,14 @@
    const int pin_busy = -1;
  #endif

+  #ifndef LED_ON
+    #define LED_ON HIGH
+  #endif
+  
+  #ifndef LED_OFF
+    #define LED_OFF LOW
+  #endif
+
  #ifndef DIO2_AS_RF_SWITCH
    #define DIO2_AS_RF_SWITCH false
  #endif
--- a/Config.h
+++ b/Config.h
@ -20,7 +20,7 @@
 	#define CONFIG_H

 	#define MAJ_VERS  0x01
-	#define MIN_VERS  0x50
+	#define MIN_VERS  0x51

 	#define MODE_HOST 0x11
 	#define MODE_TNC  0x12
@ -207,6 +207,7 @@
    uint8_t battery_state = 0x00;
    uint8_t display_intensity = 0xFF;
    uint8_t display_addr = 0xFF;
+    volatile bool display_updating = false;
    bool display_blanking_enabled = false;
    bool display_diagnostics = true;    
    bool device_init_done = false;
--- a/Console/assets/stl/Handheld_RNode_Parts.7z
+++ b/Console/assets/stl/Handheld_RNode_Parts.7z
--- a/Console/build.py
+++ b/Console/build.py
@ -4,10 +4,10 @@ import sys
 import shutil

 packages = {
-    "rns": "rns-0.8.8-py3-none-any.whl",
-    "nomadnet": "nomadnet-0.5.6-py3-none-any.whl",
-    "lxmf": "lxmf-0.5.8-py3-none-any.whl",
-    "rnsh": "rnsh-0.1.4-py3-none-any.whl",
+    "rns": "rns-0.9.1-py3-none-any.whl",
+    "nomadnet": "nomadnet-0.5.7-py3-none-any.whl",
+    "lxmf": "lxmf-0.6.0-py3-none-any.whl",
+    "rnsh": "rnsh-0.1.5-py3-none-any.whl",
 }

 DEFAULT_TITLE = "RNode Bootstrap Console"
@ -174,7 +174,7 @@ mf.write(help_redirect)
 mf.close()

 def optimise_manual(path):
-    pm = 45
+    pm = 90
    scale_imgs = [
        ("_images/board_rnodev2.png", pm),
        ("_images/board_rnode.png", pm),
--- a/Console/source/guides/make_rnodes.md
+++ b/Console/source/guides/make_rnodes.md
@ -2,7 +2,6 @@
 [title]: <> (How To Make Your Own RNodes)
 [image]: <> (images/g3p.webp)
 [excerpt]: <> (This article will outline the general process, and provide the information you need, for building your own RNode from a few basic modules. The RNode will be functionally identical to a commercially purchased board.)
-<div class="article_date">{DATE}</div>
 # How To Make Your Own RNodes

 This article will outline the general process, and provide the information you need, for building your own RNode from a few basic modules. The RNode will be functionally identical to a purchased device.
@ -31,10 +30,9 @@ Currently, the RNode firmware supports a variety of different microcontrollers,

 Regarding the LoRa transceiver module, there is going to be an almost overwhelming amount of options to choose from. To narrow it down, here are the essential characteristics to look for:

- The RNode firmware needs a module based on the **Semtech SX1276** or **Semtech SX1278** LoRa transceiver IC. These come in several different variants, for all frequency bands from about 150 MHz to about 1100 MHz.
- Support for **SX1262**, **SX1268** and **SX1280**-based modules is coming soon, but until that is released, only **SX1276** and **SX1278** modules will work.
+- The RNode firmware needs a module based on the **Semtech SX1276**, **Semtech SX1278**, **SX1262**, **SX1268** and **SX1280** LoRa transceiver ICs. These come in several different variants, for all frequency bands from about 150 MHz to 2500 MHz.
 - The module *must* expose the direct SPI bus to the transceiver chip. UART based modules that add their own communications layer will not work.
- The module must also expose the *reset* line of the chip, and provide the **DIO0** interrupt signal *from* the chip.
+- The module must also expose the *reset* line of the chip, and provide the **DIO0** (or other relevant) interrupt signal *from* the chip.
 - As mentioned above, the module must be logic-level compatible with the microcontroller you are using, unless you want to add a level-shifter. Resistor divider arrays will most likely not work here, due to the bus speeds required.

 Keeping those things in mind, you should be able to select a suitable combination of microcontroller board and transceiver module.
@ -56,12 +54,17 @@ In the photo above I used an Adafruit Feather ESP32 board and a ModTronix inAir4
 9. Connect the *DIO0* pin of the transceiver module to the *DIO0 interrupt pin* of the microcontroller board.
 10. You can optionally connect transmit and receiver LEDs to the corresponding pins of the microcontroller board.

-The pin layouts of your transceiver module and microcontroller board will vary, but you can look up the correct pin assignments for your processor type and board layout in the `Config.h` file of the [RNode Firmware]({ASSET_PATH}pkg/rnode_firmware.zip).
+The pin layouts of your transceiver module and microcontroller board will vary, but you can look up the correct pin assignments for your processor type and board layout in the [Config.h](https://github.com/markqvist/RNode_Firmware/blob/master/Config.h) file of the [RNode Firmware](https://unsigned.io/rnode_firmware).

-## Loading the Firmware
-Once the hardware is assembled, you are ready to load the firmware onto the board and configure the configuration parameters in the boards EEPROM. Luckily, this process is completely automated by the [RNode Configuration Utility]({ASSET_PATH}m/using.html#the-rnodeconf-utility).
+### Loading the Firmware
+Once the hardware is assembled, you are ready to load the firmware onto the board and configure the configuration parameters in the boards EEPROM. Luckily, this process is completely automated by the [RNode Configuration Utility](https://markqvist.github.io/Reticulum/manual/using.html#the-rnodeconf-utility). To prepare for loading the firmware, make sure that `python` and `pip` is installed on your system, then install the `rns` package (which includes the `rnodeconf` program) by issuing the command:

-The `rnodeconf` program is included in the `rns` package. Please read [these instructions]({ASSET_PATH}s_rns.html) for more information on how to install it from this repository, or from the Internet. If installation goes well, you can now move on to the next step.
+
+```txt
+pip install rns
+```
+
+If installation goes well, you can now move on to the next step.

 > *Take Care*: A LoRa transceiver module **must** be connected to the board for the firmware to start and accept commands. If the firmware does not verify that the correct transceiver is available on the SPI bus, execution is stopped, and the board will not accept commands. If you find the board unresponsive after installing the firmware, or EEPROM configuration fails, double-check your transceiver module wiring!

@ -73,24 +76,6 @@ rnodeconf --autoinstall

 The installer will now ask you to insert the device you want to set up, scan for connected serial ports, and ask you a number of questions regarding the device. When it has the information it needs, it will install the correct firmware and configure the necessary parameters in the device EEPROM for it to function properly.

-> **Please Note!** If you are connected to the Internet while installing, the autoinstaller will automatically download any needed firmware files to a local cache before installing.
-
-> If you do not have an active Internet connection while installing, you can extract and use the firmware from this device instead. This will **only** work if you are building the same type of RNode as the device you are extracting from, as the firmware has to match the targeted board and hardware configuration.
-
-If you need to extract the firmware from an existing RNode, run the following command:
-
-```
-rnodeconf --extract
-```
-
-If `rnodeconf` finds a working RNode, it will extract and save the firmware from the device for later use. You can then run the auto-installer with the `--use-extracted` option to use the locally extracted file:
-
-```
-rnodeconf --autoinstall --use-extracted
-```
-
-This also works for updating the firmware on existing RNodes, so you can extract a newer firmware from one RNode, and deploy it onto other RNodes using the same method. Just use the `--update` option instead of `--autoinstall`.
-
 If the install goes well, you will be greated with a success message telling you that your device is now ready. To confirm everything is OK, you can query the device info with:

 ```txt
--- a/Device.h
+++ b/Device.h
@ -147,9 +147,6 @@ uint32_t retrieve_application_size() {
    uint8_t bytes[4];
    memcpy(bytes, (const void*)IMG_SIZE_START, 4);
    uint32_t fw_len = bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24;
-    Serial.println("FIRMWARE LEN:");
-    Serial.print(fw_len);
-    Serial.flush();
    return fw_len;
 }

--- a/Display.h
+++ b/Display.h
@ -16,21 +16,33 @@
 #include "Graphics.h"
 #include <Adafruit_GFX.h>

-#if BOARD_MODEL == BOARD_TDECK
-  #include <Adafruit_ST7789.h>
-#elif BOARD_MODEL == BOARD_HELTEC_T114
-  #include "ST7789Spi.h"
-  #define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
-#elif BOARD_MODEL == BOARD_TBEAM_S_V1
-  #include <Adafruit_SH110X.h>
+#if BOARD_MODEL != BOARD_TECHO
+  #if BOARD_MODEL == BOARD_TDECK
+    #include <Adafruit_ST7789.h>
+  #elif BOARD_MODEL == BOARD_HELTEC_T114
+    #include "ST7789.h"
+    #define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
+  #elif BOARD_MODEL == BOARD_TBEAM_S_V1
+    #include <Adafruit_SH110X.h>
+  #else
+    #include <Wire.h>
+    #include <Adafruit_SSD1306.h>
+  #endif
+
 #else
-  #include <Wire.h>
-  #include <Adafruit_SSD1306.h>
+  void (*display_callback)();
+  void display_add_callback(void (*callback)()) { display_callback = callback; }
+  void busyCallback(const void* p) { display_callback(); }
+  #define SSD1306_BLACK GxEPD_BLACK
+  #define SSD1306_WHITE GxEPD_WHITE
+  #include <GxEPD2_BW.h>
+  #include <SPI.h>
 #endif

 #include "Fonts/Org_01.h"
 #define DISP_W 128
 #define DISP_H 64
+
 #if BOARD_MODEL == BOARD_RNODE_NG_20 || BOARD_MODEL == BOARD_LORA32_V2_0
  #define DISP_RST -1
  #define DISP_ADDR 0x3C
@ -57,11 +69,16 @@
 #elif BOARD_MODEL == BOARD_RNODE_NG_21
  #define DISP_RST -1
  #define DISP_ADDR 0x3C
-#elif BOARD_MODEL == BOARD_RNODE_NG_22
+#elif BOARD_MODEL == BOARD_T3S3
  #define DISP_RST 21
  #define DISP_ADDR 0x3C
  #define SCL_OLED 17
  #define SDA_OLED 18
+#elif BOARD_MODEL == BOARD_TECHO
+  SPIClass displaySPI = SPIClass(NRF_SPIM0, pin_disp_miso, pin_disp_sck, pin_disp_mosi);
+  #define DISP_W 128
+  #define DISP_H 64
+  #define DISP_ADDR -1
 #elif BOARD_MODEL == BOARD_TBEAM_S_V1
  #define DISP_RST -1
  #define DISP_ADDR 0x3C
@ -88,10 +105,18 @@
  Adafruit_SH1106G display = Adafruit_SH1106G(128, 64, &Wire, -1);
  #define SSD1306_WHITE SH110X_WHITE
  #define SSD1306_BLACK SH110X_BLACK
+#elif BOARD_MODEL == BOARD_TECHO
+  GxEPD2_BW<GxEPD2_154_D67, GxEPD2_154_D67::HEIGHT> display(GxEPD2_154_D67(pin_disp_cs, pin_disp_dc, pin_disp_reset, pin_disp_busy));
+  uint32_t last_epd_refresh = 0;
+  uint32_t last_epd_full_refresh = 0;
+  #define REFRESH_PERIOD 300000
 #else
  Adafruit_SSD1306 display(DISP_W, DISP_H, &Wire, DISP_RST);
 #endif

+float disp_target_fps = 7;
+float epd_update_fps  = 0.5;
+
 #define DISP_MODE_UNKNOWN   0x00
 #define DISP_MODE_LANDSCAPE 0x01
 #define DISP_MODE_PORTRAIT  0x02
@ -107,8 +132,8 @@ uint8_t display_unblank_intensity = display_intensity;
 bool display_blanked = false;
 bool display_tx = false;
 bool recondition_display = false;
-uint8_t disp_target_fps = 7;
 int disp_update_interval = 1000/disp_target_fps;
+int epd_update_interval = 1000/disp_target_fps;
 uint32_t last_page_flip = 0;
 int page_interval = 4000;
 bool device_signatures_ok();
@ -126,18 +151,46 @@ int p_as_y = 0;
 GFXcanvas1 stat_area(64, 64);
 GFXcanvas1 disp_area(64, 64);

+void fillRect(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t colour);
+
 void update_area_positions() {
-  if (disp_mode == DISP_MODE_PORTRAIT) {
-    p_ad_x = 0 * DISPLAY_SCALE;
-    p_ad_y = 0 * DISPLAY_SCALE;
-    p_as_x = 0 * DISPLAY_SCALE;
-    p_as_y = 64 * DISPLAY_SCALE;
-  } else if (disp_mode == DISP_MODE_LANDSCAPE) {
-    p_ad_x = 0 * DISPLAY_SCALE;
-    p_ad_y = 0 * DISPLAY_SCALE;
-    p_as_x = 64 * DISPLAY_SCALE;
-    p_as_y = 0 * DISPLAY_SCALE;
-  }
+  #if BOARD_MODEL == BOARD_HELTEC_T114
+    if (disp_mode == DISP_MODE_PORTRAIT) {
+      p_ad_x = 16;
+      p_ad_y = 64;
+      p_as_x = 16;
+      p_as_y = p_ad_y+126;
+    } else if (disp_mode == DISP_MODE_LANDSCAPE) {
+      p_ad_x = 0;
+      p_ad_y = 96;
+      p_as_x = 126;
+      p_as_y = p_ad_y;
+    }
+  #elif BOARD_MODEL == BOARD_TECHO
+    if (disp_mode == DISP_MODE_PORTRAIT) {
+      p_ad_x = 61;
+      p_ad_y = 36;
+      p_as_x = 64;
+      p_as_y = 64+36;
+    } else if (disp_mode == DISP_MODE_LANDSCAPE) {
+      p_ad_x = 0;
+      p_ad_y = 0;
+      p_as_x = 64;
+      p_as_y = 0;
+    }
+  #else
+    if (disp_mode == DISP_MODE_PORTRAIT) {
+      p_ad_x = 0 * DISPLAY_SCALE;
+      p_ad_y = 0 * DISPLAY_SCALE;
+      p_as_x = 0 * DISPLAY_SCALE;
+      p_as_y = 64 * DISPLAY_SCALE;
+    } else if (disp_mode == DISP_MODE_LANDSCAPE) {
+      p_ad_x = 0 * DISPLAY_SCALE;
+      p_ad_y = 0 * DISPLAY_SCALE;
+      p_as_x = 64 * DISPLAY_SCALE;
+      p_as_y = 0 * DISPLAY_SCALE;
+    }
+  #endif
 }

 uint8_t display_contrast = 0x00;
@ -145,7 +198,11 @@ uint8_t display_contrast = 0x00;
  void set_contrast(Adafruit_SH1106G *display, uint8_t value) {
  }
 #elif BOARD_MODEL == BOARD_HELTEC_T114
-  void set_contrast(ST7789Spi *display, uint8_t value) {
+  void set_contrast(ST7789Spi *display, uint8_t value) { }
+#elif BOARD_MODEL == BOARD_TECHO
+  void set_contrast(void *display, uint8_t value) {
+    if (value == 0) { analogWrite(pin_backlight, 0); }
+    else            { analogWrite(pin_backlight, value); }
  }
 #elif BOARD_MODEL == BOARD_TDECK
  void set_contrast(Adafruit_ST7789 *display, uint8_t value) {
@ -186,7 +243,7 @@ bool display_init() {
      digitalWrite(pin_display_en, LOW);
      delay(50);
      digitalWrite(pin_display_en, HIGH);
-    #elif BOARD_MODEL == BOARD_RNODE_NG_22
+    #elif BOARD_MODEL == BOARD_T3S3
      Wire.begin(SDA_OLED, SCL_OLED);
    #elif BOARD_MODEL == BOARD_HELTEC32_V2
      Wire.begin(SDA_OLED, SCL_OLED);
@ -209,23 +266,16 @@ bool display_init() {
      digitalWrite(pin_display_en, HIGH);
      Wire.begin(SDA_OLED, SCL_OLED);
    #elif BOARD_MODEL == BOARD_HELTEC_T114
-
-      // enable vext (not required for screen to work, but is done in Heltec example)
-      digitalWrite(PIN_T114_VEXT_EN, HIGH);
-      pinMode(PIN_T114_VEXT_EN, OUTPUT);
-
-      // enable power to display
-      digitalWrite(PIN_T114_TFT_EN, LOW);
      pinMode(PIN_T114_TFT_EN, OUTPUT);
-
-      // enable backlight led (display is always black without this)
-      digitalWrite(PIN_T114_TFT_BLGT, LOW);
-      pinMode(PIN_T114_TFT_BLGT, OUTPUT);
-
-      // enable adc (not required for screen to work, but is done in Heltec example)
-      digitalWrite(PIN_T114_ADC_EN, HIGH);
-      pinMode(PIN_T114_ADC_EN, OUTPUT);
-
+      digitalWrite(PIN_T114_TFT_EN, LOW);
+    #elif BOARD_MODEL == BOARD_TECHO
+      display.init(0, true, 10, false, displaySPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+      display.setPartialWindow(0, 0, DISP_W, DISP_H);
+      display.epd2.setBusyCallback(busyCallback);
+      #if HAS_BACKLIGHT
+        pinMode(pin_backlight, OUTPUT);
+        analogWrite(pin_backlight, 0);
+      #endif
    #elif BOARD_MODEL == BOARD_TBEAM_S_V1
      Wire.begin(SDA_OLED, SCL_OLED);
    #endif
@ -239,9 +289,9 @@ bool display_init() {

    #if DISP_CUSTOM_ADDR == true
      #if HAS_EEPROM
-      uint8_t display_address = EEPROM.read(eeprom_addr(ADDR_CONF_DADR));
+        uint8_t display_address = EEPROM.read(eeprom_addr(ADDR_CONF_DADR));
      #elif MCU_VARIANT == MCU_NRF52
-      uint8_t display_address = eeprom_read(eeprom_addr(ADDR_CONF_DADR));
+        uint8_t display_address = eeprom_read(eeprom_addr(ADDR_CONF_DADR));
      #endif
      if (display_address == 0xFF) display_address = DISP_ADDR;
    #else
@ -258,9 +308,22 @@ bool display_init() {
          display_blanking_timeout = db_timeout*1000;
        }
      }
+    #elif MCU_VARIANT == MCU_NRF52
+      if (eeprom_read(eeprom_addr(ADDR_CONF_BSET)) == CONF_OK_BYTE) {
+        uint8_t db_timeout = eeprom_read(eeprom_addr(ADDR_CONF_DBLK));
+        if (db_timeout == 0x00) {
+          display_blanking_enabled = false;
+        } else {
+          display_blanking_enabled = true;
+          display_blanking_timeout = db_timeout*1000;
+        }
+      }
    #endif
    
-    #if BOARD_MODEL == BOARD_TDECK
+    #if BOARD_MODEL == BOARD_TECHO
+    // Don't check if display is actually connected
+    if(false) {
+    #elif BOARD_MODEL == BOARD_TDECK
    display.init(240, 320);
    display.setSPISpeed(80e6);
    #elif BOARD_MODEL == BOARD_HELTEC_T114
@ -282,9 +345,7 @@ bool display_init() {
        } else {
          disp_mode = DISP_MODE_PORTRAIT;
        }
-        #if BOARD_MODEL != BOARD_HELTEC_T114
        display.setRotation(display_rotation);
-        #endif
      } else {
        #if BOARD_MODEL == BOARD_RNODE_NG_20
          disp_mode = DISP_MODE_PORTRAIT;
@ -314,13 +375,17 @@ bool display_init() {
          disp_mode = DISP_MODE_PORTRAIT;
          display.setRotation(1);
        #elif BOARD_MODEL == BOARD_HELTEC_T114
-          disp_mode = DISP_MODE_LANDSCAPE;
+          disp_mode = DISP_MODE_PORTRAIT;
+          display.setRotation(1);
        #elif BOARD_MODEL == BOARD_RAK4631
          disp_mode = DISP_MODE_LANDSCAPE;
          display.setRotation(0);
        #elif BOARD_MODEL == BOARD_TDECK
          disp_mode = DISP_MODE_PORTRAIT;
          display.setRotation(3);
+        #elif BOARD_MODEL == BOARD_TECHO
+          disp_mode = DISP_MODE_PORTRAIT;
+          display.setRotation(3);
        #else
          disp_mode = DISP_MODE_PORTRAIT;
          display.setRotation(3);
@ -328,9 +393,8 @@ bool display_init() {
      }

      update_area_positions();
-      for (int i = 0; i < WATERFALL_SIZE; i++) {
-        waterfall[i] = 0;
-      }
+
+      for (int i = 0; i < WATERFALL_SIZE; i++) { waterfall[i] = 0; }

      last_page_flip = millis();

@ -342,10 +406,16 @@ bool display_init() {
      #endif

      #if HAS_EEPROM
-        #if MCU_VARIANT != MCU_NRF52
-          display_intensity = EEPROM.read(eeprom_addr(ADDR_CONF_DINT));
-        #else
-          display_intensity = eeprom_read(eeprom_addr(ADDR_CONF_DINT));
+        display_intensity = EEPROM.read(eeprom_addr(ADDR_CONF_DINT));
+      #elif MCU_VARIANT == MCU_NRF52
+        display_intensity = eeprom_read(eeprom_addr(ADDR_CONF_DINT));
+      #endif
+      display_unblank_intensity = display_intensity;
+
+      #if BOARD_MODEL == BOARD_TECHO
+        #if HAS_BACKLIGHT
+          if (display_intensity == 0) { analogWrite(pin_backlight, 0); }
+          else                        { analogWrite(pin_backlight, display_intensity); }
        #endif
      #endif

@ -353,6 +423,14 @@ bool display_init() {
        display.fillScreen(SSD1306_BLACK);
      #endif

+      #if BOARD_MODEL == BOARD_HELTEC_T114
+        // Enable backlight led (display is always black without this)
+        fillRect(p_ad_x, p_ad_y, 128, 128, SSD1306_BLACK);
+        fillRect(p_as_x, p_as_y, 128, 128, SSD1306_BLACK);
+        pinMode(PIN_T114_TFT_BLGT, OUTPUT);
+        digitalWrite(PIN_T114_TFT_BLGT, LOW);
+      #endif
+
      return true;
    }
  #else
@ -360,7 +438,7 @@ bool display_init() {
  #endif
 }

-// draws a line on the screen
+// Draws a line on the screen
 void drawLine(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t colour) {
  #if BOARD_MODEL == BOARD_HELTEC_T114
  if(colour == SSD1306_WHITE){
@ -374,7 +452,7 @@ void drawLine(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t colo
  #endif
 }

-// draws a filled rectangle on the screen
+// Draws a filled rectangle on the screen
 void fillRect(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t colour) {
  #if BOARD_MODEL == BOARD_HELTEC_T114
  if(colour == SSD1306_WHITE){
@ -388,7 +466,7 @@ void fillRect(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t colo
  #endif
 }

-// draws a bitmap to the display and auto scales it based on the boards configured DISPLAY_SCALE
+// Draws a bitmap to the display and auto scales it based on the boards configured DISPLAY_SCALE
 void drawBitmap(int16_t startX, int16_t startY, const uint8_t* bitmap, int16_t bitmapWidth, int16_t bitmapHeight, uint16_t foregroundColour, uint16_t backgroundColour) {
  #if DISPLAY_SCALE == 1
    display.drawBitmap(startX, startY, bitmap, bitmapWidth, bitmapHeight, foregroundColour, backgroundColour);
@ -737,7 +815,7 @@ void draw_disp_area() {
          if (!modem_installed) {
            disp_area.drawBitmap(0, 37, bm_no_radio, disp_area.width(), 27, SSD1306_WHITE, SSD1306_BLACK);
          } else {
-            disp_area.drawBitmap(0, 37, bm_hwfail, disp_area.width(), 27, SSD1306_WHITE, SSD1306_BLACK);
+            disp_area.drawBitmap(0, 37, bm_conf_missing, disp_area.width(), 27, SSD1306_WHITE, SSD1306_BLACK);
          }
        }
      } else if (bt_state == BT_STATE_PAIRING and bt_ssp_pin != 0) {
@ -826,7 +904,23 @@ void display_recondition() {
  #endif
 }

+bool epd_blanked = false;
+#if BOARD_MODEL == BOARD_TECHO
+  void epd_blank(bool full_update = true) {
+    display.setFullWindow();
+    display.fillScreen(SSD1306_WHITE);
+    display.display(full_update);
+  }
+
+  void epd_black(bool full_update = true) {
+    display.setFullWindow();
+    display.fillScreen(SSD1306_BLACK);
+    display.display(full_update);
+  }
+#endif
+
 void update_display(bool blank = false) {
+  display_updating = true;
  if (blank == true) {
    last_disp_update = millis()-disp_update_interval-1;
  } else {
@ -853,10 +947,17 @@ void update_display(bool blank = false) {
        set_contrast(&display, display_contrast);
      }

+      #if BOARD_MODEL == BOARD_TECHO
+        if (!epd_blanked) {
+          epd_blank();
+          epd_blanked = true;
+        }
+      #endif
+
      #if BOARD_MODEL == BOARD_HELTEC_T114
        display.clear();
        display.display();
-      #elif BOARD_MODEL != BOARD_TDECK
+      #elif BOARD_MODEL != BOARD_TDECK && BOARD_MODEL != BOARD_TECHO
        display.clearDisplay();
        display.display();
      #else
@ -865,8 +966,10 @@ void update_display(bool blank = false) {

      last_disp_update = millis();
    }
+
  } else {
    if (millis()-last_disp_update >= disp_update_interval) {
+      uint32_t current = millis();
      if (display_contrast != display_intensity) {
        display_contrast = display_intensity;
        set_contrast(&display, display_contrast);
@ -874,7 +977,7 @@ void update_display(bool blank = false) {

      #if BOARD_MODEL == BOARD_HELTEC_T114
        display.clear();
-      #elif BOARD_MODEL != BOARD_TDECK
+      #elif BOARD_MODEL != BOARD_TDECK && BOARD_MODEL != BOARD_TECHO
        display.clearDisplay();
      #endif

@ -883,16 +986,30 @@ void update_display(bool blank = false) {
        disp_update_interval = 1000/disp_target_fps;
        display_recondition();
      } else {
+        #if BOARD_MODEL == BOARD_TECHO
+          display.setFullWindow();
+          display.fillScreen(SSD1306_WHITE);
+        #endif
+
        update_stat_area();
        update_disp_area();
      }
      
-      #if BOARD_MODEL != BOARD_TDECK
+      #if BOARD_MODEL == BOARD_TECHO
+        if (current-last_epd_refresh >= epd_update_interval) {
+          if (current-last_epd_full_refresh >= REFRESH_PERIOD) { display.display(false); last_epd_full_refresh = millis(); }
+          else { display.display(true); }
+          last_epd_refresh = millis();
+          epd_blanked = false;
+        }
+      #elif BOARD_MODEL != BOARD_TDECK
        display.display();
      #endif
+
      last_disp_update = millis();
    }
  }
+  display_updating = false;
 }

 void display_unblank() {
--- a/Graphics.h
+++ b/Graphics.h
@ -311,6 +311,23 @@ const unsigned char bm_hwfail [] PROGMEM = {
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };

+const unsigned char bm_conf_missing [] PROGMEM = {
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x33, 0x87, 0x0c, 0xcc, 0xe1, 0xff, 0xff, 
+   0xe2, 0x33, 0x3e, 0x7c, 0xc4, 0xcf, 0xff, 0xff, 0xe0, 0x33, 0x8f, 0x1c, 0xc0, 0xc9, 0xff, 0xff, 
+   0xe5, 0x33, 0xe7, 0xcc, 0xc8, 0xc9, 0xff, 0xff, 0xe7, 0x33, 0x0e, 0x1c, 0xcc, 0xe3, 0xff, 0xff, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xf1, 0xe3, 0x99, 0x86, 0x70, 0xff, 0xf6, 0xff, 
+   0xe4, 0xc9, 0x89, 0x9e, 0x67, 0xff, 0xf6, 0xff, 0xe7, 0xc9, 0x81, 0x86, 0x64, 0xff, 0xef, 0x7f, 
+   0xe4, 0xc9, 0x91, 0x9e, 0x64, 0xff, 0xe9, 0x7f, 0xf1, 0xe3, 0x99, 0x9e, 0x71, 0xff, 0xd9, 0xbf, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd9, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb9, 0xdf, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb9, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xef, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xf9, 0xf7, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
 const unsigned char bm_no_radio [] PROGMEM = {
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0xc7, 0x0e, 0x71, 0xfc, 0xce, 0x38, 0x7f, 
--- a/24
+++ b/24
@ -47,8 +47,9 @@ prep-nrf:
 	arduino-cli core update-index --config-file arduino-cli.yaml
 	arduino-cli core install rakwireless:nrf52 --config-file arduino-cli.yaml
 	arduino-cli core install Heltec_nRF52:Heltec_nRF52 --config-file arduino-cli.yaml
+	arduino-cli core install adafruit:nrf52 --config-file arduino-cli.yaml
+	arduino-cli lib install "GxEPD2"
 	arduino-cli config set library.enable_unsafe_install true
-	arduino-cli lib install --git-url https://github.com/liamcottle/st7789#b8e7e076714b670764139289d3829b0beff67edb
 	arduino-cli lib install --git-url https://github.com/liamcottle/esp8266-oled-ssd1306#e16cee124fe26490cb14880c679321ad8ac89c95
 	pip install adafruit-nrfutil --upgrade

@ -139,6 +140,9 @@ firmware-rak4631:
 firmware-heltec_t114:
 	arduino-cli compile --log --fqbn Heltec_nRF52:Heltec_nRF52:HT-n5262 -e --build-property "build.partitions=no_ota" --build-property "upload.maximum_size=2097152" --build-property "compiler.cpp.extra_flags=\"-DBOARD_MODEL=0x3C\""

+firmware-techo:
+	arduino-cli compile --log --fqbn adafruit:nrf52:pca10056 -e --build-property "compiler.cpp.extra_flags=\"-DBOARD_MODEL=0x44\""
+
 upload:
 	arduino-cli upload -p /dev/ttyUSB0 --fqbn unsignedio:avr:rnode

@ -238,13 +242,22 @@ upload-featheresp32:

 upload-rak4631:
 	arduino-cli upload -p /dev/ttyACM0 --fqbn rakwireless:nrf52:WisCoreRAK4631Board
+	@sleep 1
+	rnodeconf /dev/ttyACM0 --firmware-hash $$(./partition_hashes from_device /dev/ttyACM0)

 upload-heltec_t114:
-	arduino-cli upload -p /dev/cu.usbmodem14401 --fqbn heltec:Heltec_nRF52:HT-n5262
+	arduino-cli upload -p /dev/ttyACM0 --fqbn Heltec_nRF52:Heltec_nRF52:HT-n5262
+	@sleep 1
+	rnodeconf /dev/ttyACM0 --firmware-hash $$(./partition_hashes from_device /dev/ttyACM0)
+
+upload-techo:
+	arduino-cli upload -p /dev/ttyACM0 --fqbn adafruit:nrf52:pca10056
+	@sleep 6
+	rnodeconf /dev/ttyACM0 --firmware-hash $$(./partition_hashes from_device /dev/ttyACM0)

 release: release-all

-release-all: console-site spiffs-image release-tbeam release-tbeam_sx1262 release-lora32_v10 release-lora32_v20 release-lora32_v21 release-lora32_v10_extled release-lora32_v20_extled release-lora32_v21_extled release-lora32_v21_tcxo release-featheresp32 release-genericesp32 release-heltec32_v2 release-heltec32_v3 release-heltec32_v2_extled release-heltec_t114 release-rnode_ng_20 release-rnode_ng_21 release-t3s3 release-t3s3_sx127x release-t3s3_sx1280_pa release-tdeck release-tbeam_supreme release-rak4631 release-hashes
+release-all: console-site spiffs-image release-tbeam release-tbeam_sx1262 release-lora32_v10 release-lora32_v20 release-lora32_v21 release-lora32_v10_extled release-lora32_v20_extled release-lora32_v21_extled release-lora32_v21_tcxo release-featheresp32 release-genericesp32 release-heltec32_v2 release-heltec32_v3 release-heltec32_v2_extled release-heltec_t114 release-techo release-rnode_ng_20 release-rnode_ng_21 release-t3s3 release-t3s3_sx127x release-t3s3_sx1280_pa release-tdeck release-tbeam_supreme release-rak4631 release-hashes

 release-hashes:
 	python ./release_hashes.py > ./Release/release.json
@ -457,3 +470,8 @@ release-heltec_t114:
 	arduino-cli compile --fqbn Heltec_nRF52:Heltec_nRF52:HT-n5262 -e --build-property "build.partitions=no_ota" --build-property "upload.maximum_size=2097152" --build-property "compiler.cpp.extra_flags=\"-DBOARD_MODEL=0x3C\""
 	cp build/Heltec_nRF52.Heltec_nRF52.HT-n5262/RNode_Firmware.ino.hex build/rnode_firmware_heltec_t114.hex
 	adafruit-nrfutil dfu genpkg --dev-type 0x0052 --application build/rnode_firmware_heltec_t114.hex Release/rnode_firmware_heltec_t114.zip
+
+release-techo:
+	arduino-cli compile --log --fqbn adafruit:nrf52:pca10056 -e --build-property "compiler.cpp.extra_flags=\"-DBOARD_MODEL=0x44\""
+	cp build/adafruit.nrf52.pca10056/RNode_Firmware.ino.hex build/rnode_firmware_techo.hex
+	adafruit-nrfutil dfu genpkg --dev-type 0x0052 --application build/rnode_firmware_techo.hex Release/rnode_firmware_techo.zip
--- a/Power.h
+++ b/Power.h
@ -62,7 +62,7 @@
  bool bat_voltage_dropping = false;
  float bat_delay_v = 0;
  float bat_state_change_v = 0;
-#elif BOARD_MODEL == BOARD_RNODE_NG_22
+#elif BOARD_MODEL == BOARD_T3S3
  #define BAT_V_MIN       3.15
  #define BAT_V_MAX       4.217
  #define BAT_V_CHG       4.48
@ -111,6 +111,39 @@
  bool bat_voltage_dropping = false;
  float bat_delay_v = 0;
  float bat_state_change_v = 0;
+#elif BOARD_MODEL == BOARD_HELTEC_T114
+  #define BAT_V_MIN       3.15
+  #define BAT_V_MAX       4.165
+  #define BAT_V_CHG       4.48
+  #define BAT_V_FLOAT     4.33
+  #define BAT_SAMPLES     7
+  const uint8_t pin_vbat = 4;
+  const uint8_t pin_ctrl = 6;
+  float bat_p_samples[BAT_SAMPLES];
+  float bat_v_samples[BAT_SAMPLES];
+  uint8_t bat_samples_count = 0;
+  int bat_discharging_samples = 0;
+  int bat_charging_samples = 0;
+  int bat_charged_samples = 0;
+  bool bat_voltage_dropping = false;
+  float bat_delay_v = 0;
+  float bat_state_change_v = 0;
+#elif BOARD_MODEL == BOARD_TECHO
+  #define BAT_V_MIN       3.15
+  #define BAT_V_MAX       4.16
+  #define BAT_V_CHG       4.48
+  #define BAT_V_FLOAT     4.33
+  #define BAT_SAMPLES     7
+  const uint8_t pin_vbat = 4;
+  float bat_p_samples[BAT_SAMPLES];
+  float bat_v_samples[BAT_SAMPLES];
+  uint8_t bat_samples_count = 0;
+  int bat_discharging_samples = 0;
+  int bat_charging_samples = 0;
+  int bat_charged_samples = 0;
+  bool bat_voltage_dropping = false;
+  float bat_delay_v = 0;
+  float bat_state_change_v = 0;
 #endif

 uint32_t last_pmu_update = 0;
@ -121,14 +154,18 @@ uint8_t pmu_rc = 0;
 void kiss_indicate_battery();

 void measure_battery() {
-  #if BOARD_MODEL == BOARD_RNODE_NG_21 || BOARD_MODEL == BOARD_LORA32_V2_1 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK || BOARD_MODEL == BOARD_RNODE_NG_22
+  #if BOARD_MODEL == BOARD_RNODE_NG_21 || BOARD_MODEL == BOARD_LORA32_V2_1 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK || BOARD_MODEL == BOARD_T3S3 || BOARD_MODEL == BOARD_HELTEC_T114 || BOARD_MODEL == BOARD_TECHO
    battery_installed = true;
    battery_indeterminate = true;

    #if BOARD_MODEL == BOARD_HELTEC32_V3
      float battery_measurement = (float)(analogRead(pin_vbat)) * 0.0041;
-    #elif BOARD_MODEL == BOARD_RNODE_NG_22
+    #elif BOARD_MODEL == BOARD_T3S3
      float battery_measurement = (float)(analogRead(pin_vbat)) / 4095.0*6.7828;
+    #elif BOARD_MODEL == BOARD_HELTEC_T114
+      float battery_measurement = (float)(analogRead(pin_vbat)) * 0.017165;
+    #elif BOARD_MODEL == BOARD_TECHO
+      float battery_measurement = (float)(analogRead(pin_vbat)) * 0.007067;
    #else
      float battery_measurement = (float)(analogRead(pin_vbat)) / 4095.0*7.26;
    #endif
@ -195,13 +232,14 @@ void measure_battery() {
        }
      }

+      #if MCU_VARIANT == MCU_NRF52
+        if (bt_state != BT_STATE_OFF) { blebas.write(battery_percent); }
+      #endif
+
      // if (bt_state == BT_STATE_CONNECTED) {
      //   SerialBT.printf("Bus voltage %.3fv. Unfiltered %.3fv.", battery_voltage, bat_v_samples[BAT_SAMPLES-1]);
-      //   if (bat_voltage_dropping) {
-      //     SerialBT.printf(" Voltage is dropping. Percentage %.1f%%.", battery_percent);
-      //   } else {
-      //     SerialBT.printf(" Voltage is not dropping. Percentage %.1f%%.", battery_percent);
-      //   }
+      //   if (bat_voltage_dropping) { SerialBT.printf(" Voltage is dropping. Percentage %.1f%%.", battery_percent); }
+      //   else                      { SerialBT.printf(" Voltage is not dropping. Percentage %.1f%%.", battery_percent); }
      //   if (battery_state == BATTERY_STATE_DISCHARGING) { SerialBT.printf(" Battery discharging. delay_v %.3fv", bat_delay_v); }
      //   if (battery_state == BATTERY_STATE_CHARGING) { SerialBT.printf(" Battery charging. delay_v %.3fv", bat_delay_v); }
      //   if (battery_state == BATTERY_STATE_CHARGED) { SerialBT.print(" Battery is charged."); }
@ -306,13 +344,17 @@ void update_pmu() {
 }

 bool init_pmu() {
-  #if BOARD_MODEL == BOARD_RNODE_NG_21 || BOARD_MODEL == BOARD_LORA32_V2_1 || BOARD_MODEL == BOARD_TDECK || BOARD_MODEL ==BOARD_RNODE_NG_22
+  #if BOARD_MODEL == BOARD_RNODE_NG_21 || BOARD_MODEL == BOARD_LORA32_V2_1 || BOARD_MODEL == BOARD_TDECK || BOARD_MODEL == BOARD_T3S3 || BOARD_MODEL == BOARD_TECHO
    pinMode(pin_vbat, INPUT);
    return true;
  #elif BOARD_MODEL == BOARD_HELTEC32_V3
    pinMode(pin_ctrl,OUTPUT);
    digitalWrite(pin_ctrl, LOW);
    return true;
+  #elif BOARD_MODEL == BOARD_HELTEC_T114
+    pinMode(pin_ctrl,OUTPUT);
+    digitalWrite(pin_ctrl, HIGH);
+    return true;
  #elif BOARD_MODEL == BOARD_TBEAM
    Wire.begin(I2C_SDA, I2C_SCL);

--- a/README.md
+++ b/README.md
@ -16,12 +16,7 @@ The RNode system is primarily software, which *transforms* different kinds of av

 ## Latest Release

-The latest release, installable through `rnodeconf`, is version `1.79`. This release brings the following changes:
-
- Improves BLE on RAK4631
- Fixes a firmware provisioning bug on RAK4631
-
-You must have at least version `2.2.0` of `rnodeconf` installed to update the RNode Firmware to version `1.79`. Get it by updating the `rns` package to at least version `0.8.4`.
+The latest release, installable through `rnodeconf`, is version `1.81`. You must have at least version `2.4.0` of `rnodeconf` installed to update the RNode Firmware to version `1.81`. Get it by updating the `rns` package to at least version `0.9.0`.

 ## A Self-Replicating System

@ -76,8 +71,11 @@ The RNode Firmware supports the following boards:
 - LilyGO LoRa32 v2.1 devices (with and without TCXO)
 - LilyGO T3S3 devices with SX1276/8 LoRa chips
 - LilyGO T3S3 devices with SX1262/8 LoRa chips
+- LilyGO T3S3 devices with SX1280 LoRa chips
+- LilyGO T-Echo devices
 - Heltec LoRa32 v2 devices
 - Heltec LoRa32 v3 devices
+- Heltec T114 devices
 - RAK4631 devices
 - Homebrew RNodes based on ATmega1284p boards
 - Homebrew RNodes based on ATmega2560 boards
@ -85,9 +83,7 @@ The RNode Firmware supports the following boards:
 - Homebrew RNodes based on generic ESP32 boards

 ## Supported Transceiver Modules
-The RNode Firmware supports all transceiver modules based on **Semtech SX1276** or **Semtech SX1278** chips, that have an **SPI interface** and expose the **DIO_0** interrupt pin from the chip.
-
-Support for **SX1262**, **SX1268** and **SX1280** is being implemented. Please support the project with donations if you want this faster!
+The RNode Firmware supports all transceiver modules based on Semtech **SX1276**, **SX1278**, **SX1262**, **SX1268** and **SX1280** chips, that have an **SPI interface** and expose the relevant **DIO** interrupt pins from the chip.

 ## Getting Started Fast
 You can download and flash the firmware to all the supported boards using the [RNode Config Utility](https://github.com/markqvist/rnodeconfigutil). All firmware releases are now handled and installed directly through the `rnodeconf` utility, which is included in the `rns` package. It can be installed via `pip`:
--- a/RNode_Firmware.ino
+++ b/RNode_Firmware.ino
@ -78,9 +78,19 @@ void setup() {
  #endif

  #if MCU_VARIANT == MCU_NRF52
-    if (!eeprom_begin()) {
-        Serial.write("EEPROM initialisation failed.\r\n");
-    }
+    #if BOARD_MODEL == BOARD_TECHO
+      delay(200);
+      pinMode(PIN_VEXT_EN, OUTPUT);
+      digitalWrite(PIN_VEXT_EN, HIGH);
+      pinMode(pin_btn_usr1, INPUT_PULLUP);
+      pinMode(pin_btn_touch, INPUT_PULLUP);
+      pinMode(PIN_LED_RED, OUTPUT);
+      pinMode(PIN_LED_GREEN, OUTPUT);
+      pinMode(PIN_LED_BLUE, OUTPUT);
+      delay(200);
+    #endif
+
+    if (!eeprom_begin()) { Serial.write("EEPROM initialisation failed.\r\n"); }
  #endif

  // Seed the PRNG for CSMA R-value selection
@ -105,11 +115,11 @@ void setup() {
    led_init();
  #endif

-  #if BOARD_MODEL != BOARD_RAK4631 && BOARD_MODEL != BOARD_HELTEC_T114  && BOARD_MODEL != BOARD_RNODE_NG_22 && BOARD_MODEL != BOARD_TBEAM_S_V1
-  // Some boards need to wait until the hardware UART is set up before booting
-  // the full firmware. In the case of the RAK4631 and Heltec T114, the line below will wait
-  // until a serial connection is actually established with a master. Thus, it
-  // is disabled on this platform.
+  #if BOARD_MODEL != BOARD_RAK4631 && BOARD_MODEL != BOARD_HELTEC_T114 && BOARD_MODEL != BOARD_TECHO && BOARD_MODEL != BOARD_T3S3 && BOARD_MODEL != BOARD_TBEAM_S_V1
+    // Some boards need to wait until the hardware UART is set up before booting
+    // the full firmware. In the case of the RAK4631 and Heltec T114, the line below will wait
+    // until a serial connection is actually established with a master. Thus, it
+    // is disabled on this platform.
    while (!Serial);
  #endif

@ -161,7 +171,7 @@ void setup() {
  #if MCU_VARIANT == MCU_ESP32 || MCU_VARIANT == MCU_NRF52
    init_channel_stats();

-    #if BOARD_MODEL == BOARD_RNODE_NG_22
+    #if BOARD_MODEL == BOARD_T3S3
      #if MODEM == SX1280
        delay(300);
        LoRa->reset();
@ -209,8 +219,16 @@ void setup() {
    if (eeprom_read(eeprom_addr(ADDR_CONF_DSET)) != CONF_OK_BYTE) {
    #endif
      eeprom_update(eeprom_addr(ADDR_CONF_DSET), CONF_OK_BYTE);
-      eeprom_update(eeprom_addr(ADDR_CONF_DINT), 0xFF);
+      #if BOARD_MODEL == BOARD_TECHO
+        eeprom_update(eeprom_addr(ADDR_CONF_DINT), 0x03);
+      #else
+        eeprom_update(eeprom_addr(ADDR_CONF_DINT), 0xFF);
+      #endif
    }
+    #if BOARD_MODEL == BOARD_TECHO
+      display_add_callback(work_while_waiting);
+    #endif
+
    display_unblank();
    disp_ready = display_init();
    update_display();
@ -242,11 +260,13 @@ void setup() {
      avoid_interference = false;
    #else
      #if HAS_EEPROM
-        if (EEPROM.read(eeprom_addr(ADDR_CONF_DIA)) == 0x01) { avoid_interference = false; }
-        else                                                 { avoid_interference = true; }
+        uint8_t ia_conf = EEPROM.read(eeprom_addr(ADDR_CONF_DIA));
+        if (ia_conf == 0x00) { avoid_interference = true; }
+        else                 { avoid_interference = false; }
      #elif MCU_VARIANT == MCU_NRF52
-        if (eeprom_read(eeprom_addr(ADDR_CONF_DIA)) == 0x01) { avoid_interference = false; }
-        else                                                 { avoid_interference = true; }
+        uint8_t ia_conf = eeprom_read(eeprom_addr(ADDR_CONF_DIA));
+        if (ia_conf == 0x00) { avoid_interference = true; }
+        else                 { avoid_interference = false; }
      #endif
    #endif
  #endif
@ -1121,7 +1141,6 @@ void serial_callback(uint8_t sbyte) {
            di_conf_save(display_intensity);
            display_unblank();
        }
-
      #endif
    } else if (command == CMD_DISP_ADDR) {
      #if HAS_DISPLAY
@ -1263,7 +1282,7 @@ void update_modem_status() {
    portEXIT_CRITICAL();
  #endif

-  interference_detected = current_rssi > (noise_floor+CSMA_INFR_THRESHOLD_DB);
+  interference_detected = !carrier_detected && (current_rssi > (noise_floor+CSMA_INFR_THRESHOLD_DB));
  if (interference_detected) { if (led_id_filter < LED_ID_TRIG) { led_id_filter += 1; } }
  else                       { if (led_id_filter > 0) {led_id_filter -= 1; } }

@ -1489,6 +1508,8 @@ void tx_queue_handler() {
  }
 }

+void work_while_waiting() { loop(); }
+
 void loop() {
  if (radio_online) {
    #if MCU_VARIANT == MCU_ESP32
@ -1560,7 +1581,7 @@ void loop() {
  #endif

  #if HAS_DISPLAY
-    if (disp_ready) update_display();
+    if (disp_ready && !display_updating) update_display();
  #endif

  #if HAS_PMU
@ -1590,22 +1611,40 @@ void loop() {

 void sleep_now() {
  #if HAS_SLEEP == true
-    #if BOARD_MODEL == BOARD_RNODE_NG_22
-      display_intensity = 0;
-      update_display(true);
-    #endif
-    #if PIN_DISP_SLEEP >= 0
-      pinMode(PIN_DISP_SLEEP, OUTPUT);
-      digitalWrite(PIN_DISP_SLEEP, DISP_SLEEP_LEVEL);
-    #endif
-    #if HAS_BLUETOOTH
-      if (bt_state == BT_STATE_CONNECTED) {
-        bt_stop();
+    #if PLATFORM == PLATFORM_ESP32
+      #if BOARD_MODEL == BOARD_T3S3
+        display_intensity = 0;
+        update_display(true);
+      #endif
+      #if PIN_DISP_SLEEP >= 0
+        pinMode(PIN_DISP_SLEEP, OUTPUT);
+        digitalWrite(PIN_DISP_SLEEP, DISP_SLEEP_LEVEL);
+      #endif
+      #if HAS_BLUETOOTH
+        if (bt_state == BT_STATE_CONNECTED) {
+          bt_stop();
+          delay(100);
+        }
+      #endif
+      esp_sleep_enable_ext0_wakeup(PIN_WAKEUP, WAKEUP_LEVEL);
+      esp_deep_sleep_start();
+    #elif PLATFORM == PLATFORM_NRF52
+      #if BOARD_MODEL == BOARD_HELTEC_T114
+        npset(0,0,0);
+        digitalWrite(PIN_VEXT_EN, LOW);
+        digitalWrite(PIN_T114_TFT_BLGT, HIGH);
+        digitalWrite(PIN_T114_TFT_EN, HIGH);
+      #elif BOARD_MODEL == BOARD_TECHO
+        for (uint8_t i = display_intensity; i > 0; i--) { analogWrite(pin_backlight, i-1); delay(1); }
+        epd_black(true); delay(300); epd_black(true); delay(300); epd_black(false);
+        delay(2000);
+        analogWrite(PIN_VEXT_EN, 0);
        delay(100);
-      }
+      #endif
+      sd_power_gpregret_set(0, 0x6d);
+      nrf_gpio_cfg_sense_input(pin_btn_usr1, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW);
+      NRF_POWER->SYSTEMOFF = 1;
    #endif
-    esp_sleep_enable_ext0_wakeup(PIN_WAKEUP, WAKEUP_LEVEL);
-    esp_deep_sleep_start();
  #endif
 }

--- a/Release/console_image.bin
+++ b/Release/console_image.bin
--- a/ST7789.h
+++ b/ST7789.h
@ -0,0 +1,440 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
+ * Copyright (c) 2024 by Heltec AutoMation
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
+ */
+
+#ifndef ST7789Spi_h
+#define ST7789Spi_h
+
+#include "OLEDDisplay.h"
+#include <SPI.h>
+
+
+#define ST_CMD_DELAY 0x80 // special signifier for command lists
+
+#define ST77XX_NOP 0x00
+#define ST77XX_SWRESET 0x01
+#define ST77XX_RDDID 0x04
+#define ST77XX_RDDST 0x09
+
+#define ST77XX_SLPIN 0x10
+#define ST77XX_SLPOUT 0x11
+#define ST77XX_PTLON 0x12
+#define ST77XX_NORON 0x13
+
+#define ST77XX_INVOFF 0x20
+#define ST77XX_INVON 0x21
+#define ST77XX_DISPOFF 0x28
+#define ST77XX_DISPON 0x29
+#define ST77XX_CASET 0x2A
+#define ST77XX_RASET 0x2B
+#define ST77XX_RAMWR 0x2C
+#define ST77XX_RAMRD 0x2E
+
+#define ST77XX_PTLAR 0x30
+#define ST77XX_TEOFF 0x34
+#define ST77XX_TEON 0x35
+#define ST77XX_MADCTL 0x36
+#define ST77XX_COLMOD 0x3A
+
+#define ST77XX_MADCTL_MY 0x80
+#define ST77XX_MADCTL_MX 0x40
+#define ST77XX_MADCTL_MV 0x20
+#define ST77XX_MADCTL_ML 0x10
+#define ST77XX_MADCTL_RGB 0x00
+
+#define ST77XX_RDID1 0xDA
+#define ST77XX_RDID2 0xDB
+#define ST77XX_RDID3 0xDC
+#define ST77XX_RDID4 0xDD
+
+// Some ready-made 16-bit ('565') color settings:
+#define ST77XX_BLACK 0x0000
+#define ST77XX_WHITE 0xFFFF
+#define ST77XX_RED 0xF800
+#define ST77XX_GREEN 0x07E0
+#define ST77XX_BLUE 0x001F
+#define ST77XX_CYAN 0x07FF
+#define ST77XX_MAGENTA 0xF81F
+#define ST77XX_YELLOW 0xFFE0
+#define ST77XX_ORANGE 0xFC00
+
+#define LED_A_ON LOW
+
+#ifdef ESP_PLATFORM
+#undef LED_A_ON
+#define LED_A_ON HIGH
+#define rtos_free free
+#define rtos_malloc malloc
+//SPIClass SPI1(HSPI);
+#endif
+class ST7789Spi : public OLEDDisplay {
+  private:
+      uint8_t             _rst;
+      uint8_t             _dc;
+      uint8_t             _cs;
+      uint8_t             _ledA;
+      int             _miso;
+      int             _mosi;
+      int             _clk;
+      SPIClass * _spi;
+      SPISettings           _spiSettings;
+      uint16_t            _RGB=0xFFFF;
+      uint8_t             _buffheight;
+  public:
+    /* pass _cs as -1 to indicate "do not use CS pin", for cases where it is hard wired low */
+    ST7789Spi(SPIClass *spiClass,uint8_t _rst, uint8_t _dc, uint8_t _cs, OLEDDISPLAY_GEOMETRY g = GEOMETRY_RAWMODE,uint16_t width=240,uint16_t height=320,int mosi=-1,int miso=-1,int clk=-1) {
+      this->_spi = spiClass;
+      this->_rst = _rst;
+      this->_dc  = _dc;
+      this->_cs  = _cs;
+      this->_mosi=mosi;
+      this->_miso=miso;
+      this->_clk=clk;
+      //this->_ledA  = _ledA;
+      _spiSettings = SPISettings(40000000, MSBFIRST, SPI_MODE0);
+      setGeometry(g,width,height);
+    }
+
+    bool connect(){
+      this->_buffheight=displayHeight / 8;
+      this->_buffheight+=displayHeight % 8 ? 1:0;
+      pinMode(_cs, OUTPUT);
+      pinMode(_dc, OUTPUT);
+      //pinMode(_ledA, OUTPUT);
+      if (_cs != (uint8_t) -1) {
+        pinMode(_cs, OUTPUT);
+      }  
+      pinMode(_rst, OUTPUT);
+
+#ifdef ESP_PLATFORM
+      _spi->begin(_clk,_miso,_mosi,-1);
+#else
+      _spi->begin();
+#endif
+      _spi->setClockDivider (SPI_CLOCK_DIV2);
+
+      // Pulse Reset low for 10ms
+      digitalWrite(_rst, HIGH);
+      delay(1);
+      digitalWrite(_rst, LOW);
+      delay(10);
+      digitalWrite(_rst, HIGH);
+      _spi->begin ();
+      //digitalWrite(_ledA, LED_A_ON);
+      return true;
+    }
+
+    void display(void) {
+    #ifdef OLEDDISPLAY_DOUBLE_BUFFER
+
+       uint16_t minBoundY = UINT16_MAX;
+       uint16_t maxBoundY = 0;
+
+       uint16_t minBoundX = UINT16_MAX;
+       uint16_t maxBoundX = 0;
+
+       uint16_t x, y;
+        
+       // Calculate the Y bounding box of changes
+       // and copy buffer[pos] to buffer_back[pos];
+       for (y = 0; y < _buffheight; y++) {
+         for (x = 0; x < displayWidth; x++) {
+          //Serial.printf("x  %d y %d\r\n",x,y);
+          uint16_t pos = x + y * displayWidth;
+          if (buffer[pos] != buffer_back[pos]) {
+            minBoundY = min(minBoundY, y);
+            maxBoundY = max(maxBoundY, y);
+            minBoundX = min(minBoundX, x);
+            maxBoundX = max(maxBoundX, x);
+          }
+          buffer_back[pos] = buffer[pos];
+        }
+        yield();
+       }
+
+       // If the minBoundY wasn't updated
+       // we can savely assume that buffer_back[pos] == buffer[pos]
+       // holdes true for all values of pos
+       if (minBoundY == UINT16_MAX) return;
+
+          set_CS(LOW);
+          _spi->beginTransaction(_spiSettings);
+
+          for (y = minBoundY; y <= maxBoundY; y++)
+          {
+            for(int temp = 0; temp<8;temp++)
+            {
+              //setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              //setAddrWindow(y*8+temp,minBoundX,1,maxBoundX-minBoundX+1);
+              uint32_t const pixbufcount = maxBoundX-minBoundX+1;
+              uint16_t *pixbuf = (uint16_t *)rtos_malloc(2 * pixbufcount);
+              for (x = minBoundX; x <= maxBoundX; x++)
+              {
+                pixbuf[x-minBoundX] = ((buffer[x + y * displayWidth]>>temp)&0x01)==1?_RGB:0;
+              }
+#ifdef ESP_PLATFORM
+              _spi->transferBytes((uint8_t *)pixbuf, NULL, 2 * pixbufcount);
+#else
+              _spi->transfer(pixbuf, NULL, 2 * pixbufcount);
+#endif
+              rtos_free(pixbuf);
+            }
+          }
+      _spi->endTransaction();
+      set_CS(HIGH);
+
+     #else
+          set_CS(LOW);
+          _spi->beginTransaction(_spiSettings);
+        uint8_t x, y;
+          for (y = 0; y < _buffheight; y++)
+          {
+            for(int temp = 0; temp<8;temp++)
+            {
+              //setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              //setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              setAddrWindow(y*8+temp,0,1,displayWidth);
+              uint32_t const pixbufcount = displayWidth;
+              uint16_t *pixbuf = (uint16_t *)rtos_malloc(2 * pixbufcount);
+              for (x = 0; x < displayWidth; x++)
+              {
+                pixbuf[x] = ((buffer[x + y * displayWidth]>>temp)&0x01)==1?_RGB:0;
+              }
+#ifdef ESP_PLATFORM
+              _spi->transferBytes((uint8_t *)pixbuf, NULL, 2 * pixbufcount);
+#else
+              _spi->transfer(pixbuf, NULL, 2 * pixbufcount);
+#endif
+              rtos_free(pixbuf);
+            }
+          }
+      _spi->endTransaction();
+      set_CS(HIGH);
+
+     #endif
+    }
+
+ virtual void resetOrientation() {
+    uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX;
+    sendCommand(ST77XX_MADCTL);
+    WriteData(madctl);
+    delay(10);
+  }
+  
+ virtual void flipScreenVertically() {
+    uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MY;
+    sendCommand(ST77XX_MADCTL);
+    WriteData(madctl);
+    delay(10);
+  }
+  
+ virtual void mirrorScreen() {
+    uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX|ST77XX_MADCTL_MY;
+    sendCommand(ST77XX_MADCTL);
+    WriteData(madctl);
+    delay(10);
+  }
+
+  virtual void setRotation(uint8_t r) {
+    uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX;
+    if (r == 1) { madctl = 0xC0; }
+    if (r == 2) { madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MY; }
+    if (r == 3) { madctl = 0x00; }
+    sendCommand(ST77XX_MADCTL);
+    WriteData(madctl);
+    delay(10);
+  }
+
+  void setRGB(uint16_t c)
+  {
+
+    this->_RGB=0x00|c>>8|c<<8&0xFF00;
+  }
+  
+  void displayOn(void) {
+  //sendCommand(DISPLAYON);
+  }
+
+  void displayOff(void) {
+  //sendCommand(DISPLAYOFF);
+  }
+  
+//#define ST77XX_MADCTL_MY 0x80
+//#define ST77XX_MADCTL_MX 0x40
+//#define ST77XX_MADCTL_MV 0x20
+//#define ST77XX_MADCTL_ML 0x10
+  protected:
+    // Send all the init commands
+    virtual void sendInitCommands()
+    {
+        sendCommand(ST77XX_SWRESET); //  1: Software reset, no args, w/delay
+        delay(150);
+
+        sendCommand(ST77XX_SLPOUT); //  2: Out of sleep mode, no args, w/delay
+        delay(10);
+
+        sendCommand(ST77XX_COLMOD); //  3: Set color mode, 16-bit color
+        WriteData(0x55); 
+        delay(10);
+        
+        sendCommand(ST77XX_MADCTL); //  4: Mem access ctrl (directions), Row/col addr, bottom-top refresh
+        WriteData(0x08); 
+        
+        sendCommand(ST77XX_CASET); //   5: Column addr set, 
+        WriteData(0x00); 
+        WriteData(0x00);         //    XSTART = 0
+        WriteData(0x00); 
+        WriteData(240);          //     XEND = 240
+        
+        sendCommand(ST77XX_RASET); //   6: Row addr set, 
+        WriteData(0x00); 
+        WriteData(0x00);         //    YSTART = 0
+        WriteData(320>>8); 
+        WriteData(320&0xFF);          //    YSTART = 320
+        
+        sendCommand(ST77XX_SLPOUT); //  7: hack
+        delay(10);
+        
+        sendCommand(ST77XX_NORON); //  8: Normal display on, no args, w/delay
+        delay(10);
+        
+        sendCommand(ST77XX_DISPON); //  9: Main screen turn on, no args, delay
+        delay(10);
+
+        sendCommand(ST77XX_INVON); //  10: invert
+        delay(10);
+
+        //uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MX;
+        uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX;
+        sendCommand(ST77XX_MADCTL);
+        WriteData(madctl);
+        delay(10);
+        setRGB(ST77XX_GREEN);
+    }
+
+
+  private:
+
+   void setAddrWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
+    x += (320-displayWidth)/2;
+    y += (240-displayHeight)/2;
+    uint32_t xa = ((uint32_t)x << 16) | (x + w - 1);
+    uint32_t ya = ((uint32_t)y << 16) | (y + h - 1);
+
+    writeCommand(ST77XX_CASET); // Column addr set
+    SPI_WRITE32(xa);
+
+    writeCommand(ST77XX_RASET); // Row addr set
+    SPI_WRITE32(ya);
+
+    writeCommand(ST77XX_RAMWR); // write to RAM
+  }
+    int getBufferOffset(void) {
+        return 0;
+    }
+    inline void set_CS(bool level) {
+      if (_cs != (uint8_t) -1) {
+        digitalWrite(_cs, level);
+      }
+    };
+    inline void sendCommand(uint8_t com) __attribute__((always_inline)){
+      set_CS(HIGH);
+      digitalWrite(_dc, LOW);
+      set_CS(LOW);
+      _spi->beginTransaction(_spiSettings);
+      _spi->transfer(com);
+      _spi->endTransaction();
+      set_CS(HIGH);
+      digitalWrite(_dc, HIGH);
+    }
+    
+    inline void WriteData(uint8_t data) __attribute__((always_inline)){
+        digitalWrite(_cs, LOW);
+        _spi->beginTransaction(_spiSettings);
+        _spi->transfer(data);
+        _spi->endTransaction();
+        digitalWrite(_cs, HIGH);
+    }
+   void SPI_WRITE32(uint32_t l)
+   {
+      _spi->transfer(l >> 24);
+      _spi->transfer(l >> 16);
+      _spi->transfer(l >> 8);
+      _spi->transfer(l);
+   }
+  void writeCommand(uint8_t cmd) {
+    digitalWrite(_dc, LOW);
+    _spi->transfer(cmd);
+    digitalWrite(_dc, HIGH);
+  }
+
+// Private functions
+  void setGeometry(OLEDDISPLAY_GEOMETRY g, uint16_t width, uint16_t height) {
+    this->geometry = g;
+
+    switch (g) {
+      case GEOMETRY_128_128:
+        this->displayWidth = 128;
+        this->displayHeight = 128;
+        break;
+      case GEOMETRY_128_64:
+        this->displayWidth = 128;
+        this->displayHeight = 64;
+        break;
+      case GEOMETRY_128_32:
+        this->displayWidth = 128;
+        this->displayHeight = 32;
+        break;
+      case GEOMETRY_64_48:
+        this->displayWidth = 64;
+        this->displayHeight = 48;
+        break;
+      case GEOMETRY_64_32:
+        this->displayWidth = 64;
+        this->displayHeight = 32;
+        break;
+      case GEOMETRY_RAWMODE:
+        this->displayWidth = width > 0 ? width : 128;
+        this->displayHeight = height > 0 ? height : 64;
+        break;
+    }
+    uint8_t tmp=displayHeight % 8;
+    uint8_t _buffheight=displayHeight / 8;
+
+    if(tmp!=0)
+      _buffheight++;
+    this->displayBufferSize = displayWidth * _buffheight ;
+  }
+  
+
+
+};
+
+#endif
--- a/Utilities.h
+++ b/Utilities.h
@ -15,7 +15,7 @@

 #include "Config.h"

-#if HAS_EEPROM 
+#if HAS_EEPROM
    #include <EEPROM.h>
 #elif PLATFORM == PLATFORM_NRF52
    #include <Adafruit_LittleFS.h>
@ -74,7 +74,7 @@ uint8_t eeprom_read(uint32_t mapped_addr);
  #if BOARD_MODEL == BOARD_HELTEC32_V3
    //https://github.com/espressif/esp-idf/issues/8855
    #include "hal/wdt_hal.h"
-	#elif BOARD_MODEL == BOARD_RNODE_NG_22
+	#elif BOARD_MODEL == BOARD_T3S3
 		#include "hal/wdt_hal.h"
  #else
 		#include "hal/wdt_hal.h"
@ -119,6 +119,12 @@ uint8_t boot_vector = 0x00;
  }

  void led_init() {
+  	#if BOARD_MODEL == BOARD_HELTEC_T114
+  		// Enable vext power supply to neopixel
+  		pinMode(PIN_VEXT_EN, OUTPUT);
+  		digitalWrite(PIN_VEXT_EN, HIGH);
+  	#endif
+
    #if MCU_VARIANT == MCU_NRF52
      if (eeprom_read(eeprom_addr(ADDR_CONF_PSET)) == CONF_OK_BYTE) {
        uint8_t int_val = eeprom_read(eeprom_addr(ADDR_CONF_PINT));
@ -189,7 +195,7 @@ uint8_t boot_vector = 0x00;
 		void led_tx_off() { digitalWrite(pin_led_tx, LOW); }
 		void led_id_on()  { }
 		void led_id_off() { }
-	#elif BOARD_MODEL == BOARD_RNODE_NG_22
+	#elif BOARD_MODEL == BOARD_T3S3
 		void led_rx_on()  { digitalWrite(pin_led_rx, HIGH); }
 		void led_rx_off() {	digitalWrite(pin_led_rx, LOW); }
 		void led_tx_on()  { digitalWrite(pin_led_tx, HIGH); }
@ -317,7 +323,14 @@ uint8_t boot_vector = 0x00;
    void led_tx_off() { digitalWrite(pin_led_tx, HIGH); }
 		void led_id_on()  { }
 		void led_id_off() { }
-    #endif
+  #elif BOARD_MODEL == BOARD_TECHO
+		void led_rx_on()  { digitalWrite(pin_led_rx, LED_ON); }
+		void led_rx_off() {	digitalWrite(pin_led_rx, LED_OFF); }
+		void led_tx_on()  { digitalWrite(pin_led_tx, LED_ON); }
+		void led_tx_off() { digitalWrite(pin_led_tx, LED_OFF); }
+		void led_id_on()  { }
+		void led_id_off() { }
+	#endif
 #endif

 void hard_reset(void) {
@ -470,6 +483,19 @@ void led_indicate_warning(int cycles) {
 		  }
 		  led_rx_off();
 		}
+	#elif BOARD_MODEL == BOARD_TECHO
+		void led_indicate_info(int cycles) {
+			bool forever = (cycles == 0) ? true : false;
+			cycles = forever ? 1 : cycles;
+			while(cycles > 0) {
+		    led_rx_off();
+		    delay(100);
+		    led_rx_on();
+		    delay(100);
+		    if (!forever) cycles--;
+		  }
+		  led_rx_off();
+		}
 	#else
 		void led_indicate_info(int cycles) {
 			bool forever = (cycles == 0) ? true : false;
@ -623,9 +649,17 @@ int8_t  led_standby_direction = 0;
 				}
 				led_standby_value += led_standby_direction;
 				if (led_standby_value > 253) {
-					led_tx_on();
+					#if BOARD_MODEL == BOARD_TECHO
+						led_rx_on();
+					#else
+						led_tx_on();
+					#endif
 				} else {
-					led_tx_off();
+					#if BOARD_MODEL == BOARD_TECHO
+						led_rx_off();
+					#else
+						led_tx_off();
+					#endif
 				}
 				#if BOARD_MODEL == BOARD_LORA32_V2_1
 					#if defined(EXTERNAL_LEDS)
@ -732,13 +766,8 @@ void serial_write(uint8_t byte) {
      #if MCU_VARIANT == MCU_NRF52 && HAS_BLE
 	      // This ensures that the TX buffer is flushed after a frame is queued in serial.
 	      // serial_in_frame is used to ensure that the flush only happens at the end of the frame
-	      if (serial_in_frame && byte == FEND) {
-	          SerialBT.flushTXD();
-	          serial_in_frame = false;
-	      }
-	      else if (!serial_in_frame && byte == FEND) {
-	          serial_in_frame = true;
-	      }
+	      if (serial_in_frame && byte == FEND) { SerialBT.flushTXD(); serial_in_frame = false; }
+	      else if (!serial_in_frame && byte == FEND) { serial_in_frame = true; }
      #endif
 		}
 	#else
@ -882,13 +911,14 @@ void kiss_indicate_lt_alock() {
 }

 void kiss_indicate_channel_stats() {
-	#if MCU_VARIANT == MCU_ESP32
+	#if MCU_VARIANT == MCU_ESP32 || MCU_VARIANT == MCU_NRF52
 		uint16_t ats = (uint16_t)(airtime*100*100);
 		uint16_t atl = (uint16_t)(longterm_airtime*100*100);
 		uint16_t cls = (uint16_t)(total_channel_util*100*100);
 		uint16_t cll = (uint16_t)(longterm_channel_util*100*100);
 		uint8_t  crs = (uint8_t)(current_rssi+rssi_offset);
 		uint8_t  nfl = (uint8_t)(noise_floor+rssi_offset);
+		uint8_t  ntf = 0xFF; if (interference_detected) { ntf = (uint8_t)(current_rssi+rssi_offset); }
 		serial_write(FEND);
 		serial_write(CMD_STAT_CHTM);
 		escaped_serial_write(ats>>8);
@ -901,12 +931,13 @@ void kiss_indicate_channel_stats() {
 		escaped_serial_write(cll);
 		escaped_serial_write(crs);
 		escaped_serial_write(nfl);
+		escaped_serial_write(ntf);
 		serial_write(FEND);
 	#endif
 }

 void kiss_indicate_csma_stats() {
-	#if MCU_VARIANT == MCU_ESP32
+	#if MCU_VARIANT == MCU_ESP32 || MCU_VARIANT == MCU_NRF52
 		serial_write(FEND);
 		serial_write(CMD_STAT_CSMA);
 		escaped_serial_write(cw_band);
@ -917,7 +948,7 @@ void kiss_indicate_csma_stats() {
 }

 void kiss_indicate_phy_stats() {
-	#if MCU_VARIANT == MCU_ESP32
+	#if MCU_VARIANT == MCU_ESP32 || MCU_VARIANT == MCU_NRF52
 		uint16_t lst = (uint16_t)(lora_symbol_time_ms*1000);
 		uint16_t lsr = (uint16_t)(lora_symbol_rate);
 		uint16_t prs = (uint16_t)(lora_preamble_symbols);
@ -937,7 +968,7 @@ void kiss_indicate_phy_stats() {
 }

 void kiss_indicate_battery() {
-	#if MCU_VARIANT == MCU_ESP32
+	#if MCU_VARIANT == MCU_ESP32 || MCU_VARIANT == MCU_NRF52
 		serial_write(FEND);
 		serial_write(CMD_STAT_BAT);
 		escaped_serial_write(battery_state);
@ -1282,35 +1313,32 @@ void promisc_disable() {
 }

 #if !HAS_EEPROM && MCU_VARIANT == MCU_NRF52
-    bool eeprom_begin() {
-        InternalFS.begin();
+  bool eeprom_begin() {
+    InternalFS.begin();

-        file.open(EEPROM_FILE, FILE_O_READ);
-
-        // if file doesn't exist
-        if (!file) {
-            if (file.open(EEPROM_FILE, FILE_O_WRITE)) {
-                // initialise the file with empty content
-                uint8_t empty_content[EEPROM_SIZE] = {0};
-                file.write(empty_content, EEPROM_SIZE);
-                return true;
-            } else {
-                return false;
-            }
-        } else {
-            file.close();
-            file.open(EEPROM_FILE, FILE_O_WRITE);
-            return true;
-        }
+    file.open(EEPROM_FILE, FILE_O_READ);
+    if (!file) {
+      if (file.open(EEPROM_FILE, FILE_O_WRITE)) {
+      	for (uint32_t mapped_addr = 0; mapped_addr < EEPROM_SIZE; mapped_addr++) { file.seek(mapped_addr); file.write(0xFF); }
+        eeprom_flush();
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      file.close();
+      file.open(EEPROM_FILE, FILE_O_WRITE);
+      return true;
    }
+  }

-    uint8_t eeprom_read(uint32_t mapped_addr) {
-        uint8_t byte;
-        void* byte_ptr = &byte;
-        file.seek(mapped_addr);
-        file.read(byte_ptr, 1);
-        return byte;
-    }
+  uint8_t eeprom_read(uint32_t mapped_addr) {
+      uint8_t byte;
+      void* byte_ptr = &byte;
+      file.seek(mapped_addr);
+      file.read(byte_ptr, 1);
+      return byte;
+  }
 #endif

 bool eeprom_info_locked() {
@ -1368,7 +1396,6 @@ void kiss_dump_eeprom() {

 #if !HAS_EEPROM && MCU_VARIANT == MCU_NRF52
 void eeprom_flush() {
-    // sync file contents to flash
    file.close();
    file.open(EEPROM_FILE, FILE_O_WRITE);
    written_bytes = 0;
@ -1395,19 +1422,7 @@ void eeprom_update(int mapped_addr, uint8_t byte) {
      file.write(byte);
    }
    written_bytes++;
-    
-    if ((mapped_addr - eeprom_addr(0)) == ADDR_INFO_LOCK) {
-      #if !HAS_EEPROM && MCU_VARIANT == MCU_NRF52
-        // have to do a flush because we're only writing 1 byte and it syncs after 4
-        eeprom_flush();
-      #endif
-    }
-
-    if (written_bytes >= 4) {
-      file.close();
-      file.open(EEPROM_FILE, FILE_O_WRITE);
-      written_bytes = 0;
-    }
+    eeprom_flush();
 	#endif
 }

@ -1420,9 +1435,13 @@ void eeprom_write(uint8_t addr, uint8_t byte) {
 }

 void eeprom_erase() {
-	for (int addr = 0; addr < EEPROM_RESERVED; addr++) {
-		eeprom_update(eeprom_addr(addr), 0xFF);
-	}
+	#if !HAS_EEPROM && MCU_VARIANT == MCU_NRF52
+		InternalFS.format();
+	#else
+		for (int addr = 0; addr < EEPROM_RESERVED; addr++) {
+			eeprom_update(eeprom_addr(addr), 0xFF);
+		}
+	#endif
 	hard_reset();
 }

@ -1450,7 +1469,7 @@ bool eeprom_product_valid() {
 	#elif PLATFORM == PLATFORM_ESP32
 	if (rval == PRODUCT_RNODE || rval == BOARD_RNODE_NG_20 || rval == BOARD_RNODE_NG_21 || rval == PRODUCT_HMBRW || rval == PRODUCT_TBEAM || rval == PRODUCT_T32_10 || rval == PRODUCT_T32_20 || rval == PRODUCT_T32_21 || rval == PRODUCT_H32_V2 || rval == PRODUCT_H32_V3 || rval == PRODUCT_TDECK_V1 || rval == PRODUCT_TBEAM_S_V1) {
 	#elif PLATFORM == PLATFORM_NRF52
-	if (rval == PRODUCT_RAK4631 || rval == PRODUCT_HELTEC_T114 || rval == PRODUCT_HMBRW) {
+	if (rval == PRODUCT_RAK4631 || rval == PRODUCT_HELTEC_T114 || rval == PRODUCT_TECHO || rval == PRODUCT_HMBRW) {
 	#else
 	if (false) {
 	#endif
@ -1472,7 +1491,7 @@ bool eeprom_model_valid() {
 	if (model == MODEL_A3 || model == MODEL_A8) {
 	#elif BOARD_MODEL == BOARD_RNODE_NG_21
 	if (model == MODEL_A2 || model == MODEL_A7) {
-	#elif BOARD_MODEL == BOARD_RNODE_NG_22
+	#elif BOARD_MODEL == BOARD_T3S3
 	if (model == MODEL_A1 || model == MODEL_A6 || model == MODEL_A5 || model == MODEL_AA || model == MODEL_AC) {
 	#elif BOARD_MODEL == BOARD_HMBRW
 	if (model == MODEL_FF || model == MODEL_FE) {
@ -1480,6 +1499,8 @@ bool eeprom_model_valid() {
 	if (model == MODEL_E4 || model == MODEL_E9 || model == MODEL_E3 || model == MODEL_E8) {
 	#elif BOARD_MODEL == BOARD_TDECK
 	if (model == MODEL_D4 || model == MODEL_D9) {
+	#elif BOARD_MODEL == BOARD_TECHO
+	if (model == MODEL_16 || model == MODEL_17) {
 	#elif BOARD_MODEL == BOARD_TBEAM_S_V1
 	if (model == MODEL_DB || model == MODEL_DC) {
 	#elif BOARD_MODEL == BOARD_LORA32_V1_0
--- a/arduino-cli.yaml
+++ b/arduino-cli.yaml
@ -3,4 +3,5 @@ board_manager:
  - https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  - https://raw.githubusercontent.com/RAKwireless/RAKwireless-Arduino-BSP-Index/main/package_rakwireless_index.json
  - https://github.com/HelTecAutomation/Heltec_nRF52/releases/download/1.7.0/package_heltec_nrf_index.json
+  - https://adafruit.github.io/arduino-board-index/package_adafruit_index.json
  - http://unsigned.io/arduino/package_unsignedio_UnsignedBoards_index.json
--- a/25
+++ b/25
@ -20,6 +20,7 @@ import sys
 import RNS
 import json
 import hashlib
+import subprocess

 major_version = None
 minor_version = None
@ -27,9 +28,23 @@ target_version = None

 target_file = os.path.join(sys.argv[1])

-firmware_data = open(target_file, "rb").read()
-calc_hash = hashlib.sha256(firmware_data[0:-32]).digest()
-part_hash = firmware_data[-32:]
+if sys.argv[1] == "from_device":
+    from_device = True
+else:
+    from_device = False

-if calc_hash == part_hash:
-    print(RNS.hexrep(part_hash, delimit=False))
+if not from_device:
+    firmware_data = open(target_file, "rb").read()
+    calc_hash = hashlib.sha256(firmware_data[0:-32]).digest()
+    part_hash = firmware_data[-32:]
+
+    if calc_hash == part_hash:
+        print(RNS.hexrep(part_hash, delimit=False))
+
+else:
+    try:
+        cmdresult = subprocess.run(["rnodeconf", sys.argv[2], "-L"], stdout=subprocess.PIPE).stdout.decode('utf-8')
+        part_hash = cmdresult.split("The actual firmware hash is: ")[1].replace("\n", "")
+        print(part_hash)
+    except Exception as e:
+        print("Could not get partition hash from device: "+str(e))
--- a/sx126x.cpp
+++ b/sx126x.cpp
@ -87,7 +87,11 @@
 #define FREQ_DIV_6X  (double)pow(2.0, 25.0)
 #define FREQ_STEP_6X (double)(XTAL_FREQ_6X / FREQ_DIV_6X)

-#if defined(NRF52840_XXAA)
+#if BOARD_MODEL == BOARD_TECHO
+  SPIClass spim3 = SPIClass(NRF_SPIM3, pin_miso, pin_sclk, pin_mosi) ;
+  #define SPI spim3
+
+#elif defined(NRF52840_XXAA)
  extern SPIClass spiModem;
  #define SPI spiModem
 #endif
@ -121,8 +125,11 @@ bool sx126x::preInit() {
  pinMode(_ss, OUTPUT);
  digitalWrite(_ss, HIGH);
  
-  #if BOARD_MODEL == BOARD_RNODE_NG_22 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK
+  #if BOARD_MODEL == BOARD_T3S3 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK
    SPI.begin(pin_sclk, pin_miso, pin_mosi, pin_cs);
+  #elif BOARD_MODEL == BOARD_TECHO
+    SPI.setPins(pin_miso, pin_sclk, pin_mosi);
+    SPI.begin();
  #else
    SPI.begin();
  #endif
@ -383,29 +390,35 @@ int sx126x::endPacket() {
 }

 unsigned long preamble_detected_at = 0;
-unsigned long header_detected_at = 0;
 extern long lora_preamble_time_ms;
 extern long lora_header_time_ms;
+bool false_preamble_detected = false;
+
 bool sx126x::dcd() {
-  bool carrier_detected = false;
  uint8_t buf[2] = {0}; executeOpcodeRead(OP_GET_IRQ_STATUS_6X, buf, 2);
+  uint32_t now = millis();
+
+  bool header_detected = false;
+  bool carrier_detected = false;
+
+  if ((buf[1] & IRQ_HEADER_DET_MASK_6X) != 0) { header_detected = true; carrier_detected = true; }
+  else { header_detected = false; }

  if ((buf[1] & IRQ_PREAMBLE_DET_MASK_6X) != 0) {
    carrier_detected = true;
-    if (preamble_detected_at == 0) preamble_detected_at = millis();
-    if (millis() - preamble_detected_at > lora_preamble_time_ms + lora_header_time_ms) {
+    if (preamble_detected_at == 0) { preamble_detected_at = now; }
+    if (now - preamble_detected_at > lora_preamble_time_ms + lora_header_time_ms) {
      preamble_detected_at = 0;
+      if (!header_detected) { false_preamble_detected = true; }
      uint8_t clearbuf[2] = {0};
      clearbuf[1] = IRQ_PREAMBLE_DET_MASK_6X;
      executeOpcode(OP_CLEAR_IRQ_STATUS_6X, clearbuf, 2);
    }
  }

-  if ((buf[1] & IRQ_HEADER_DET_MASK_6X) != 0) {
-    carrier_detected = true;
-    header_detected_at = millis();
-  }
-
+  // TODO: Maybe there's a way of unlatching the RSSI
+  // status without re-activating receive mode?
+  if (false_preamble_detected) { sx126x_modem.receive(); false_preamble_detected = false; }
  return carrier_detected;
 }

@ -565,10 +578,12 @@ void sx126x::enableTCXO() {
      uint8_t buf[4] = {MODE_TCXO_1_8V_6X, 0x00, 0x00, 0xFF};
    #elif BOARD_MODEL == BOARD_TBEAM_S_V1
      uint8_t buf[4] = {MODE_TCXO_1_8V_6X, 0x00, 0x00, 0xFF};
-    #elif BOARD_MODEL == BOARD_RNODE_NG_22
+    #elif BOARD_MODEL == BOARD_T3S3
      uint8_t buf[4] = {MODE_TCXO_1_8V_6X, 0x00, 0x00, 0xFF};
    #elif BOARD_MODEL == BOARD_HELTEC_T114
      uint8_t buf[4] = {MODE_TCXO_1_8V_6X, 0x00, 0x00, 0xFF};
+    #elif BOARD_MODEL == BOARD_TECHO
+      uint8_t buf[4] = {MODE_TCXO_1_8V_6X, 0x00, 0x00, 0xFF};
    #endif
    executeOpcode(OP_DIO3_TCXO_CTRL_6X, buf, 4);
  #endif
--- a/sx127x.cpp
+++ b/sx127x.cpp
@ -100,7 +100,7 @@ bool sx127x::preInit() {
  pinMode(_ss, OUTPUT);
  digitalWrite(_ss, HIGH);
  
-  #if BOARD_MODEL == BOARD_RNODE_NG_22
+  #if BOARD_MODEL == BOARD_T3S3
    SPI.begin(pin_sclk, pin_miso, pin_mosi, pin_cs);
  #else
    SPI.begin();
--- a/sx128x.cpp
+++ b/sx128x.cpp
@ -134,7 +134,7 @@ bool sx128x::preInit() {
  
  // TODO: Check if this change causes issues on any platforms
  #if MCU_VARIANT == MCU_ESP32
-    #if BOARD_MODEL == BOARD_RNODE_NG_22 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK
+    #if BOARD_MODEL == BOARD_T3S3 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK
      SPI.begin(pin_sclk, pin_miso, pin_mosi, pin_cs);
    #else
      SPI.begin();
@ -402,29 +402,33 @@ int sx128x::endPacket() {
 }

 unsigned long preamble_detected_at = 0;
-unsigned long header_detected_at = 0;
 extern long lora_preamble_time_ms;
 extern long lora_header_time_ms;
+bool false_preamble_detected = false;
 bool sx128x::dcd() {
-  bool carrier_detected = false;
  uint8_t buf[2] = {0}; executeOpcodeRead(OP_GET_IRQ_STATUS_8X, buf, 2);
+  uint32_t now = millis();
+
+  bool header_detected = false;
+  bool carrier_detected = false;
+
+  if ((buf[1] & IRQ_HEADER_DET_MASK_8X) != 0) { header_detected = true; carrier_detected = true; }
+  else { header_detected = false; }

  if ((buf[0] & IRQ_PREAMBLE_DET_MASK_8X) != 0) {
    carrier_detected = true;
-    if (preamble_detected_at == 0) preamble_detected_at = millis();
-    if (millis() - preamble_detected_at > lora_preamble_time_ms + lora_header_time_ms) {
+    if (preamble_detected_at == 0) { preamble_detected_at = now; }
+    if (now - preamble_detected_at > lora_preamble_time_ms + lora_header_time_ms) {
      preamble_detected_at = 0;
-      uint8_t clearbuf[2] = {0};
-      clearbuf[0] = IRQ_PREAMBLE_DET_MASK_8X;
+      if (!header_detected) { false_preamble_detected = true; }
+      uint8_t clearbuf[2]  = {0}; clearbuf[0] = IRQ_PREAMBLE_DET_MASK_8X;
      executeOpcode(OP_CLEAR_IRQ_STATUS_8X, clearbuf, 2);
    }
  }

-  if ((buf[1] & IRQ_HEADER_DET_MASK_8X) != 0) {
-    carrier_detected = true;
-    header_detected_at = millis();
-  }
-
+  // TODO: Maybe there's a way of unlatching the RSSI
+  // status without re-activating receive mode?
+  if (false_preamble_detected) { sx128x_modem.receive(); false_preamble_detected = false; }
  return carrier_detected;
 }
Author	SHA1	Message	Date
Mark Qvist	de35a9dda0	Updated readme	2025-01-24 13:21:24 +01:00
Mark Qvist	e230c73ee0	Updated console build	2025-01-19 22:14:15 +01:00
Mark Qvist	6bbcaa0ba9	Report battery percentage over BLE battery service	2025-01-18 15:20:58 +01:00
Mark Qvist	9473b9df82	Updated readme	2025-01-18 13:12:02 +01:00
Mark Qvist	2ee0e4eb13	Updated console build	2025-01-17 17:25:24 +01:00
Mark Qvist	926e32ec99	Updated console build	2025-01-17 17:04:27 +01:00
Mark Qvist	16090f73e4	Updated readme	2025-01-17 14:38:55 +01:00
Mark Qvist	919bddb703	Cleanup	2025-01-17 10:44:46 +01:00
Mark Qvist	458e40ce9a	SX1262 register hang debug	2025-01-17 10:44:16 +01:00
Mark Qvist	3ae8982e93	False preamble detection on SX1262	2025-01-16 23:33:49 +01:00
Mark Qvist	4bdd30daac	Cleanup	2025-01-16 23:15:17 +01:00
Mark Qvist	49d023379f	Work around for SX1280 modem RSSI status latch on invalid preamble lengths	2025-01-16 23:01:46 +01:00
Mark Qvist	01a27cfd9b	Display sleep on T-Echo	2025-01-16 12:20:01 +01:00
Mark Qvist	48bce4ea15	Actually, use SPIM3 for SX1262 on T-Echo	2025-01-16 12:19:38 +01:00
Mark Qvist	3379217e19	Sensible e-ink backlight default	2025-01-16 11:15:31 +01:00
Mark Qvist	9b792862b9	Improved T-Echo e-ink sleep	2025-01-16 11:00:39 +01:00
Mark Qvist	68349aaa70	Fixed T-Echo build paths	2025-01-16 10:19:34 +01:00
Mark Qvist	3e98ea14d2	Fixed T-Echo build paths	2025-01-16 09:46:30 +01:00
Mark Qvist	01e346f21f	Added T-Echo to release	2025-01-15 23:57:38 +01:00
Mark Qvist	3fab6d4cdb	Blank T-Echo display on sleep	2025-01-15 21:43:13 +01:00
Mark Qvist	ebf5b54957	Power init for T-Echo	2025-01-15 21:20:43 +01:00
Mark Qvist	4e627d6e6b	Implemented backlight control and display blanking for T-Echo	2025-01-15 21:19:58 +01:00
Mark Qvist	113b2f1081	Battery management for T-Echo	2025-01-15 21:18:52 +01:00
Mark Qvist	733a792d72	Don't use SPIM3 for LoRa on T-Echo	2025-01-15 21:11:19 +01:00
Mark Qvist	ea33f0cba7	T-Echo pin definitions	2025-01-15 21:10:01 +01:00
Mark Qvist	7066b4de6f	Fixed single-byte configuration changes not working on nRF	2025-01-15 21:09:30 +01:00
Mark Qvist	6b815c47d4	LED config on T-Echo	2025-01-15 21:00:02 +01:00
Mark Qvist	f447998c35	Initial T-Echo support	2025-01-15 18:38:34 +01:00
Mark Qvist	2d2d90847a	Initial T-Echo support	2025-01-15 18:38:14 +01:00
Mark Qvist	13266c96db	Cleanup	2025-01-15 14:03:35 +01:00
Mark Qvist	7e30648968	Fixed nRF52 soft-brick on device EEPROM wipe	2025-01-15 12:42:24 +01:00
Mark Qvist	32fc5afee2	Added missing config graphic	2025-01-15 12:41:15 +01:00
Mark Qvist	3073677b82	Added sleep and wake support on T114	2025-01-15 11:01:26 +01:00
Mark Qvist	2119d381b3	Refactored T3S3 board name variable	2025-01-15 10:21:15 +01:00
Mark Qvist	cbe95b10d6	Fixed incorrect display initialisation on T114 causing display noise on startup	2025-01-15 10:20:25 +01:00
Mark Qvist	6f0c849cb3	Fixed missing check in interference avoidance	2025-01-13 21:12:39 +01:00
Mark Qvist	6eaacb7f99	Cleanup	2025-01-13 20:06:51 +01:00
Mark Qvist	8cf6e9cb40	Added battery support to Heltec T114	2025-01-13 18:05:35 +01:00
Mark Qvist	7a505f73e3	Added signalling of detected interference. Added channel stats output on nRF.	2025-01-13 17:02:07 +01:00
Mark Qvist	b4b1d13dc9	Cleanup	2025-01-13 11:38:17 +01:00
Mark Qvist	becc3d0e3d	Implemented display rotation on Heltec T114	2025-01-13 11:37:46 +01:00
Mark Qvist	95895f3756	Set firmware hashes on nRF	2025-01-13 11:37:29 +01:00
Mark Qvist	c1b3b4f416	Updated version	2025-01-13 11:36:42 +01:00
Mark Qvist	62cd3977c7	Added modified ST7789 driver for Heltec T114	2025-01-13 11:36:28 +01:00
Mark Qvist	7235fa6c3f	Updated readme	2025-01-09 21:00:02 +01:00
Mark Qvist	7720fa5192	Updated readme	2025-01-09 20:57:41 +01:00
Mark Qvist	d0041281bd	Updated release	2025-01-09 20:49:22 +01:00