Lora “Letterbox” Project – PART 2

No, Pete’s not regressing to a bygone age. I happen to have a bunch of LOLIN Mini D1 ESP8266 boards lying around, abandoned when I discovered the all-singing ESP32 – and I HATE to see waste – so I’ve had an idea forming for the LoRa Letterbox Alert for the last couple of days – and now working on multiple remotes (it’s now in the code) – please see part 1 before you continue – I had NO IDEA it would go this far….

Firstly , after reducing the software-serial-driven comms for the Reyax RYLR998 LoRa modules from default 115k baud to a more sensible 9600 baud (I’m only sending simple text commands back and forth – ESP8266 – Reyax LoRa board – and only as I was being cautious with the software UART on the ESP8266) – see code below – and testing it to death, today I took my fully functioning but unfeasibly power hungry original NodeMCU ESP8266 + LoRa module (REMOTE END) apart and replaced the remote end with a Lolin D1 Mini board instead.

Why this board? Well, one thing you’ll hear out there is “you need a board with no regulators as they take power regardless” – no such problems here when connecting to 3v3 and GND (NOT USB) on this board once programmed up.

Small, neat, cheap (AliExpress for example) – and remembering again that WiFi on the ESP8266 (remote unit only) has in this case been turned off, no problems with the 2 antenna being close together.

The design requires a connection (microswitch?) from GPIO16 to RST to wake the unit up from sleep.

That’s the hardware sorted – and bearing in mind that the ESP8266 can be put to sleep to save power – and with a test button in the base unit WebUI to tell the remote to sleep, the idea being that the instruction hits the remote ESP8266 which puts the LoRa module to sleep – then the ESP8266 itself – and they all sleep happily ever after until someone opens the letter box flap. When that happens, the ESP8266 wakes up, sends an AT message to the LoRa module which auto-wakes it up – and off we go.

That’s the idea, let’s see how that works in practice and whether the power-saving makes this incredibly cheap and simple idea work. I’m not now using the Arduino IDE for development, the remote unit can be programmed in ESPHOME – albeit by serial as we’ve turned the WiFi OFF in the remote unit…

But before I start – we have set the LoRa unit to work at 9600 baud (non-volatile). This used a simple Arduino sketch ChatGPT made for me – there are other ways but this is what we used. Why a bunch of characters in the code below? Because the LoRa board is picky about exact CRLF.

 #include <SoftwareSerial.h>

SoftwareSerial loraSerial(D6, D7);  // RX, TX

void setup() {
  Serial.begin(115200);

  // RYLR998 is initially at 115200
  loraSerial.begin(115200);

  delay(1000);

  // AT+IPR=9600\r\n
  const uint8_t command[] = {
    0x41, 0x54, 0x2B, 0x49, 0x50, 0x52, 0x3D,
    0x39, 0x36, 0x30, 0x30, 0x0D, 0x0A
  };

  loraSerial.write(command, sizeof(command));

  delay(1000);

  Serial.println("AT+IPR=9600 sent");
}

void loop() {
}

So reading this on conjunction with part 1 for data pins.. with my base unit set up with a WebUI for testing (the ultimate control will be in Home Assistant in my case), I can turn the builtin LED on the D1 on and off remotely, originally I’d watch and report on the the status of D5 input on the remote unit (my ultimate microswitch on the letterbox) and put the remote D1 and it’s LoRa board to sleep – then I realosed taht even D5 was redundant – the act of waking up is enough to know the letterbox (or gate) has been opened. I referred earlier to the obvious – the board combo has to sit OUTSIDE the letterbox as the latter is made of metal… so I was really looking for a setup with a small battery… and a plastic enclosure fastened to the side.

Ok, down to business – as of part 1, this all fell apart (we’d not worked on sleep at that point) because the combined ESP8266/Lora power was 32mA – WAY too high for a battery gadget that has to stay on constantly. That’s when I went off on a tangent to try the D1 Mini. “Wisdom” has it that the ESP8266 isn’t that good at low power but what I discoverered was that the LoRa module was just as bad – 17mA each for a total of 34mA.

Why the LOLIN D1 Mini? I just happen to have some and as it happens I could not have made a better choice. Total current with both (remote) boards awake 34mA. Total current with both boards asleep – a staggering 0.06mA. Now, I don’t really want 3v as my starting point as down to 2.8v could be troublesome (I later discovered the pair work just fine on 2.8v but that may not be repeatable from batch to batch).. but a pair of non-rechargeable, Lithium 1.5v batteries should start a lot neared to 3.2 or 3.3v and a CR2477 round Lithium battery will definitely start nearer 3.2v.. AND I’ve JUST tested down to 2.9v – but read on.

I have the base unit on my messy desk talking to it’s ESPHOME WebUI over WiFi – and the remote board combo hanging off my (currently 3V) adjustable power supply – with an accurate 6-digit meter in-between the D1 (I’m using the D1 3v3 and gnd lines – not the USB) and power supply – but bear in mind, in first tests I put the two units 160 BIG steps apart – all detailed in part 1. Thats not line of sight – that’s my home office around several corners and down a sloping, tree-lined dirt track to the letterbox.

In essense – THIS IS WORKING – do the math – we could be looking at well over a year battery life- Wheee..

The video subtitles aren’t mine – keep up, YouTube… Also the video refers to the now defunct D5 input button/switch press.

Update – batteries – we are indeed looking at almost nothing in sleep mode but 34mA when running for the receiver (combined ESP and the LoRa module – split evenly). That all looked like it was heading towards a CR2450 or similar plenty of capacity to get a year or so out of the unit. Ah, well that’s how it SEEMED but a miserly 34mA KILLS the voltage on those batteries and I found that as they dropped from their original well over 3v down to 2.8v (temporarily) in a matter of seconds – it’s just not going to work… HOWEVER I happened to have a standard utility pack of AAA batteries from our big retail store here in Southern Spain – Obramat – read that as like B&Q in the UK or Home Depot in the USA… not even Lithium non-rechargeables… and they hardly drop voltage AT ALL after several seconds of full-on time so I think a pair of those have got the job..

Meanwhile the circuit for the actual letterbox switch turned out to be surprisingly simple (can’t just use the switch to ground – the posty could leave the letterbox half way open with a big envelope). With GPIO16 tied to RST, I needed a path to ground for the microswitch. I inserted 0.2uf capacitor in series with the switch and ground, and a 100k resistor across the capacitor to leak charge so the unit could be brought out of sleep in practice every minute or two (real use – once a day more likely).

Then we realised a fatal flaw – it was possible to forget to either have the unit flash, then automatically sleep or just sleep. I went off chatting to friends for a few hours – and the poor remote unit was consuming 34mA all that time – no good for the batteries, now sitting at a verified 2.88v (internal sensor says 2.95v) but as all is still working reliably – I’ll keep the batteries in to push this as far as I can. Update – the batteries recovered – days later sitting at 3v.

Meanwhile I have a Home Assistant dashboard item to display – as well as the webUI in the base unit. The entities appeared automagically in Home Assistant but had to add a tile to my control system…. way better wording than the WebUI. Here is the Home Assistant tile:

type: vertical-stack
cards:
  - type: custom:button-card
    name: LORA LETTERBOX ALERT
    show_icon: false
    show_name: true
    styles:
      card:
        - background: '#002200'
        - border: 1px solid darkcyan
        - border-radius: 12px
        - padding: 12px
      name:
        - color: cyan
        - font-size: 18px
        - font-weight: 500
        - text-align: center
        - justify-self: center
  - type: grid
    columns: 2
    square: false
    cards:
      - type: custom:button-card
        name: Flash Remote LED
        icon: mdi:flash
        show_name: true
        show_icon: true
        show_state: true
        state_display: |
          [[[
            const connection =
              states['sensor.lora_transmitter_lora_remote_connection']?.state;

            return connection === 'ONLINE'
              ? 'Press to flash'
              : 'N/A';
          ]]]
        tap_action:
          action: javascript
          javascript: |
            [[[
              const connection =
                states['sensor.lora_transmitter_lora_remote_connection']?.state;

              if (connection === 'ONLINE') {
                hass.callService(
                  'button',
                  'press',
                  {
                    entity_id: 'button.lora_transmitter_flash_remote_led'
                  }
                );
              }
            ]]]
        styles:
          card:
            - background: '#002200'
            - border: 1px solid darkcyan
            - border-radius: 12px
            - padding: 12px
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 40px 1fr
            - grid-template-rows: min-content min-content
          icon:
            - color: |
                [[[
                  const connection =
                    states['sensor.lora_transmitter_lora_remote_connection']?.state;

                  return connection === 'ONLINE' ? 'amber' : 'grey';
                ]]]
            - width: 28px
          name:
            - justify-self: start
            - color: |
                [[[
                  const connection =
                    states['sensor.lora_transmitter_lora_remote_connection']?.state;

                  return connection === 'ONLINE' ? 'cyan' : 'grey';
                ]]]
            - font-size: 14px
            - font-weight: 500
          state:
            - justify-self: start
            - color: |
                [[[
                  const connection =
                    states['sensor.lora_transmitter_lora_remote_connection']?.state;

                  return connection === 'ONLINE' ? 'yellow' : 'grey';
                ]]]
            - font-size: 12px
      - type: custom:mushroom-legacy-template-card
        primary: Sleep Remote
        secondary: >
          {% if is_state('sensor.lora_transmitter_lora_remote_connection',
          'ONLINE') %}
            Press to sleep
          {% else %}
            SLEEPING
          {% endif %}
        icon: mdi:sleep
        icon_color: blue
        tap_action:
          action: call-service
          service: button.press
          target:
            entity_id: button.lora_transmitter_sleep_remote
        card_mod:
          style: |
            ha-card {
              background: #002200;
              border: 1px solid darkcyan;
              border-radius: 12px;
              --card-primary-color: cyan;
              --card-secondary-color: yellow;
            }
  - type: custom:button-card
    name: Remote Status
    icon: mdi:information-outline
    show_name: true
    show_icon: true
    show_state: false
    custom_fields:
      connection: |
        [[[
          const v =
            states['sensor.lora_transmitter_lora_remote_connection']?.state;

          const value = v === 'ONLINE' ? 'ONLINE' : 'SLEEPING';

          return `<div class="status-line"><span>Connection</span><b>${value}</b></div>`;
        ]]]
      battery: |
        [[[
          const connection =
            states['sensor.lora_transmitter_lora_remote_connection']?.state;

          const v =
            states['sensor.lora_transmitter_remote_battery_voltage']?.state;

          let value = 'N/A';

          if (
            connection === 'ONLINE' &&
            v &&
            v !== 'unknown' &&
            v !== 'unavailable'
          ) {
            value = Number(v).toFixed(2) + ' V';
          }

          return `<div class="status-line"><span>Battery</span><b>${value}</b></div>`;
        ]]]
      led: |
        [[[
          const connection =
            states['sensor.lora_transmitter_lora_remote_connection']?.state;

          let value = 'OFF';

          if (
            connection === 'ONLINE' &&
            states['sensor.lora_transmitter_remote_led_flashing']?.state === 'ON'
          ) {
            value = 'ON';
          }

          return `<div class="status-line"><span>LED Flashing</span><b>${value}</b></div>`;
        ]]]
    styles:
      card:
        - background: '#002200'
        - border: 1px solid darkcyan
        - border-radius: 12px
        - padding: 12px 16px
      grid:
        - grid-template-areas: |
            "i n"
            "connection connection"
            "battery battery"
            "led led"
        - grid-template-columns: 24px 1fr
        - grid-template-rows: min-content min-content min-content min-content
        - column-gap: 8px
        - row-gap: 0px
      icon:
        - color: cyan
        - width: 32px
        - align-self: center
      name:
        - justify-self: start
        - align-self: center
        - color: cyan
        - font-size: 16px
        - font-weight: 500
      custom_fields:
        connection:
          - width: 100%
          - justify-self: stretch
          - color: yellow
          - font-size: 14px
        battery:
          - width: 100%
          - justify-self: stretch
          - color: yellow
          - font-size: 14px
        led:
          - width: 100%
          - justify-self: stretch
          - color: yellow
          - font-size: 14px
    tap_action:
      action: none
    card_mod:
      style: |
        ha-card {
          background: #002200;
          border: 1px solid darkcyan;
          border-radius: 12px;
        }

        .status-line {
          display: flex;
          width: 100%;
          justify-content: space-between;
          align-items: center;
          line-height: 20px;
        }

        .status-line span {
          text-align: left;
        }

        .status-line b {
          text-align: right;
          font-weight: 500;
          margin-left: 20px;
        }
  - type: grid
    columns: 2
    square: false
    cards:
      - type: custom:mushroom-legacy-template-card
        primary: Last Letterbox Event
        secondary: >
          {% set s =
          states('sensor.lora_transmitter_lora_remote_input_last_changed') %} {%
          if s in ['unknown', 'unavailable', ''] %}
            No event recorded
          {% else %}
            {{ s }}
          {% endif %}
        icon: mdi:clock-outline
        icon_color: cyan
        tap_action:
          action: none
        card_mod:
          style: |
            ha-card {
              background: #002200;
              border: 1px solid darkcyan;
              border-radius: 12px;
              --card-primary-color: cyan;
              --card-secondary-color: yellow;
            }
      - type: custom:mushroom-legacy-template-card
        primary: Firmware Version
        secondary: >
          {{ states('sensor.office_lora_base_station_lora_base_station_version')
          }}
        icon: mdi:chip
        icon_color: cyan
        tap_action:
          action: none
        card_mod:
          style: |
            ha-card {
              background: #002200;
              border: 1px solid darkcyan;
              border-radius: 12px;
              --card-primary-color: cyan;
              --card-secondary-color: yellow;
            }

As for the remote and base source code for ESPHOME – below (if you didn’t follow the part about reducing the Lora speed from 115k to 960k, adjust the speed in the base and remote back to 115200 bps). To program the base after the first time (USB), use WiFi. For the remote unit always use serial as WiFi is turned off – and you MUST leave RST/gpio16 link disconnected for programming.

# LoRa Remote Unit - LOLIN D1 Mini
# Letterbox wake-up is detected by the GPIO16/RST wake circuit.
# No separate GPIO input is required.
#
# DEVELOPMENT v0.3:
# The letterbox microswitch wakes the ESP8266 through the capacitor/resistor
# GPIO16-to-RST circuit. A wake therefore IS the letterbox event.
# INPUT:ON is then transmitted up to five times, one second apart,
# until the Base acknowledges it with ACK:INPUT. If no ACK is received
# after the fifth attempt, the Remote sends no further input messages
# and then goes to sleep. The Base five-minute safety timeout remains
# the final battery protection.

substitutions:
  device_version: "0.3"

esphome:
  name: lora-remote
  friendly_name: LoRa Remote

  on_boot:
    priority: 800
    then:
      # Wake the RYLR998 from MODE=1 sleep. The first UART activity wakes it.
      - delay: 500ms
      - uart.write:
          id: lora_uart
          data: "AT\r\n"
      - delay: 500ms
      - uart.write:
          id: lora_uart
          data: "AT+MODE=0\r\n"
      - delay: 500ms
      # Tell the Base that the remote has woken, including the unique ESP8266 ID.
      - uart.write:
          id: lora_uart
          data: !lambda |-
            char message[50];
            snprintf(message, sizeof(message),
                     "AT+SEND=2,14,WAKE,ID:%06X\r\n",
                     ESP.getChipId());
            return std::vector<uint8_t>(message, message + strlen(message));
      - delay: 1s
      # Send the ESP8266 VDD voltage to the Base.
      - uart.write:
          id: lora_uart
          data: !lambda |-
            char message[40];
            snprintf(message, sizeof(message),
                     "AT+SEND=2,13,BATTERY:%.3f\r\n",
                     id(remote_vcc).state);
            return std::vector<uint8_t>(message, message + strlen(message));
      - delay: 250ms
      # The wake itself is the letterbox event. Send the normal INPUT:ON
      # notification so the Base can acknowledge it and stop the retries.
      - lambda: |-
          id(input_ack_received) = false;
      - script.execute: send_input_on

# The ESP8266 chip ID is used as the Remote's unique ID.
# It is hardware-derived, requires no WiFi, and is different for each ESP8266.
esp8266:
  board: d1_mini

deep_sleep:
  id: remote_deep_sleep

logger:
  baud_rate: 115200

globals:
  - id: input_ack_received
    type: bool
    restore_value: no
    initial_value: 'false'

output:
  - platform: gpio
    id: onboard_led_output
    pin:
      number: GPIO2
      inverted: true

light:
  - platform: binary
    name: "Remote LED"
    id: remote_led
    output: onboard_led_output
    restore_mode: ALWAYS_OFF

script:
  # Send INPUT:ON, retrying once per second up to five times.
  # The loop stops sending as soon as ACK:INPUT is received.
  - id: send_input_on
    mode: restart
    then:
      - repeat:
          count: 5
          then:
            - if:
                condition:
                  lambda: 'return !id(input_ack_received);'
                then:
                  - logger.log:
                      level: INFO
                      format: "LoRa TX: INPUT:ON + ID"
                  - uart.write:
                      id: lora_uart
                      data: !lambda |-
                        char message[60];
                        snprintf(message, sizeof(message),
                                 "AT+SEND=2,18,INPUT:ON,ID:%06X\r\n",
                                 ESP.getChipId());
                        return std::vector<uint8_t>(message, message + strlen(message));
                  - delay: 1s
      - if:
          condition:
            lambda: 'return !id(input_ack_received);'
          then:
            - logger.log:
                level: WARN
                format: "No INPUT ACK after 5 attempts - going to sleep"
            - script.execute: put_remote_to_sleep

  - id: put_remote_to_sleep
    then:
      # Tell the Base we are going to sleep.
      - uart.write:
          id: lora_uart
          data: "AT+SEND=2,10,DONE:SLEEP\r\n"
      - delay: 250ms
      # Put the RYLR998 into its 10 uA sleep mode.
      - uart.write:
          id: lora_uart
          data: "AT+MODE=1\r\n"
      - delay: 250ms
      # Then put the ESP8266 into deep sleep until the next wake/reset.
      - deep_sleep.enter:
          id: remote_deep_sleep

  - id: send_done_on
    then:
      - uart.write:
          id: lora_uart
          data: "AT+SEND=2,7,DONE:ON\r\n"

  - id: send_done_off
    then:
      - uart.write:
          id: lora_uart
          data: "AT+SEND=2,8,DONE:OFF\r\n"

uart:
  id: lora_uart
  tx_pin: GPIO13
  rx_pin: GPIO12
  baud_rate: 9600
  rx_buffer_size: 256
  debug:
    direction: RX
    dummy_receiver: true
    after:
      delimiter: "\n"
    sequence:
      - lambda: |-
          std::string received(bytes.begin(), bytes.end());

          if (received.find("ACK:INPUT") != std::string::npos) {
            // The Base has received INPUT:ON. Stop any further retries.
            id(input_ack_received) = true;

          } else if (received.find(",SLEEP,") != std::string::npos) {
            id(put_remote_to_sleep).execute();

          } else if (received.find(",ON,") != std::string::npos) {
            id(onboard_led_output).turn_on();
            id(send_done_on).execute();

          } else if (received.find(",OFF,") != std::string::npos) {
            id(onboard_led_output).turn_off();
            id(send_done_off).execute();
          }

sensor:
  - platform: adc
    pin: VCC
    name: "Remote VDD Voltage"
    id: remote_vcc
    unit_of_measurement: "V"
    accuracy_decimals: 3
    update_interval: 1s

And the code for the base:

# LoRa/ESP8266-based Letterbox sensor
# Base starts by turning the currently-awake Remote LED OFF,
# then puts the Remote to sleep for a clean starting state.
#
# SAFETY TIMEOUT:
# If the Remote wakes but is accidentally left running, the Base
# automatically sends SLEEP after 5 minutes. This is deliberately
# handled here rather than in Home Assistant so the Remote is still
# shut down even if Home Assistant is unavailable.

substitutions:
  device_version: "0.91"

esphome:
  name: lora-transmitter
  friendly_name: LoRa Base Station

  on_boot:
    priority: -100
    then:
      - delay: 2s
      - logger.log:
          level: INFO
          format: "Startup: turning Remote LED OFF"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,3,OFF\r\n"
      - delay: 2s
      - logger.log:
          level: INFO
          format: "Startup: putting Remote to sleep"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,5,SLEEP\r\n"

esp8266:
  board: nodemcuv2

wifi:
  networks:
    - ssid: !secret wifi_ssid
      password: !secret wifi_password
    - ssid: !secret wifi_ssid2
      password: !secret wifi_password
    - ssid: !secret wifi_ssid3
      password: !secret wifi_password
    - ssid: !secret wifi_ssid4
      password: !secret wifi_password
    - ssid: !secret wifi_ssid5
      password: !secret wifi_password
  power_save_mode: none
  post_connect_roaming: true

api:

ota:
  - platform: esphome

web_server:
  port: 80
  version: 3
  local: true
  log: false
  sorting_groups:
    - id: controls
      name: "Controls"
      sorting_weight: 10
    - id: remote_status
      name: "LoRa Remote Status"
      sorting_weight: 20
    - id: lora_signal
      name: "LoRa Signal"
      sorting_weight: 30
    - id: wifi_status
      name: "WiFi Status"
      sorting_weight: 40
    - id: system
      name: "System"
      sorting_weight: 50
    - id: debugging
      name: "Debugging"
      sorting_weight: 60

time:
  - platform: sntp
    id: sntp_time

logger:
  baud_rate: 0

globals:
  - id: flash_active
    type: bool
    restore_value: no
    initial_value: 'false'

  - id: remote_awake
    type: bool
    restore_value: no
    initial_value: 'false'

  - id: ack_retry_count
    type: int
    restore_value: no
    initial_value: '0'

script:

  # ============================================================
  # SEND REMOTE TO SLEEP
  # ============================================================

  - id: send_sleep
    mode: restart
    then:
      # Cancel the five-minute safety timeout because the Remote
      # is being deliberately put to sleep now.
      - script.stop: remote_awake_timeout

      - lambda: |-
          id(flash_active) = false;
          id(lora_remote_connection).publish_state("OFFLINE");
          id(remote_awake) = false;
          id(lora_led_flashing).publish_state("OFF");
          id(remote_battery_voltage).publish_state(NAN);
          id(remote_id_sensor).publish_state("");

      - logger.log:
          level: INFO
          format: "LoRa TX: AT+SEND=1,5,SLEEP"

      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,5,SLEEP\r\n"

  # ============================================================
  # FIVE-MINUTE REMOTE SAFETY TIMEOUT
  # ============================================================
  #
  # This runs in the Base ESP8266, not Home Assistant.
  # Whenever the Remote wakes, the timer starts. If the Remote
  # has not already been put to sleep within five minutes, the
  # Base sends the normal SLEEP command automatically.
  #
  # This prevents the battery-powered Remote being left awake
  # accidentally for a long period.

  - id: remote_awake_timeout
    mode: restart
    then:
      - delay: 5min
      - logger.log:
          level: WARN
          format: "Remote awake for 5 minutes - automatic safety sleep"
      - script.execute: send_sleep

  # ============================================================
  # ACKNOWLEDGE REMOTE DELIVERY
  # ============================================================

  - id: send_input_ack
    mode: queued
    then:
      - logger.log:
          level: INFO
          format: "LoRa TX: AT+SEND=1,9,ACK:INPUT"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,9,ACK:INPUT\r\n"

  # ============================================================
  # FLASH REMOTE LED
  # ============================================================

  - id: flash_remote
    mode: restart
    then:
      - lambda: |-
          id(flash_active) = true;
          id(lora_led_flashing).publish_state("ON");

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 1 ON"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,2,ON\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 1 OFF"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,3,OFF\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 2 ON"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,2,ON\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 2 OFF"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,3,OFF\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 3 ON"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,2,ON\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 3 OFF"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,3,OFF\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 4 ON"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,2,ON\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 4 OFF"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,3,OFF\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 5 ON"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,2,ON\r\n"
      - delay: 500ms

      - logger.log:
          level: INFO
          format: "LoRa TX: FLASH cycle 5 OFF"
      - uart.write:
          id: lora_uart
          data: "AT+SEND=1,3,OFF\r\n"
      - delay: 500ms

      # Flashing is complete. send_sleep also cancels the
      # five-minute safety timeout.
      - script.execute: send_sleep

uart:
  id: lora_uart
  tx_pin: D7
  rx_pin: D6
  baud_rate: 9600

  debug:
    direction: RX
    dummy_receiver: true

    after:
      delimiter: "\n"

    sequence:
      - lambda: |-
          std::string received(bytes.begin(), bytes.end());
          ESP_LOGI("lora", "LoRa RX: %s", received.c_str());

          // Extract the unique ESP8266 Remote ID when present.
          size_t id_pos = received.find("ID:");
          if (id_pos != std::string::npos) {
            std::string remote_id = received.substr(id_pos + 3);
            size_t id_end = remote_id.find(',');
            if (id_end != std::string::npos) {
              remote_id = remote_id.substr(0, id_end);
            }
            id(remote_id_sensor).publish_state(remote_id);
          }

          if (received.find("WAKE") != std::string::npos) {
            id(lora_remote_connection).publish_state("ONLINE");
            id(remote_awake) = true;

            if (id(sntp_time).now().is_valid()) {
              id(lora_input_last_changed).publish_state(
                id(sntp_time).now().strftime("%d/%m/%Y %H:%M:%S")
              );
            } else {
              id(lora_input_last_changed).publish_state("Event received");
            }

            // WAKE is the letterbox event. The Remote stays awake.
            // The Base now shows the event and waits for a decision.
            //
            // Start the five-minute safety timer. If nothing else
            // puts the Remote to sleep first, the timer will do it.
            id(remote_awake_timeout).execute();

          } else if (received.find("DONE:ON") != std::string::npos) {
            id(lora_remote_connection).publish_state("ONLINE");

          } else if (received.find("DONE:OFF") != std::string::npos) {
            id(lora_remote_connection).publish_state("ONLINE");

          } else if (received.find("DONE:SLEEP") != std::string::npos) {
            // Remote has confirmed that it is now going to sleep.
            // Cancel any remaining safety timeout.
            id(remote_awake_timeout).stop();
            id(flash_active) = false;
            id(lora_led_flashing).publish_state("OFF");
            id(lora_remote_connection).publish_state("OFFLINE");
            id(remote_battery_voltage).publish_state(NAN);

          } else if (received.find("INPUT:ON") != std::string::npos) {
            // INPUT:ON is now only the Remote's retry/ACK mechanism.
            // WAKE is the letterbox event and has already updated the status.
            // Acknowledge every INPUT:ON, including retries.
            id(send_input_ack).execute();
            id(ack_status).publish_state("ACK RECEIVED");
            if (id(sntp_time).now().is_valid()) {
              id(last_ack).publish_state(
                id(sntp_time).now().strftime("%d/%m/%Y %H:%M:%S")
              );
            } else {
              id(last_ack).publish_state("ACK received");
            }

          } else if (received.find("INPUT:OFF") != std::string::npos) {
            // Do not clear the event indicator here.
            // It remains active until the Base sends SLEEP.

          } else if (received.find("BATTERY:") != std::string::npos) {
            size_t battery_pos = received.find("BATTERY:");
            std::string battery_string = received.substr(battery_pos + 8);
            float battery_voltage = atof(battery_string.c_str());

            // Calibrated against a meter: 2.522 V reported = 2.880 V measured.
            // Correction factor = 2.880 / 2.522 = 1.14195.
            // Current practical correction chosen for the 10-bit ESP8266 ADC.
            //battery_voltage *= 1.23686f;
            battery_voltage *= 1.12f;

            id(remote_battery_voltage).publish_state(battery_voltage);
          }

          // RSSI and SNR extraction
          size_t last_comma = received.rfind(',');
          size_t previous_comma = received.rfind(',', last_comma - 1);

          if (last_comma != std::string::npos &&
              previous_comma != std::string::npos) {

            std::string rssi_string =
              received.substr(previous_comma + 1,
                              last_comma - previous_comma - 1);

            std::string snr_string =
              received.substr(last_comma + 1);

            int rssi = atoi(rssi_string.c_str());
            int snr = atoi(snr_string.c_str());

            id(lora_rssi).publish_state(rssi);
            id(lora_snr).publish_state(snr);

            if (rssi >= -60) {
              id(lora_quality).publish_state("Excellent");
            } else if (rssi >= -80) {
              id(lora_quality).publish_state("Good");
            } else if (rssi >= -100) {
              id(lora_quality).publish_state("OK");
            } else if (rssi >= -115) {
              id(lora_quality).publish_state("Poor");
            } else {
              id(lora_quality).publish_state("Rubbish");
            }
          }

text_sensor:
  - platform: template
    name: "ACK Status"
    id: ack_status
    icon: "mdi:check-network"
    web_server:
      sorting_group_id: debugging
      sorting_weight: 10

  - platform: template
    name: "Last ACK"
    id: last_ack
    icon: "mdi:clock-check-outline"
    web_server:
      sorting_group_id: debugging
      sorting_weight: 20

  - platform: template
    name: "Remote ID"
    id: remote_id_sensor
    icon: "mdi:identifier"
    web_server:
      sorting_group_id: debugging
      sorting_weight: 25

  - platform: template
    name: "LoRa Signal Quality"
    id: lora_quality
    icon: "mdi:signal"
    web_server:
      sorting_group_id: lora_signal
      sorting_weight: 30

  - platform: wifi_info
    ip_address:
      name: "LoRa WiFi IP Address"
      icon: "mdi:ip-network"
      web_server:
        sorting_group_id: wifi_status
        sorting_weight: 20

    ssid:
      name: "LoRa WiFi SSID"
      icon: "mdi:wifi"
      web_server:
        sorting_group_id: wifi_status
        sorting_weight: 10

  - platform: template
    name: "LoRa Base Station Version"
    id: lora_transmitter_version
    lambda: |-
      return {"${device_version}"};
    update_interval: 60s
    web_server:
      sorting_group_id: system
      sorting_weight: 10

  - platform: template
    name: "LoRa Remote Input Last Changed"
    id: lora_input_last_changed
    icon: "mdi:clock-outline"
    web_server:
      sorting_group_id: remote_status
      sorting_weight: 50

  - platform: template
    name: "LoRa Remote Connection"
    id: lora_remote_connection
    icon: "mdi:radio-tower"
    web_server:
      sorting_group_id: remote_status
      sorting_weight: 10

  - platform: template
    name: "Remote LED Flashing"
    id: lora_led_flashing
    icon: "mdi:flash"
    web_server:
      sorting_group_id: remote_status
      sorting_weight: 35

sensor:
  - platform: template
    name: "ACK Retries"
    id: ack_retries
    icon: "mdi:counter"
    accuracy_decimals: 0
    lambda: |-
      return id(ack_retry_count);
    update_interval: 1s
    web_server:
      sorting_group_id: debugging
      sorting_weight: 30

  - platform: template
    name: "LoRa Signal Strength"
    id: lora_rssi
    unit_of_measurement: "dBm"
    icon: "mdi:signal"
    web_server:
      sorting_group_id: lora_signal
      sorting_weight: 10

  - platform: template
    name: "LoRa Signal SNR"
    id: lora_snr
    unit_of_measurement: "dB"
    icon: "mdi:signal"
    web_server:
      sorting_group_id: lora_signal
      sorting_weight: 20

  - platform: template
    name: "Remote Battery Voltage"
    id: remote_battery_voltage
    unit_of_measurement: "V"
    accuracy_decimals: 3
    icon: "mdi:battery-medium"
    web_server:
      sorting_group_id: remote_status
      sorting_weight: 60

  - platform: wifi_signal
    name: "LoRa WiFi Signal Strength"
    update_interval: 60s
    icon: "mdi:wifi"
    web_server:
      sorting_group_id: wifi_status
      sorting_weight: 30

button:
  - platform: template
    name: "Flash Remote LED"
    id: flash_remote_button
    web_server:
      sorting_group_id: controls
      sorting_weight: 10
    on_press:
      - if:
          condition:
            lambda: 'return id(lora_remote_connection).state == "ONLINE";'
          then:
            - script.execute: flash_remote
          else:
            - logger.log:
                level: INFO
                format: "Flash requested but Remote is not ONLINE"

  - platform: template
    name: "Sleep Remote"
    id: sleep_remote
    web_server:
      sorting_group_id: controls
      sorting_weight: 20
    on_press:
      - script.execute: send_sleep

Think that’s it – we’ve added ACK and now I get better range – WAY past my letterbox. This morning it occurred to me if we added a unique ID for the remote unit – which we have done here – and it turns out that the ESP8266 unique 24-bit ID is the easiest way to do that… we could have more than one remote – a tiny change to the remote to send that ID and a change to the base station to associate that with the “button pressed” event would let me monitor gate opening (out gate is also out of WiFi/Zigbee range).

This could go on forever – I think the ID was a good idea – someone opening the gate in the dark of night and seeing that light flashing might think twice before going any further.

In Summary

I’ve tried to give you an honest description of how and why we ended up where we are now and this has been great fun – I’m just waiting for the last eureka moment to get this thing in a box by the sidee of our letterbox. The ESP8266, well, pretty much any AliExpress ESP8266 module will do. As for Lora… I’ve investigated inexpensive alternatives to the modules we used – possibly to improve range and in order to use the code for more exotic ideas – but there I feel I’m banging my head against a brick wall. Taking AliExpress as an example, there are countless LoRa modules out there but I immediately discounted those with an external antenna as that starts to get unnecessarily messy.

Most of the AliExpress descriptions for different modules are “AI GENERATED” – the latest in a long line of cop-outs used by sales companies.

“Disclaimer: This content is generated by AI and does not represent the merchants opinion. The platform and merchants assume no related legal liability.”

That probably implies the merchant hasn’t a CLUE and outright specifies ZERO responsibility if the product works but doesn’t meet your needs. Worse, many of the ads feature multiple options and the description might say for example “up to 10km range” – for WHICH option you might ask – and under what conditions – outer space? In other words such descriptions are utterly useless. How many times have we EVER seen items claiming UP TO whatever speed or range ever actually achieve the headline figure.