Merge branch 'master' into custom-esp32

* Make sure to call randomSeed() on esp32

* Randomize the top 22 bits of the Message ID

* Make it clear that we are not calling randomSeed() on purpose

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

.github/ISSUE_TEMPLATE/Bug Report.yml

@@ -52,6 +52,7 @@ body:
         - Raspberry Pi Pico (W)
         - Relay v1
         - Relay v2
+        - Seeed Wio Tracker 1110
         - DIY
         - Other
     validations:

.github/actions/setup-base/action.yml

@@ -14,7 +14,7 @@ runs:
     - name: Install dependencies 
       shell: bash
       run: |
-        sudo apt-get -y update 
+        sudo apt-get -y update --fix-missing
         sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev
 
     - name: Setup Python

.github/workflows/build_native.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Install libbluetooth
         shell: bash
         run: |
-          sudo apt-get update
+          sudo apt-get update --fix-missing
           sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev
 
       - name: Checkout code

.github/workflows/build_nrf52.yml

@@ -29,6 +29,7 @@ jobs:
           name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
           overwrite: true
           path: |
+            release/*.hex
             release/*.uf2
             release/*.elf
             release/*.zip

.github/workflows/build_raspbian.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Install libbluetooth
         shell: bash
         run: |
-          apt-get update -y
+          apt-get update -y --fix-missing
           apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev
 
       - name: Checkout code

.github/workflows/build_raspbian_armv7l.yml

@@ -13,6 +13,7 @@ jobs:
       - name: Install libbluetooth
         shell: bash
         run: |
+          apt-get update -y --fix-missing
           apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev
 
       - name: Checkout code

.github/workflows/main_matrix.yml

@@ -136,7 +136,7 @@ jobs:
         build-rpi2040,
         package-raspbian,
         package-raspbian-armv7l,
-        package-native
+        package-native,
       ]
     steps:
       - name: Checkout code
@@ -168,6 +168,7 @@ jobs:
           path: |
             ./firmware-*.bin
             ./firmware-*.uf2
+            ./firmware-*.hex
             ./firmware-*-ota.zip
             ./device-*.sh
             ./device-*.bat

.semgrepignore

@@ -1,2 +1,2 @@
 .github/workflows/main_matrix.yml
-src/mesh/compression/unishox2.c
+src/mesh/compression/unishox2.cpp

.trunk/trunk.yaml

@@ -1,6 +1,6 @@
 version: 0.1
 cli:
-  version: 1.22.1
+  version: 1.22.2
 plugins:
   sources:
     - id: trunk
@@ -31,6 +31,10 @@ lint:
     - gitleaks@8.18.2
     - clang-format@16.0.3
     - prettier@3.2.5
+  ignore:
+    - linters: [ALL]
+      paths:
+        - bin/**
 runtimes:
   enabled:
     - python@3.10.8

Dockerfile

@@ -7,8 +7,6 @@ ENV TZ=Etc/UTC
 # > At the moment, setting "LANG=C" on a Linux system *fundamentally breaks Python 3*, and that's not OK.
 ENV LANG C.UTF-8
 
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
 # Install build deps
 USER root
 
@@ -24,10 +22,10 @@ USER mesh
 
 WORKDIR /tmp/firmware
 RUN python3 -m venv /tmp/firmware 
-RUN source ./bin/activate && pip3 install --no-cache-dir -U platformio==6.1.14
+RUN bash -o pipefail -c "source bin/activate; pip3 install --no-cache-dir -U platformio==6.1.15"
 # trunk-ignore(terrascan/AC_DOCKER_00024): We would actually like these files to be owned by mesh tyvm
 COPY --chown=mesh:mesh . /tmp/firmware
-RUN source ./bin/activate && chmod +x /tmp/firmware/bin/build-native.sh && ./bin/build-native.sh
+RUN bash -o pipefail -c "source ./bin/activate && bash ./bin/build-native.sh"
 RUN cp "/tmp/firmware/release/meshtasticd_linux_$(uname -m)" "/tmp/firmware/release/meshtasticd"
 
 

bin/build-nrf52.sh

@@ -23,8 +23,10 @@ basename=firmware-$1-$VERSION
 
 pio run --environment $1 # -v
 SRCELF=.pio/build/$1/firmware.elf
-DFUPKG=.pio/build/$1/firmware.zip
 cp $SRCELF $OUTDIR/$basename.elf
+
+echo "Generating NRF52 dfu file"
+DFUPKG=.pio/build/$1/firmware.zip
 cp $DFUPKG $OUTDIR/$basename-ota.zip
 
 echo "Generating NRF52 uf2 file"
@@ -33,13 +35,14 @@ SRCHEX=.pio/build/$1/firmware.hex
 # if WM1110 target, merge hex with softdevice 7.3.0
 if (echo $1 | grep -q "wio-sdk-wm1110"); then
 	echo "Merging with softdevice"
-    sudo chmod +x ./bin/mergehex
-	bin/mergehex -m bin/s140_nrf52_7.3.0_softdevice.hex $SRCHEX -o .pio/build/$1/merged_fimware.hex
-	SRCHEX=.pio/build/$1/merged_fimware.hex
+	bin/mergehex -m bin/s140_nrf52_7.3.0_softdevice.hex $SRCHEX -o .pio/build/$1/$basename.hex
+	SRCHEX=.pio/build/$1/$basename.hex
+	bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
+	cp $SRCHEX $OUTDIR
+	cp bin/*.uf2 $OUTDIR
+else
+	bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
+	cp bin/device-install.* $OUTDIR
+	cp bin/device-update.* $OUTDIR
+	cp bin/*.uf2 $OUTDIR
 fi
-
-bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
-
-cp bin/device-install.* $OUTDIR
-cp bin/device-update.* $OUTDIR
-cp bin/*.uf2 $OUTDIR

bin/platformio-custom.py

@@ -7,6 +7,7 @@ from readprops import readProps
 
 Import("env")
 platform = env.PioPlatform()
+board = env.GetProjectOption("board")
 
 
 def esp32_create_combined_bin(source, target, env):
@@ -77,6 +78,9 @@ if platform.name == "espressif32":
     else:
         # For newer ESP32 targets, using newlib nano works better.
         env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
+    if board == "ttgo-t-beam":
+        print("patching esp32 libs")
+        env.Execute("tar -xvf bin/arduino-esp32-libs-release_*tar.gz -C ~/.platformio/packages/framework-arduinoespressif32/")
 
 Import("projenv")
 
@@ -90,4 +94,4 @@ projenv.Append(
         "-DAPP_VERSION=" + verObj["long"],
         "-DAPP_VERSION_SHORT=" + verObj["short"],
     ]
-)
+)

bin/uf2conv.py

@@ -1,39 +1,38 @@
 #!/usr/bin/env python3
-import sys
-import struct
-import subprocess
-import re
+import argparse
 import os
 import os.path
-import argparse
+import re
+import struct
+import subprocess
+import sys
 
-
-UF2_MAGIC_START0 = 0x0A324655 # "UF2\n"
-UF2_MAGIC_START1 = 0x9E5D5157 # Randomly selected
-UF2_MAGIC_END    = 0x0AB16F30 # Ditto
+UF2_MAGIC_START0 = 0x0A324655  # "UF2\n"
+UF2_MAGIC_START1 = 0x9E5D5157  # Randomly selected
+UF2_MAGIC_END = 0x0AB16F30  # Ditto
 
 families = {
-    'SAMD21': 0x68ed2b88,
-    'SAML21': 0x1851780a,
-    'SAMD51': 0x55114460,
-    'NRF52': 0x1b57745f,
-    'STM32F0': 0x647824b6,
-    'STM32F1': 0x5ee21072,
-    'STM32F2': 0x5d1a0a2e,
-    'STM32F3': 0x6b846188,
-    'STM32F4': 0x57755a57,
-    'STM32F7': 0x53b80f00,
-    'STM32G0': 0x300f5633,
-    'STM32G4': 0x4c71240a,
-    'STM32H7': 0x6db66082,
-    'STM32L0': 0x202e3a91,
-    'STM32L1': 0x1e1f432d,
-    'STM32L4': 0x00ff6919,
-    'STM32L5': 0x04240bdf,
-    'STM32WB': 0x70d16653,
-    'STM32WL': 0x21460ff0,
-    'ATMEGA32': 0x16573617,
-    'MIMXRT10XX': 0x4FB2D5BD
+    "SAMD21": 0x68ED2B88,
+    "SAML21": 0x1851780A,
+    "SAMD51": 0x55114460,
+    "NRF52": 0x1B57745F,
+    "STM32F0": 0x647824B6,
+    "STM32F1": 0x5EE21072,
+    "STM32F2": 0x5D1A0A2E,
+    "STM32F3": 0x6B846188,
+    "STM32F4": 0x57755A57,
+    "STM32F7": 0x53B80F00,
+    "STM32G0": 0x300F5633,
+    "STM32G4": 0x4C71240A,
+    "STM32H7": 0x6DB66082,
+    "STM32L0": 0x202E3A91,
+    "STM32L1": 0x1E1F432D,
+    "STM32L4": 0x00FF6919,
+    "STM32L5": 0x04240BDF,
+    "STM32WB": 0x70D16653,
+    "STM32WL": 0x21460FF0,
+    "ATMEGA32": 0x16573617,
+    "MIMXRT10XX": 0x4FB2D5BD,
 }
 
 INFO_FILE = "/INFO_UF2.TXT"
@@ -46,15 +45,17 @@ def is_uf2(buf):
     w = struct.unpack("<II", buf[0:8])
     return w[0] == UF2_MAGIC_START0 and w[1] == UF2_MAGIC_START1
 
+
 def is_hex(buf):
     try:
         w = buf[0:30].decode("utf-8")
     except UnicodeDecodeError:
         return False
-    if w[0] == ':' and re.match(b"^[:0-9a-fA-F\r\n]+$", buf):
+    if w[0] == ":" and re.match(b"^[:0-9a-fA-F\r\n]+$", buf):
         return True
     return False
 
+
 def convert_from_uf2(buf):
     global appstartaddr
     numblocks = len(buf) // 512
@@ -62,7 +63,7 @@ def convert_from_uf2(buf):
     outp = b""
     for blockno in range(numblocks):
         ptr = blockno * 512
-        block = buf[ptr:ptr + 512]
+        block = buf[ptr : ptr + 512]
         hd = struct.unpack(b"<IIIIIIII", block[0:32])
         if hd[0] != UF2_MAGIC_START0 or hd[1] != UF2_MAGIC_START1:
             print("Skipping block at " + ptr + "; bad magic")
@@ -80,7 +81,7 @@ def convert_from_uf2(buf):
         padding = newaddr - curraddr
         if padding < 0:
             assert False, "Block out of order at " + ptr
-        if padding > 10*1024*1024:
+        if padding > 10 * 1024 * 1024:
             assert False, "More than 10M of padding needed at " + ptr
         if padding % 4 != 0:
             assert False, "Non-word padding size at " + ptr
@@ -91,6 +92,7 @@ def convert_from_uf2(buf):
         curraddr = newaddr + datalen
     return outp
 
+
 def convert_to_carray(file_content):
     outp = "const unsigned char bindata[] __attribute__((aligned(16))) = {"
     for i in range(len(file_content)):
@@ -100,6 +102,7 @@ def convert_to_carray(file_content):
     outp += "\n};\n"
     return outp
 
+
 def convert_to_uf2(file_content):
     global familyid
     datapadding = b""
@@ -109,13 +112,21 @@ def convert_to_uf2(file_content):
     outp = b""
     for blockno in range(numblocks):
         ptr = 256 * blockno
-        chunk = file_content[ptr:ptr + 256]
+        chunk = file_content[ptr : ptr + 256]
         flags = 0x0
         if familyid:
             flags |= 0x2000
-        hd = struct.pack(b"<IIIIIIII",
-            UF2_MAGIC_START0, UF2_MAGIC_START1,
-            flags, ptr + appstartaddr, 256, blockno, numblocks, familyid)
+        hd = struct.pack(
+            b"<IIIIIIII",
+            UF2_MAGIC_START0,
+            UF2_MAGIC_START1,
+            flags,
+            ptr + appstartaddr,
+            256,
+            blockno,
+            numblocks,
+            familyid,
+        )
         while len(chunk) < 256:
             chunk += b"\x00"
         block = hd + chunk + datapadding + struct.pack(b"<I", UF2_MAGIC_END)
@@ -123,6 +134,7 @@ def convert_to_uf2(file_content):
         outp += block
     return outp
 
+
 class Block:
     def __init__(self, addr):
         self.addr = addr
@@ -133,35 +145,44 @@ class Block:
         flags = 0x0
         if familyid:
             flags |= 0x2000
-        hd = struct.pack("<IIIIIIII",
-            UF2_MAGIC_START0, UF2_MAGIC_START1,
-            flags, self.addr, 256, blockno, numblocks, familyid)
+        hd = struct.pack(
+            "<IIIIIIII",
+            UF2_MAGIC_START0,
+            UF2_MAGIC_START1,
+            flags,
+            self.addr,
+            256,
+            blockno,
+            numblocks,
+            familyid,
+        )
         hd += self.bytes[0:256]
         while len(hd) < 512 - 4:
             hd += b"\x00"
         hd += struct.pack("<I", UF2_MAGIC_END)
         return hd
 
+
 def convert_from_hex_to_uf2(buf):
     global appstartaddr
     appstartaddr = None
     upper = 0
     currblock = None
     blocks = []
-    for line in buf.split('\n'):
+    for line in buf.split("\n"):
         if line[0] != ":":
             continue
         i = 1
         rec = []
         while i < len(line) - 1:
-            rec.append(int(line[i:i+2], 16))
+            rec.append(int(line[i : i + 2], 16))
             i += 2
         tp = rec[3]
         if tp == 4:
             upper = ((rec[4] << 8) | rec[5]) << 16
         elif tp == 2:
             upper = ((rec[4] << 8) | rec[5]) << 4
-            assert (upper & 0xffff) == 0
+            assert (upper & 0xFFFF) == 0
         elif tp == 1:
             break
         elif tp == 0:
@@ -170,10 +191,10 @@ def convert_from_hex_to_uf2(buf):
                 appstartaddr = addr
             i = 4
             while i < len(rec) - 1:
-                if not currblock or currblock.addr & ~0xff != addr & ~0xff:
-                    currblock = Block(addr & ~0xff)
+                if not currblock or currblock.addr & ~0xFF != addr & ~0xFF:
+                    currblock = Block(addr & ~0xFF)
                     blocks.append(currblock)
-                currblock.bytes[addr & 0xff] = rec[i]
+                currblock.bytes[addr & 0xFF] = rec[i]
                 addr += 1
                 i += 1
     numblocks = len(blocks)
@@ -182,17 +203,28 @@ def convert_from_hex_to_uf2(buf):
         resfile += blocks[i].encode(i, numblocks)
     return resfile
 
+
 def to_str(b):
     return b.decode("utf-8")
 
+
 def get_drives():
     drives = []
     if sys.platform == "win32":
-        r = subprocess.check_output(["wmic", "PATH", "Win32_LogicalDisk",
-                                     "get", "DeviceID,", "VolumeName,",
-                                     "FileSystem,", "DriveType"])
-        for line in to_str(r).split('\n'):
-            words = re.split('\s+', line)
+        r = subprocess.check_output(
+            [
+                "wmic",
+                "PATH",
+                "Win32_LogicalDisk",
+                "get",
+                "DeviceID,",
+                "VolumeName,",
+                "FileSystem,",
+                "DriveType",
+            ]
+        )
+        for line in to_str(r).split("\n"):
+            words = re.split("\\s+", line)
             if len(words) >= 3 and words[1] == "2" and words[2] == "FAT":
                 drives.append(words[0])
     else:
@@ -206,7 +238,6 @@ def get_drives():
         for d in os.listdir(rootpath):
             drives.append(os.path.join(rootpath, d))
 
-
     def has_info(d):
         try:
             return os.path.isfile(d + INFO_FILE)
@@ -217,7 +248,7 @@ def get_drives():
 
 
 def board_id(path):
-    with open(path + INFO_FILE, mode='r') as file:
+    with open(path + INFO_FILE, mode="r") as file:
         file_content = file.read()
     return re.search("Board-ID: ([^\r\n]*)", file_content).group(1)
 
@@ -235,30 +266,61 @@ def write_file(name, buf):
 
 def main():
     global appstartaddr, familyid
+
     def error(msg):
         print(msg)
         sys.exit(1)
-    parser = argparse.ArgumentParser(description='Convert to UF2 or flash directly.')
-    parser.add_argument('input', metavar='INPUT', type=str, nargs='?',
-                        help='input file (HEX, BIN or UF2)')
-    parser.add_argument('-b' , '--base', dest='base', type=str,
-                        default="0x2000",
-                        help='set base address of application for BIN format (default: 0x2000)')
-    parser.add_argument('-o' , '--output', metavar="FILE", dest='output', type=str,
-                        help='write output to named file; defaults to "flash.uf2" or "flash.bin" where sensible')
-    parser.add_argument('-d' , '--device', dest="device_path",
-                        help='select a device path to flash')
-    parser.add_argument('-l' , '--list', action='store_true',
-                        help='list connected devices')
-    parser.add_argument('-c' , '--convert', action='store_true',
-                        help='do not flash, just convert')
-    parser.add_argument('-D' , '--deploy', action='store_true',
-                        help='just flash, do not convert')
-    parser.add_argument('-f' , '--family', dest='family', type=str,
-                        default="0x0",
-                        help='specify familyID - number or name (default: 0x0)')
-    parser.add_argument('-C' , '--carray', action='store_true',
-                        help='convert binary file to a C array, not UF2')
+
+    parser = argparse.ArgumentParser(description="Convert to UF2 or flash directly.")
+    parser.add_argument(
+        "input",
+        metavar="INPUT",
+        type=str,
+        nargs="?",
+        help="input file (HEX, BIN or UF2)",
+    )
+    parser.add_argument(
+        "-b",
+        "--base",
+        dest="base",
+        type=str,
+        default="0x2000",
+        help="set base address of application for BIN format (default: 0x2000)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="FILE",
+        dest="output",
+        type=str,
+        help='write output to named file; defaults to "flash.uf2" or "flash.bin" where sensible',
+    )
+    parser.add_argument(
+        "-d", "--device", dest="device_path", help="select a device path to flash"
+    )
+    parser.add_argument(
+        "-l", "--list", action="store_true", help="list connected devices"
+    )
+    parser.add_argument(
+        "-c", "--convert", action="store_true", help="do not flash, just convert"
+    )
+    parser.add_argument(
+        "-D", "--deploy", action="store_true", help="just flash, do not convert"
+    )
+    parser.add_argument(
+        "-f",
+        "--family",
+        dest="family",
+        type=str,
+        default="0x0",
+        help="specify familyID - number or name (default: 0x0)",
+    )
+    parser.add_argument(
+        "-C",
+        "--carray",
+        action="store_true",
+        help="convert binary file to a C array, not UF2",
+    )
     args = parser.parse_args()
     appstartaddr = int(args.base, 0)
 
@@ -268,14 +330,17 @@ def main():
         try:
             familyid = int(args.family, 0)
         except ValueError:
-            error("Family ID needs to be a number or one of: " + ", ".join(families.keys()))
+            error(
+                "Family ID needs to be a number or one of: "
+                + ", ".join(families.keys())
+            )
 
     if args.list:
         list_drives()
     else:
         if not args.input:
             error("Need input file")
-        with open(args.input, mode='rb') as f:
+        with open(args.input, mode="rb") as f:
             inpbuf = f.read()
         from_uf2 = is_uf2(inpbuf)
         ext = "uf2"
@@ -291,8 +356,10 @@ def main():
             ext = "h"
         else:
             outbuf = convert_to_uf2(inpbuf)
-        print("Converting to %s, output size: %d, start address: 0x%x" %
-              (ext, len(outbuf), appstartaddr))
+        print(
+            "Converting to %s, output size: %d, start address: 0x%x"
+            % (ext, len(outbuf), appstartaddr)
+        )
         if args.convert or ext != "uf2":
             drives = []
             if args.output == None:

boards/heltec_mesh_node_t114.json

@@ -0,0 +1,53 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_PCA10056 -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      ["0x239A", "0x4405"],
+      ["0x239A", "0x0029"],
+      ["0x239A", "0x002A"]
+    ],
+    "usb_product": "HT-n5262",
+    "mcu": "nrf52840",
+    "variant": "heltec_mesh_node_t114",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino"],
+  "name": "Heltec nrf (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  },
+  "url": "FIXME",
+  "vendor": "Heltec"
+}

boards/heltec_vision_master_e213.json

@@ -0,0 +1,42 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_8MB.csv"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [
+      ["0x303A", "0x1001"],
+      ["0x303A", "0x0002"]
+    ],
+    "mcu": "esp32s3",
+    "variant": "heltec_vision_master_e213"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "Heltec Vision Master E213",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 8388608,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://heltec.org/project/vision-master-e213/",
+  "vendor": "Heltec"
+}

boards/wio-t1000-s.json

@@ -0,0 +1,58 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v7.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_WIO_WM1110 -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      ["0x239A", "0x8029"],
+      ["0x239A", "0x0029"],
+      ["0x239A", "0x002A"],
+      ["0x239A", "0x802A"]
+    ],
+    "usb_product": "WIO-BOOT",
+    "mcu": "nrf52840",
+    "variant": "Seeed_WIO_WM1110",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "7.3.0",
+      "sd_fwid": "0x0123"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Seeed WIO WM1110",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "nrfutil",
+      "stlink",
+      "cmsis-dap",
+      "blackmagic"
+    ],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  },
+  "url": "https://www.seeedstudio.com/LoRaWAN-Tracker-c-1938.html",
+  "vendor": "Seeed Studio"
+}

platformio.ini

@@ -35,6 +35,10 @@ default_envs = tbeam
 ;default_envs = radiomaster_900_bandit_nano
 ;default_envs = radiomaster_900_bandit_micro
 ;default_envs = heltec_capsule_sensor_v3
+;default_envs = heltec_vision_master_t190
+;default_envs = heltec_vision_master_e213
+;default_envs = heltec_vision_master_e290
+;default_envs = heltec_mesh_node_t114
 
 extra_configs =
   arch/*/*.ini

src/ButtonThread.cpp

@@ -43,6 +43,8 @@ ButtonThread::ButtonThread() : OSThread("Button")
     int pin = config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN; // Resolved button pin
 #if defined(HELTEC_CAPSULE_SENSOR_V3)
     this->userButton = OneButton(pin, false, false);
+#elif defined(BUTTON_ACTIVE_LOW) // change by WayenWeng
+    this->userButton = OneButton(pin, BUTTON_ACTIVE_LOW, BUTTON_ACTIVE_PULLUP);
 #else
     this->userButton = OneButton(pin, true, true);
 #endif
@@ -51,8 +53,12 @@ ButtonThread::ButtonThread() : OSThread("Button")
 
 #ifdef INPUT_PULLUP_SENSE
     // Some platforms (nrf52) have a SENSE variant which allows wake from sleep - override what OneButton did
+#ifdef BUTTON_SENSE_TYPE // change by WayenWeng
+    pinMode(pin, BUTTON_SENSE_TYPE);
+#else
     pinMode(pin, INPUT_PULLUP_SENSE);
 #endif
+#endif
 
 #if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
     userButton.attachClick(userButtonPressed);

src/Power.cpp

@@ -232,12 +232,20 @@ class AnalogBatteryLevel : public HasBatteryLevel
             raw = espAdcRead();
             scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
             scaled *= operativeAdcMultiplier;
-#else // block for all other platforms
+#else           // block for all other platforms
+#ifdef ADC_CTRL // enable adc voltage divider when we need to read
+            pinMode(ADC_CTRL, OUTPUT);
+            digitalWrite(ADC_CTRL, ADC_CTRL_ENABLED);
+            delay(10);
+#endif
             for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
                 raw += analogRead(BATTERY_PIN);
             }
             raw = raw / BATTERY_SENSE_SAMPLES;
             scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
+#ifdef ADC_CTRL // disable adc voltage divider when we need to read
+            digitalWrite(ADC_CTRL, !ADC_CTRL_ENABLED);
+#endif
 #endif
 
             if (!initial_read_done) {
@@ -441,6 +449,11 @@ class AnalogBatteryLevel : public HasBatteryLevel
             if (!ina260Sensor.isInitialized())
                 return ina260Sensor.runOnce() > 0;
             return ina260Sensor.isRunning();
+        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first ==
+                   config.power.device_battery_ina_address) {
+            if (!ina3221Sensor.isInitialized())
+                return ina3221Sensor.runOnce() > 0;
+            return ina3221Sensor.isRunning();
         }
         return false;
     }

src/SerialConsole.cpp

@@ -7,8 +7,12 @@
 #ifdef RP2040_SLOW_CLOCK
 #define Port Serial2
 #else
+#ifdef USER_DEBUG_PORT // change by WayenWeng
+#define Port USER_DEBUG_PORT
+#else
 #define Port Serial
 #endif
+#endif
 // Defaulting to the formerly removed phone_timeout_secs value of 15 minutes
 #define SERIAL_CONNECTION_TIMEOUT (15 * 60) * 1000UL
 

src/configuration.h

@@ -171,10 +171,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // -----------------------------------------------------------------------------
 // GPS
 // -----------------------------------------------------------------------------
-#ifndef GPS_BAUDRATE
-#define GPS_BAUDRATE 9600
-#endif
-
 #ifndef GPS_THREAD_INTERVAL
 #define GPS_THREAD_INTERVAL 200
 #endif
@@ -185,6 +181,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Step #1: offer chance for variant-specific defines */
 #include "variant.h"
 
+#ifndef GPS_BAUDRATE
+#define GPS_BAUDRATE 9600
+#endif
+
 /* Step #2: follow with defines common to the architecture;
    also enable HAS_ option not specifically disabled by variant.h */
 #include "architecture.h"
@@ -313,4 +313,4 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 #include "DebugConfiguration.h"
-#include "RF95Configuration.h"
+#include "RF95Configuration.h"

src/gps/GPS.cpp

@@ -9,6 +9,7 @@
 #include "main.h" // pmu_found
 #include "sleep.h"
 
+#include "GPSUpdateScheduling.h"
 #include "cas.h"
 #include "ubx.h"
 
@@ -22,19 +23,6 @@
 #define GPS_RESET_MODE HIGH
 #endif
 
-// How many minutes of sleep make it worthwhile to power-off the GPS
-// Shorter than this, and GPS will only enter standby
-// Affected by lock-time, and config.position.gps_update_interval
-#ifndef GPS_STANDBY_THRESHOLD_MINUTES
-#define GPS_STANDBY_THRESHOLD_MINUTES 15
-#endif
-
-// How many seconds of sleep make it worthwhile for the GPS to use powered-on standby
-// Shorter than this, and we'll just wait instead
-#ifndef GPS_IDLE_THRESHOLD_SECONDS
-#define GPS_IDLE_THRESHOLD_SECONDS 10
-#endif
-
 #if defined(NRF52840_XXAA) || defined(NRF52833_XXAA) || defined(ARCH_ESP32) || defined(ARCH_PORTDUINO)
 HardwareSerial *GPS::_serial_gps = &Serial1;
 #else
@@ -43,6 +31,8 @@ HardwareSerial *GPS::_serial_gps = NULL;
 
 GPS *gps = nullptr;
 
+GPSUpdateScheduling scheduling;
+
 /// Multiple GPS instances might use the same serial port (in sequence), but we can
 /// only init that port once.
 static bool didSerialInit;
@@ -52,6 +42,25 @@ uint8_t uBloxProtocolVersion;
 #define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
 #define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
 
+// For logging
+const char *getGPSPowerStateString(GPSPowerState state)
+{
+    switch (state) {
+    case GPS_ACTIVE:
+        return "ACTIVE";
+    case GPS_IDLE:
+        return "IDLE";
+    case GPS_SOFTSLEEP:
+        return "SOFTSLEEP";
+    case GPS_HARDSLEEP:
+        return "HARDSLEEP";
+    case GPS_OFF:
+        return "OFF";
+    default:
+        assert(false); // Unhandled enum value..
+    }
+}
+
 void GPS::UBXChecksum(uint8_t *message, size_t length)
 {
     uint8_t CK_A = 0, CK_B = 0;
@@ -391,9 +400,14 @@ bool GPS::setup()
     int msglen = 0;
 
     if (!didSerialInit) {
-#if !defined(GPS_UC6580)
 
         if (tx_gpio && gnssModel == GNSS_MODEL_UNKNOWN) {
+
+            // if GPS_BAUDRATE is specified in variant (i.e. not 9600), skip to the specified rate.
+            if (speedSelect == 0 && GPS_BAUDRATE != serialSpeeds[speedSelect]) {
+                speedSelect = std::find(serialSpeeds, std::end(serialSpeeds), GPS_BAUDRATE) - serialSpeeds;
+            }
+
             LOG_DEBUG("Probing for GPS at %d \n", serialSpeeds[speedSelect]);
             gnssModel = probe(serialSpeeds[speedSelect]);
             if (gnssModel == GNSS_MODEL_UNKNOWN) {
@@ -409,9 +423,6 @@ bool GPS::setup()
         } else {
             gnssModel = GNSS_MODEL_UNKNOWN;
         }
-#else
-        gnssModel = GNSS_MODEL_UC6580;
-#endif
 
         if (gnssModel == GNSS_MODEL_MTK) {
             /*
@@ -767,7 +778,6 @@ bool GPS::setup()
     }
 
     notifyDeepSleepObserver.observe(&notifyDeepSleep);
-    notifyGPSSleepObserver.observe(&notifyGPSSleep);
 
     return true;
 }
@@ -776,124 +786,185 @@ GPS::~GPS()
 {
     // we really should unregister our sleep observer
     notifyDeepSleepObserver.unobserve(&notifyDeepSleep);
-    notifyGPSSleepObserver.observe(&notifyGPSSleep);
 }
 
-const char *GPS::powerStateToString()
+// Put the GPS hardware into a specified state
+void GPS::setPowerState(GPSPowerState newState, uint32_t sleepTime)
 {
-    switch (powerState) {
-    case GPS_OFF:
-        return "OFF";
-    case GPS_IDLE:
-        return "IDLE";
-    case GPS_STANDBY:
-        return "STANDBY";
+    // Update the stored GPSPowerstate, and create local copies
+    GPSPowerState oldState = powerState;
+    powerState = newState;
+    LOG_INFO("GPS power state moving from %s to %s\n", getGPSPowerStateString(oldState), getGPSPowerStateString(newState));
+
+    switch (newState) {
     case GPS_ACTIVE:
-        return "ACTIVE";
-    default:
-        return "UNKNOWN";
+    case GPS_IDLE:
+        if (oldState == GPS_ACTIVE || oldState == GPS_IDLE) // If hardware already awake, no changes needed
+            break;
+        if (oldState != GPS_ACTIVE && oldState != GPS_IDLE) // If hardware just waking now, clear buffer
+            clearBuffer();
+        powerMon->setState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(true);                                         // Power (EN pin): on
+        setPowerPMU(true);                                        // Power (PMU): on
+        writePinStandby(false);                                   // Standby (pin): awake (not standby)
+        setPowerUBLOX(true);                                      // Standby (UBLOX): awake
+        break;
+
+    case GPS_SOFTSLEEP:
+        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(true);                                           // Power (EN pin): on
+        setPowerPMU(true);                                          // Power (PMU): on
+        writePinStandby(true);                                      // Standby (pin): asleep (not awake)
+        setPowerUBLOX(false, sleepTime);                            // Standby (UBLOX): asleep, timed
+        break;
+
+    case GPS_HARDSLEEP:
+        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(false);                                          // Power (EN pin): off
+        setPowerPMU(false);                                         // Power (PMU): off
+        writePinStandby(true);                                      // Standby (pin): asleep (not awake)
+        setPowerUBLOX(false, sleepTime);                            // Standby (UBLOX): asleep, timed
+        break;
+
+    case GPS_OFF:
+        assert(sleepTime == 0);                                     // This is an indefinite sleep
+        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(false);                                          // Power (EN pin): off
+        setPowerPMU(false);                                         // Power (PMU): off
+        writePinStandby(true);                                      // Standby (pin): asleep
+        setPowerUBLOX(false, 0);                                    // Standby (UBLOX): asleep, indefinitely
+        break;
     }
 }
 
-void GPS::setGPSPower(bool on, bool standbyOnly, uint32_t sleepTime)
+// Set power with EN pin, if relevant
+void GPS::writePinEN(bool on)
 {
-    // Record the current powerState
-    if (on)
-        powerState = GPS_ACTIVE;
-    else if (!enabled) // User has disabled with triple press
-        powerState = GPS_OFF;
-    else if (sleepTime <= GPS_IDLE_THRESHOLD_SECONDS * 1000UL)
-        powerState = GPS_IDLE;
-    else if (standbyOnly)
-        powerState = GPS_STANDBY;
-    else
-        powerState = GPS_OFF;
-
-    LOG_DEBUG("GPS::powerState=%s\n", powerStateToString());
-
-    // If the next update is due *really soon*, don't actually power off or enter standby. Just wait it out.
-    if (!on && powerState == GPS_IDLE)
+    // Abort: if conflict with Canned Messages when using Wisblock(?)
+    if (HW_VENDOR == meshtastic_HardwareModel_RAK4631 && (rotaryEncoderInterruptImpl1 || upDownInterruptImpl1))
         return;
 
-    if (on) {
-        powerMon->setState(meshtastic_PowerMon_State_GPS_Active);
-        clearBuffer(); // drop any old data waiting in the buffer before re-enabling
-        if (en_gpio)
-            digitalWrite(en_gpio, on ? GPS_EN_ACTIVE : !GPS_EN_ACTIVE); // turn this on if defined, every time
-    } else {
-        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active);
-    }
-    isInPowersave = !on;
-    if (!standbyOnly && en_gpio != 0 &&
-        !(HW_VENDOR == meshtastic_HardwareModel_RAK4631 && (rotaryEncoderInterruptImpl1 || upDownInterruptImpl1))) {
-        LOG_DEBUG("GPS powerdown using GPS_EN_ACTIVE\n");
-        digitalWrite(en_gpio, on ? GPS_EN_ACTIVE : !GPS_EN_ACTIVE);
+    // Abort: if pin unset
+    if (!en_gpio)
         return;
-    }
-#ifdef HAS_PMU // We only have PMUs on the T-Beam, and that board has a tiny battery to save GPS ephemera, so treat as a standby.
-    if (pmu_found && PMU) {
-        uint8_t model = PMU->getChipModel();
-        if (model == XPOWERS_AXP2101) {
-            if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
-                // t-beam v1.2 GNSS power channel
-                on ? PMU->enablePowerOutput(XPOWERS_ALDO3) : PMU->disablePowerOutput(XPOWERS_ALDO3);
-            } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
-                // t-beam-s3-core GNSS  power channel
-                on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
-            }
-        } else if (model == XPOWERS_AXP192) {
-            // t-beam v1.1 GNSS  power channel
-            on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3);
-        }
-        return;
-    }
+
+    // Determine new value for the pin
+    bool val = GPS_EN_ACTIVE ? on : !on;
+
+    // Write and log
+    pinMode(en_gpio, OUTPUT);
+    digitalWrite(en_gpio, val);
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("Pin EN %s\n", val == HIGH ? "HIGH" : "LOW");
 #endif
+}
+
+// Set the value of the STANDBY pin, if relevant
+// true for standby state, false for awake
+void GPS::writePinStandby(bool standby)
+{
 #ifdef PIN_GPS_STANDBY // Specifically the standby pin for L76B, L76K and clones
-    if (on) {
-        LOG_INFO("Waking GPS\n");
-        pinMode(PIN_GPS_STANDBY, OUTPUT);
-        // Some PCB's use an inverse logic due to a transistor driver
-        // Example for this is the Pico-Waveshare Lora+GPS HAT
+
+// Determine the new value for the pin
+// Normally: active HIGH for awake
 #ifdef PIN_GPS_STANDBY_INVERTED
-        digitalWrite(PIN_GPS_STANDBY, 0);
+    bool val = standby;
 #else
-        digitalWrite(PIN_GPS_STANDBY, 1);
+    bool val = !standby;
 #endif
-        return;
-    } else {
-        LOG_INFO("GPS entering sleep\n");
-        // notifyGPSSleep.notifyObservers(NULL);
-        pinMode(PIN_GPS_STANDBY, OUTPUT);
-#ifdef PIN_GPS_STANDBY_INVERTED
-        digitalWrite(PIN_GPS_STANDBY, 1);
-#else
-        digitalWrite(PIN_GPS_STANDBY, 0);
+
+    // Write and log
+    pinMode(PIN_GPS_STANDBY, OUTPUT);
+    digitalWrite(PIN_GPS_STANDBY, val);
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("Pin STANDBY %s\n", val == HIGH ? "HIGH" : "LOW");
 #endif
+#endif
+}
+
+// Enable / Disable GPS with PMU, if present
+void GPS::setPowerPMU(bool on)
+{
+    // We only have PMUs on the T-Beam, and that board has a tiny battery to save GPS ephemera,
+    // so treat as a standby.
+#ifdef HAS_PMU
+    // Abort: if no PMU
+    if (!pmu_found)
         return;
+
+    // Abort: if PMU not initialized
+    if (!PMU)
+        return;
+
+    uint8_t model = PMU->getChipModel();
+    if (model == XPOWERS_AXP2101) {
+        if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
+            // t-beam v1.2 GNSS power channel
+            on ? PMU->enablePowerOutput(XPOWERS_ALDO3) : PMU->disablePowerOutput(XPOWERS_ALDO3);
+        } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
+            // t-beam-s3-core GNSS  power channel
+            on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
+        }
+    } else if (model == XPOWERS_AXP192) {
+        // t-beam v1.1 GNSS  power channel
+        on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3);
     }
+
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("PMU %s\n", on ? "on" : "off");
 #endif
-    if (!on) {
-        if (gnssModel == GNSS_MODEL_UBLOX) {
-            uint8_t msglen;
-            LOG_DEBUG("Sleep Time: %i\n", sleepTime);
-            if (strncmp(info.hwVersion, "000A0000", 8) != 0) {
-                for (int i = 0; i < 4; i++) {
-                    gps->_message_PMREQ[0 + i] = sleepTime >> (i * 8); // Encode the sleep time in millis into the packet
-                }
-                msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ), gps->_message_PMREQ);
-            } else {
-                for (int i = 0; i < 4; i++) {
-                    gps->_message_PMREQ_10[4 + i] = sleepTime >> (i * 8); // Encode the sleep time in millis into the packet
-                }
-                msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ_10), gps->_message_PMREQ_10);
-            }
-            gps->_serial_gps->write(gps->UBXscratch, msglen);
+#endif
+}
+
+// Set UBLOX power, if relevant
+void GPS::setPowerUBLOX(bool on, uint32_t sleepMs)
+{
+    // Abort: if not UBLOX hardware
+    if (gnssModel != GNSS_MODEL_UBLOX)
+        return;
+
+    // If waking
+    if (on) {
+        gps->_serial_gps->write(0xFF);
+        clearBuffer(); // This often returns old data, so drop it
+#ifdef GPS_EXTRAVERBOSE
+        LOG_DEBUG("UBLOX: wake\n");
+#endif
+    }
+
+    // If putting to sleep
+    else {
+        uint8_t msglen;
+
+        // If we're being asked to sleep indefinitely, make *sure* we're awake first, to process the new sleep command
+        if (sleepMs == 0) {
+            setPowerUBLOX(true);
+            delay(500);
         }
-    } else {
-        if (gnssModel == GNSS_MODEL_UBLOX) {
-            gps->_serial_gps->write(0xFF);
-            clearBuffer(); // This often returns old data, so drop it
+
+        // Determine hardware version
+        if (strncmp(info.hwVersion, "000A0000", 8) != 0) {
+            // Encode the sleep time in millis into the packet
+            for (int i = 0; i < 4; i++)
+                gps->_message_PMREQ[0 + i] = sleepMs >> (i * 8);
+
+            // Record the message length
+            msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ), gps->_message_PMREQ);
+        } else {
+            // Encode the sleep time in millis into the packet
+            for (int i = 0; i < 4; i++)
+                gps->_message_PMREQ_10[4 + i] = sleepMs >> (i * 8);
+
+            // Record the message length
+            msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ_10), gps->_message_PMREQ_10);
         }
+
+        // Send the UBX packet
+        gps->_serial_gps->write(gps->UBXscratch, msglen);
+
+#ifdef GPS_EXTRAVERBOSE
+        LOG_DEBUG("UBLOX: sleep for %dmS\n", sleepMs);
+#endif
     }
 }
 
@@ -906,108 +977,54 @@ void GPS::setConnected()
     }
 }
 
-/**
- * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
- *
- * calls sleep/wake
- */
-void GPS::setAwake(bool wantAwake)
+// We want a GPS lock. Wake the hardware
+void GPS::up()
 {
+    scheduling.informSearching();
+    setPowerState(GPS_ACTIVE);
+}
 
-    // If user has disabled GPS, make sure it is off, not just in standby or idle
-    if (!wantAwake && !enabled && powerState != GPS_OFF) {
-        setGPSPower(false, false, 0);
-        return;
-    }
+// We've got a GPS lock. Enter a low power state, potentially.
+void GPS::down()
+{
+    scheduling.informGotLock();
+    uint32_t predictedSearchDuration = scheduling.predictedSearchDurationMs();
+    uint32_t sleepTime = scheduling.msUntilNextSearch();
+    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
 
-    // If GPS power state needs to change
-    if ((wantAwake && powerState != GPS_ACTIVE) || (!wantAwake && powerState == GPS_ACTIVE)) {
-        LOG_DEBUG("WANT GPS=%d\n", wantAwake);
+    LOG_DEBUG("%us until next search\n", sleepTime / 1000);
 
-        // Calculate how long it takes to get a GPS lock
-        if (wantAwake) {
-            // Record the time we start looking for a lock
-            lastWakeStartMsec = millis();
-        } else {
-            // Record by how much we missed our ideal target postion.gps_update_interval (for logging only)
-            // Need to calculate this before we update lastSleepStartMsec, to make the new prediction
-            int32_t lateByMsec = (int32_t)(millis() - lastSleepStartMsec) - (int32_t)getSleepTime();
+    // If update interval less than 10 seconds, no attempt to sleep
+    if (updateInterval <= 10 * 1000UL)
+        setPowerState(GPS_IDLE);
 
-            // Record the time we finish looking for a lock
-            lastSleepStartMsec = millis();
-
-            // How long did it take to get GPS lock this time?
-            uint32_t lockTime = lastSleepStartMsec - lastWakeStartMsec;
-
-            // Update the lock-time prediction
-            // Used pre-emptively, attempting to hit target of gps.position_update_interval
-            switch (GPSCycles) {
-            case 0:
-                LOG_DEBUG("Initial GPS lock took %ds\n", lockTime / 1000);
-                break;
-            case 1:
-                predictedLockTime = lockTime; // Avoid slow ramp-up - start with a real value
-                LOG_DEBUG("GPS Lock took %ds\n", lockTime / 1000);
-                break;
-            default:
-                // Predict lock-time using exponential smoothing: respond slowly to changes
-                predictedLockTime = (lockTime * 0.2) + (predictedLockTime * 0.8); // Latest lock time has 20% weight on prediction
-                LOG_INFO("GPS Lock took %ds. %s by %ds. Next lock predicted to take %ds.\n", lockTime / 1000,
-                         (lateByMsec > 0) ? "Late" : "Early", abs(lateByMsec) / 1000, predictedLockTime / 1000);
-            }
-            GPSCycles++;
-        }
-
-        // How long to wait before attempting next GPS update
-        // Aims to hit position.gps_update_interval by using the lock-time prediction
-        uint32_t compensatedSleepTime = (getSleepTime() > predictedLockTime) ? (getSleepTime() - predictedLockTime) : 0;
-
-        // If long interval between updates: power off between updates
-        if (compensatedSleepTime > GPS_STANDBY_THRESHOLD_MINUTES * MS_IN_MINUTE) {
-            setGPSPower(wantAwake, false, getSleepTime() - predictedLockTime);
-        }
-
-        // If waking relatively frequently: don't power off. Would use more energy trying to reacquire lock each time
-        // We'll either use a "powered-on" standby, or just wait it out, depending on how soon the next update is due
-        // Will decide which inside setGPSPower method
-        else {
-#ifdef GPS_UC6580
-            setGPSPower(wantAwake, false, compensatedSleepTime);
-#else
-            setGPSPower(wantAwake, true, compensatedSleepTime);
+    else {
+        // Check whether the GPS hardware is capable of GPS_SOFTSLEEP
+        // If not, fallback to GPS_HARDSLEEP instead
+        bool softsleepSupported = false;
+        if (gnssModel == GNSS_MODEL_UBLOX) // U-blox is supported via PMREQ
+            softsleepSupported = true;
+#ifdef PIN_GPS_STANDBY // L76B, L76K and clones have a standby pin
+        softsleepSupported = true;
 #endif
-        }
+
+        // How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than GPS_SOFTSLEEP?
+        // Heuristic equation. A compromise manually fitted to power observations from U-blox NEO-6M and M10050
+        // https://www.desmos.com/calculator/6gvjghoumr
+        // This is not particularly accurate, but probably an impromevement over a single, fixed threshold
+        uint32_t hardsleepThreshold = (2750 * pow(predictedSearchDuration / 1000, 1.22));
+        LOG_DEBUG("gps_update_interval >= %us needed to justify hardsleep\n", hardsleepThreshold / 1000);
+
+        // If update interval too short: softsleep (if supported by hardware)
+        if (softsleepSupported && updateInterval < hardsleepThreshold)
+            setPowerState(GPS_SOFTSLEEP, sleepTime);
+
+        // If update interval long enough (or softsleep unsupported): hardsleep instead
+        else
+            setPowerState(GPS_HARDSLEEP, sleepTime);
     }
 }
 
-/** Get how long we should stay looking for each acquisition in msecs
- */
-uint32_t GPS::getWakeTime() const
-{
-    uint32_t t = config.position.position_broadcast_secs;
-
-    if (t == UINT32_MAX)
-        return t; // already maxint
-
-    return Default::getConfiguredOrDefaultMs(t, default_broadcast_interval_secs);
-}
-
-/** Get how long we should sleep between aqusition attempts in msecs
- */
-uint32_t GPS::getSleepTime() const
-{
-    uint32_t t = config.position.gps_update_interval;
-
-    // We'll not need the GPS thread to wake up again after first acq. with fixed position.
-    if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED || config.position.fixed_position)
-        t = UINT32_MAX; // Sleep forever now
-
-    if (t == UINT32_MAX)
-        return t; // already maxint
-
-    return Default::getConfiguredOrDefaultMs(t, default_gps_update_interval);
-}
-
 void GPS::publishUpdate()
 {
     if (shouldPublish) {
@@ -1056,13 +1073,13 @@ int32_t GPS::runOnce()
         return disable();
     }
 
-    if (whileIdle()) {
+    if (whileActive()) {
         // if we have received valid NMEA claim we are connected
         setConnected();
     } else {
         if ((config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) && (gnssModel == GNSS_MODEL_UBLOX)) {
             // reset the GPS on next bootup
-            if (devicestate.did_gps_reset && (millis() - lastWakeStartMsec > 60000) && !hasFlow()) {
+            if (devicestate.did_gps_reset && scheduling.elapsedSearchMs() > 60 * 1000UL && !hasFlow()) {
                 LOG_DEBUG("GPS is not communicating, trying factory reset on next bootup.\n");
                 devicestate.did_gps_reset = false;
                 nodeDB->saveDeviceStateToDisk();
@@ -1077,54 +1094,43 @@ int32_t GPS::runOnce()
         // gps->factoryReset();
     }
 
-    // If we are overdue for an update, turn on the GPS and at least publish the current status
-    uint32_t now = millis();
-    uint32_t timeAsleep = now - lastSleepStartMsec;
+    // If we're due for an update, wake the GPS
+    if (!config.position.fixed_position && powerState != GPS_ACTIVE && scheduling.isUpdateDue())
+        up();
 
-    auto sleepTime = getSleepTime();
-    if (powerState != GPS_ACTIVE && (sleepTime != UINT32_MAX) &&
-        ((timeAsleep > sleepTime) || (isInPowersave && timeAsleep > (sleepTime - predictedLockTime)))) {
-        // We now want to be awake - so wake up the GPS
-        setAwake(true);
+    // If we've already set time from the GPS, no need to ask the GPS
+    bool gotTime = (getRTCQuality() >= RTCQualityGPS);
+    if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
+        gotTime = true;
+        shouldPublish = true;
     }
 
-    // While we are awake
-    if (powerState == GPS_ACTIVE) {
-        // LOG_DEBUG("looking for location\n");
-        // If we've already set time from the GPS, no need to ask the GPS
-        bool gotTime = (getRTCQuality() >= RTCQualityGPS);
-        if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
-            gotTime = true;
-            shouldPublish = true;
-        }
+    bool gotLoc = lookForLocation();
+    if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
+        LOG_DEBUG("hasValidLocation RISING EDGE\n");
+        hasValidLocation = true;
+        shouldPublish = true;
+    }
 
-        bool gotLoc = lookForLocation();
-        if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
-            LOG_DEBUG("hasValidLocation RISING EDGE\n");
-            hasValidLocation = true;
-            shouldPublish = true;
-        }
+    bool tooLong = scheduling.searchedTooLong();
+    if (tooLong)
+        LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time.\n");
 
-        now = millis();
-        auto wakeTime = getWakeTime();
-        bool tooLong = wakeTime != UINT32_MAX && (now - lastWakeStartMsec) > wakeTime;
+    // Once we get a location we no longer desperately want an update
+    // LOG_DEBUG("gotLoc %d, tooLong %d, gotTime %d\n", gotLoc, tooLong, gotTime);
+    if ((gotLoc && gotTime) || tooLong) {
 
-        // Once we get a location we no longer desperately want an update
-        // LOG_DEBUG("gotLoc %d, tooLong %d, gotTime %d\n", gotLoc, tooLong, gotTime);
-        if ((gotLoc && gotTime) || tooLong) {
-
-            if (tooLong) {
-                // we didn't get a location during this ack window, therefore declare loss of lock
-                if (hasValidLocation) {
-                    LOG_DEBUG("hasValidLocation FALLING EDGE (last read: %d)\n", gotLoc);
-                }
-                p = meshtastic_Position_init_default;
-                hasValidLocation = false;
+        if (tooLong) {
+            // we didn't get a location during this ack window, therefore declare loss of lock
+            if (hasValidLocation) {
+                LOG_DEBUG("hasValidLocation FALLING EDGE\n");
             }
-
-            setAwake(false);
-            shouldPublish = true; // publish our update for this just finished acquisition window
+            p = meshtastic_Position_init_default;
+            hasValidLocation = false;
         }
+
+        down();
+        shouldPublish = true; // publish our update for this just finished acquisition window
     }
 
     // If state has changed do a publish
@@ -1150,9 +1156,7 @@ void GPS::clearBuffer()
 int GPS::prepareDeepSleep(void *unused)
 {
     LOG_INFO("GPS deep sleep!\n");
-
-    setAwake(false);
-
+    disable();
     return 0;
 }
 
@@ -1167,6 +1171,9 @@ GnssModel_t GPS::probe(int serialSpeed)
         _serial_gps->updateBaudRate(serialSpeed);
     }
 #endif
+#ifdef GNSS_Airoha // add by WayenWeng
+    return GNSS_MODEL_UNKNOWN;
+#else
 #ifdef GPS_DEBUG
     for (int i = 0; i < 20; i++) {
         getACK("$GP", 200);
@@ -1180,6 +1187,15 @@ GnssModel_t GPS::probe(int serialSpeed)
     _serial_gps->write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
     delay(20);
 
+    // get version information from Unicore UFirebirdII Series
+    // Works for: UC6580, UM620, UM621, UM670A, UM680A, or UM681A
+    _serial_gps->write("$PDTINFO\r\n");
+    delay(750);
+    if (getACK("UC6580", 500) == GNSS_RESPONSE_OK) {
+        LOG_INFO("UC6580 detected, using UC6580 Module\n");
+        return GNSS_MODEL_UC6580;
+    }
+
     // Get version information
     clearBuffer();
     _serial_gps->write("$PCAS06,1*1A\r\n");
@@ -1313,6 +1329,7 @@ GnssModel_t GPS::probe(int serialSpeed)
     }
 
     return GNSS_MODEL_UBLOX;
+#endif // !GNSS_Airoha
 }
 
 GPS *GPS::createGps()
@@ -1348,12 +1365,6 @@ GPS *GPS::createGps()
     new_gps->tx_gpio = _tx_gpio;
     new_gps->en_gpio = _en_gpio;
 
-    if (_en_gpio != 0) {
-        LOG_DEBUG("Setting %d to output.\n", _en_gpio);
-        pinMode(_en_gpio, OUTPUT);
-        digitalWrite(_en_gpio, !GPS_EN_ACTIVE);
-    }
-
 #ifdef PIN_GPS_PPS
     // pulse per second
     pinMode(PIN_GPS_PPS, INPUT);
@@ -1368,7 +1379,8 @@ GPS *GPS::createGps()
     LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
 #endif
 
-    new_gps->setGPSPower(true, false, 0);
+    // Make sure the GPS is awake before performing any init.
+    new_gps->up();
 
 #ifdef PIN_GPS_RESET
     pinMode(PIN_GPS_RESET, OUTPUT);
@@ -1376,7 +1388,6 @@ GPS *GPS::createGps()
     delay(10);
     digitalWrite(PIN_GPS_RESET, !GPS_RESET_MODE);
 #endif
-    new_gps->setAwake(true); // Wake GPS power before doing any init
 
     if (_serial_gps) {
 #ifdef ARCH_ESP32
@@ -1392,13 +1403,6 @@ GPS *GPS::createGps()
 #else
         _serial_gps->begin(GPS_BAUDRATE);
 #endif
-
-        /*
-         * T-Beam-S3-Core will be preset to use gps Probe here, and other boards will not be changed first
-         */
-#if defined(GPS_UC6580)
-        _serial_gps->updateBaudRate(115200);
-#endif
     }
     return new_gps;
 }
@@ -1480,6 +1484,11 @@ bool GPS::factoryReset()
  */
 bool GPS::lookForTime()
 {
+#ifdef GNSS_Airoha // add by WayenWeng
+    uint8_t fix = reader.fixQuality();
+    uint32_t now = millis();
+#endif
+
     auto ti = reader.time;
     auto d = reader.date;
     if (ti.isValid() && d.isValid()) { // Note: we don't check for updated, because we'll only be called if needed
@@ -1514,6 +1523,13 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
  */
 bool GPS::lookForLocation()
 {
+#ifdef GNSS_Airoha // add by WayenWeng
+    if ((config.position.gps_update_interval * 1000) >= (GPS_FIX_HOLD_TIME * 2)) {
+        uint8_t fix = reader.fixQuality();
+        uint32_t now = millis();
+    }
+#endif
+
     // By default, TinyGPS++ does not parse GPGSA lines, which give us
     //   the 2D/3D fixType (see NMEAGPS.h)
     // At a minimum, use the fixQuality indicator in GPGGA (FIXME?)
@@ -1662,13 +1678,13 @@ bool GPS::hasFlow()
     return reader.passedChecksum() > 0;
 }
 
-bool GPS::whileIdle()
+bool GPS::whileActive()
 {
     unsigned int charsInBuf = 0;
     bool isValid = false;
     if (powerState != GPS_ACTIVE) {
         clearBuffer();
-        return (powerState == GPS_ACTIVE);
+        return false;
     }
 #ifdef SERIAL_BUFFER_SIZE
     if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) {
@@ -1699,20 +1715,21 @@ bool GPS::whileIdle()
 }
 void GPS::enable()
 {
-    // Clear the old lock-time prediction
-    GPSCycles = 0;
-    predictedLockTime = 0;
+    // Clear the old scheduling info (reset the lock-time prediction)
+    scheduling.reset();
 
     enabled = true;
     setInterval(GPS_THREAD_INTERVAL);
-    setAwake(true);
+
+    scheduling.informSearching();
+    setPowerState(GPS_ACTIVE);
 }
 
 int32_t GPS::disable()
 {
     enabled = false;
     setInterval(INT32_MAX);
-    setAwake(false);
+    setPowerState(GPS_OFF);
 
     return INT32_MAX;
 }
@@ -1721,11 +1738,11 @@ void GPS::toggleGpsMode()
 {
     if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_DISABLED;
-        LOG_DEBUG("Flag set to false for gps power. GpsMode: DISABLED\n");
+        LOG_INFO("User toggled GpsMode. Now DISABLED.\n");
         disable();
     } else if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_DISABLED) {
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_ENABLED;
-        LOG_DEBUG("Flag set to true to restore power. GpsMode: ENABLED\n");
+        LOG_INFO("User toggled GpsMode. Now ENABLED\n");
         enable();
     }
 }

src/gps/GPS.h

@@ -39,10 +39,11 @@ typedef enum {
 } GPS_RESPONSE;
 
 enum GPSPowerState : uint8_t {
-    GPS_OFF = 0,     // Physically powered off
-    GPS_ACTIVE = 1,  // Awake and want a position
-    GPS_STANDBY = 2, // Physically powered on, but soft-sleeping
-    GPS_IDLE = 3,    // Awake, but not wanting another position yet
+    GPS_ACTIVE,    // Awake and want a position
+    GPS_IDLE,      // Awake, but not wanting another position yet
+    GPS_SOFTSLEEP, // Physically powered on, but soft-sleeping
+    GPS_HARDSLEEP, // Physically powered off, but scheduled to wake
+    GPS_OFF        // Powered off indefinitely
 };
 
 // Generate a string representation of DOP
@@ -67,14 +68,11 @@ class GPS : private concurrency::OSThread
     uint8_t fixType = 0;      // fix type from GPGSA
 #endif
   private:
-    uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0;
     const int serialSpeeds[6] = {9600, 4800, 38400, 57600, 115200, 9600};
 
     uint32_t rx_gpio = 0;
     uint32_t tx_gpio = 0;
     uint32_t en_gpio = 0;
-    uint32_t predictedLockTime = 0;
-    uint32_t GPSCycles = 0;
 
     int speedSelect = 0;
     int probeTries = 2;
@@ -99,7 +97,6 @@ class GPS : private concurrency::OSThread
     uint8_t numSatellites = 0;
 
     CallbackObserver<GPS, void *> notifyDeepSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
-    CallbackObserver<GPS, void *> notifyGPSSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
 
   public:
     /** If !NULL we will use this serial port to construct our GPS */
@@ -175,7 +172,8 @@ class GPS : private concurrency::OSThread
     // toggle between enabled/disabled
     void toggleGpsMode();
 
-    void setGPSPower(bool on, bool standbyOnly, uint32_t sleepTime);
+    // Change the power state of the GPS - for power saving / shutdown
+    void setPowerState(GPSPowerState newState, uint32_t sleepMs = 0);
 
     /// Returns true if we have acquired GPS lock.
     virtual bool hasLock();
@@ -206,18 +204,18 @@ class GPS : private concurrency::OSThread
 
     GPS_RESPONSE getACKCas(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis);
 
-    /**
-     * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
-     *
-     * calls sleep/wake
-     */
-    void setAwake(bool on);
     virtual bool factoryReset();
 
     // Creates an instance of the GPS class.
     // Returns the new instance or null if the GPS is not present.
     static GPS *createGps();
 
+    // Wake the GPS hardware - ready for an update
+    void up();
+
+    // Let the GPS hardware save power between updates
+    void down();
+
   protected:
     /**
      * Perform any processing that should be done only while the GPS is awake and looking for a fix.
@@ -240,7 +238,7 @@ class GPS : private concurrency::OSThread
      *
      * Return true if we received a valid message from the GPS
      */
-    virtual bool whileIdle();
+    virtual bool whileActive();
 
     /**
      * Perform any processing that should be done only while the GPS is awake and looking for a fix.
@@ -267,13 +265,21 @@ class GPS : private concurrency::OSThread
     void UBXChecksum(uint8_t *message, size_t length);
     void CASChecksum(uint8_t *message, size_t length);
 
-    /** Get how long we should stay looking for each aquisition
+    /** Set power with EN pin, if relevant
      */
-    uint32_t getWakeTime() const;
+    void writePinEN(bool on);
 
-    /** Get how long we should sleep between aqusition attempts
+    /** Set the value of the STANDBY pin, if relevant
      */
-    uint32_t getSleepTime() const;
+    void writePinStandby(bool standby);
+
+    /** Set GPS power with PMU, if relevant
+     */
+    void setPowerPMU(bool on);
+
+    /** Set UBLOX power, if relevant
+     */
+    void setPowerUBLOX(bool on, uint32_t sleepMs = 0);
 
     /**
      * Tell users we have new GPS readings

src/gps/GPSUpdateScheduling.cpp

@@ -0,0 +1,118 @@
+#include "GPSUpdateScheduling.h"
+
+#include "Default.h"
+
+// Mark the time when searching for GPS position begins
+void GPSUpdateScheduling::informSearching()
+{
+    searchStartedMs = millis();
+}
+
+// Mark the time when searching for GPS is complete,
+// then update the predicted lock-time
+void GPSUpdateScheduling::informGotLock()
+{
+    searchEndedMs = millis();
+    LOG_DEBUG("Took %us to get lock\n", (searchEndedMs - searchStartedMs) / 1000);
+    updateLockTimePrediction();
+}
+
+// Clear old lock-time prediction data.
+// When re-enabling GPS with user button.
+void GPSUpdateScheduling::reset()
+{
+    searchStartedMs = 0;
+    searchEndedMs = 0;
+    searchCount = 0;
+    predictedMsToGetLock = 0;
+}
+
+// How many milliseconds before we should next search for GPS position
+// Used by GPS hardware directly, to enter timed hardware sleep
+uint32_t GPSUpdateScheduling::msUntilNextSearch()
+{
+    uint32_t now = millis();
+
+    // Target interval (seconds), between GPS updates
+    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval, default_gps_update_interval);
+
+    // Check how long until we should start searching, to hopefully hit our target interval
+    uint32_t dueAtMs = searchEndedMs + updateInterval;
+    uint32_t compensatedStart = dueAtMs - predictedMsToGetLock;
+    int32_t remainingMs = compensatedStart - now;
+
+    // If we should have already started (negative value), start ASAP
+    if (remainingMs < 0)
+        remainingMs = 0;
+
+    return (uint32_t)remainingMs;
+}
+
+// How long have we already been searching?
+// Used to abort a search in progress, if it runs unnaceptably long
+uint32_t GPSUpdateScheduling::elapsedSearchMs()
+{
+    // If searching
+    if (searchStartedMs > searchEndedMs)
+        return millis() - searchStartedMs;
+
+    // If not searching - 0ms. We shouldn't really consume this value
+    else
+        return 0;
+}
+
+// Is it now time to begin searching for a GPS position?
+bool GPSUpdateScheduling::isUpdateDue()
+{
+    return (msUntilNextSearch() == 0);
+}
+
+// Have we been searching for a GPS position for too long?
+bool GPSUpdateScheduling::searchedTooLong()
+{
+    uint32_t maxSearchMs =
+        Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
+
+    // If broadcast interval set to max, no such thing as "too long"
+    if (maxSearchMs == UINT32_MAX)
+        return false;
+
+    // If we've been searching longer than our position broadcast interval: that's too long
+    else if (elapsedSearchMs() > maxSearchMs)
+        return true;
+
+    // Otherwise, not too long yet!
+    else
+        return false;
+}
+
+// Updates the predicted time-to-get-lock, by exponentially smoothing the latest observation
+void GPSUpdateScheduling::updateLockTimePrediction()
+{
+
+    // How long did it take to get GPS lock this time?
+    // Duration between down() calls
+    int32_t lockTime = searchEndedMs - searchStartedMs;
+    if (lockTime < 0)
+        lockTime = 0;
+
+    // Ignore the first lock-time: likely to be long, will skew data
+
+    // Second locktime: likely stable. Use to intialize the smoothing filter
+    if (searchCount == 1)
+        predictedMsToGetLock = lockTime;
+
+    // Third locktime and after: predict using exponential smoothing. Respond slowly to changes
+    else if (searchCount > 1)
+        predictedMsToGetLock = (lockTime * weighting) + (predictedMsToGetLock * (1 - weighting));
+
+    searchCount++; // Only tracked so we can diregard initial lock-times
+
+    LOG_DEBUG("Predicting %us to get next lock\n", predictedMsToGetLock / 1000);
+}
+
+// How long do we expect to spend searching for a lock?
+uint32_t GPSUpdateScheduling::predictedSearchDurationMs()
+{
+    return GPSUpdateScheduling::predictedMsToGetLock;
+}

src/gps/GPSUpdateScheduling.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "configuration.h"
+
+// Encapsulates code responsible for the timing of GPS updates
+class GPSUpdateScheduling
+{
+  public:
+    // Marks the time of these events, for calculation use
+    void informSearching();
+    void informGotLock(); // Predicted lock-time is recalculated here
+
+    void reset();           // Reset the prediction - after GPS::disable() / GPS::enable()
+    bool isUpdateDue();     // Is it time to begin searching for a GPS position?
+    bool searchedTooLong(); // Have we been searching for too long?
+
+    uint32_t msUntilNextSearch(); // How long until we need to begin searching for a GPS? Info provided to GPS hardware for sleep
+    uint32_t elapsedSearchMs();   // How long have we been searching so far?
+    uint32_t predictedSearchDurationMs(); // How long do we expect to spend searching for a lock?
+
+  private:
+    void updateLockTimePrediction(); // Called from informGotLock
+    uint32_t searchStartedMs = 0;
+    uint32_t searchEndedMs = 0;
+    uint32_t searchCount = 0;
+    uint32_t predictedMsToGetLock = 0;
+
+    const float weighting = 0.2; // Controls exponential smoothing of lock-times prediction. 20% weighting of "latest lock-time".
+};

src/graphics/EInkDisplay2.cpp

@@ -156,7 +156,8 @@ bool EInkDisplay::connect()
         }
     }
 
-#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER)
+#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_VISION_MASTER_E213) ||             \
+    defined(HELTEC_VISION_MASTER_E290)
     {
         // Start HSPI
         hspi = new SPIClass(HSPI);

src/graphics/EInkDisplay2.h

@@ -5,11 +5,6 @@
 #include "GxEPD2_BW.h"
 #include <OLEDDisplay.h>
 
-#if defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER)
-// Re-enable SPI after deep sleep: rtc_gpio_hold_dis()
-#include "driver/rtc_io.h"
-#endif
-
 /**
  * An adapter class that allows using the GxEPD2 library as if it was an OLEDDisplay implementation.
  *
@@ -72,7 +67,8 @@ class EInkDisplay : public OLEDDisplay
     GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT> *adafruitDisplay = NULL;
 
     // If display uses HSPI
-#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0)
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E213) ||               \
+    defined(HELTEC_VISION_MASTER_E290)
     SPIClass *hspi = NULL;
 #endif
 

src/graphics/Screen.cpp

@@ -41,6 +41,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh/Channels.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "meshUtils.h"
+#include "modules/AdminModule.h"
 #include "modules/ExternalNotificationModule.h"
 #include "modules/TextMessageModule.h"
 #include "sleep.h"
@@ -1485,6 +1486,10 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
     screen->drawColumns(display, x, y, fields);
 }
 
+#if defined(ESP_PLATFORM) && defined(USE_ST7789)
+SPIClass SPI1(HSPI);
+#endif
+
 Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_OledType screenType, OLEDDISPLAY_GEOMETRY geometry)
     : concurrency::OSThread("Screen"), address_found(address), model(screenType), geometry(geometry), cmdQueue(32)
 {
@@ -1492,6 +1497,13 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 #if defined(USE_SH1106) || defined(USE_SH1107) || defined(USE_SH1107_128_64)
     dispdev = new SH1106Wire(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
+#elif defined(USE_ST7789)
+#ifdef ESP_PLATFORM
+    dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT, ST7789_SDA,
+                            ST7789_MISO, ST7789_SCK);
+#else
+    dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
+#endif
 #elif defined(USE_SSD1306)
     dispdev = new SSD1306Wire(address.address, -1, -1, geometry,
                               (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -1570,7 +1582,14 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 
             dispdev->displayOn();
-
+#ifdef USE_ST7789
+#ifdef ESP_PLATFORM
+            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
+#else
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
+#endif
+#endif
             enabled = true;
             setInterval(0); // Draw ASAP
             runASAP = true;
@@ -1581,6 +1600,12 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
             LOG_INFO("Turning off screen\n");
             dispdev->displayOff();
+
+#ifdef USE_ST7789
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, !TFT_BACKLIGHT_ON);
+#endif
+
 #ifdef T_WATCH_S3
             PMU->disablePowerOutput(XPOWERS_ALDO2);
 #endif
@@ -1701,6 +1726,7 @@ void Screen::setup()
     powerStatusObserver.observe(&powerStatus->onNewStatus);
     gpsStatusObserver.observe(&gpsStatus->onNewStatus);
     nodeStatusObserver.observe(&nodeStatus->onNewStatus);
+    adminMessageObserver.observe(adminModule);
     if (textMessageModule)
         textMessageObserver.observe(textMessageModule);
     if (inputBroker)
@@ -1929,9 +1955,6 @@ void Screen::setWelcomeFrames()
 /// Determine which screensaver frame to use, then set the FrameCallback
 void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 {
-    // Remember current frame, restore position at power-on
-    uint8_t frameNumber = ui->getUiState()->currentFrame;
-
     // Retain specified frame / overlay callback beyond scope of this method
     static FrameCallback screensaverFrame;
     static OverlayCallback screensaverOverlay;
@@ -1969,9 +1992,8 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 #endif
 
     // Prepare now for next frame, shown when display wakes
-    ui->setOverlays(NULL, 0);       // Clear overlay
-    setFrames();                    // Return to normal display updates
-    ui->switchToFrame(frameNumber); // Attempt to return to same frame after power-on
+    ui->setOverlays(NULL, 0);  // Clear overlay
+    setFrames(FOCUS_PRESERVE); // Return to normal display updates, showing same frame as before screensaver, ideally
 
     // Pick a refresh method, for when display wakes
 #ifdef EINK_HASQUIRK_GHOSTING
@@ -1982,9 +2004,13 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 }
 #endif
 
-// restore our regular frame list
-void Screen::setFrames()
+// Regenerate the normal set of frames, focusing a specific frame if requested
+// Called when a frame should be added / removed, or custom frames should be cleared
+void Screen::setFrames(FrameFocus focus)
 {
+    uint8_t originalPosition = ui->getUiState()->currentFrame;
+    FramesetInfo fsi; // Location of specific frames, for applying focus parameter
+
     LOG_DEBUG("showing standard frames\n");
     showingNormalScreen = true;
 
@@ -2018,20 +2044,33 @@ void Screen::setFrames()
     // is the same offset into the moduleFrames vector
     // so that we can invoke the module's callback
     for (auto i = moduleFrames.begin(); i != moduleFrames.end(); ++i) {
-        normalFrames[numframes++] = drawModuleFrame;
+        // Draw the module frame, using the hack described above
+        normalFrames[numframes] = drawModuleFrame;
+
+        // Check if the module being drawn has requested focus
+        // We will honor this request later, if setFrames was triggered by a UIFrameEvent
+        MeshModule *m = *i;
+        if (m->isRequestingFocus())
+            fsi.positions.focusedModule = numframes;
+
+        numframes++;
     }
 
     LOG_DEBUG("Added modules.  numframes: %d\n", numframes);
 
     // If we have a critical fault, show it first
-    if (error_code)
+    fsi.positions.fault = numframes;
+    if (error_code) {
         normalFrames[numframes++] = drawCriticalFaultFrame;
+        focus = FOCUS_FAULT; // Change our "focus" parameter, to ensure we show the fault frame
+    }
 
 #ifdef T_WATCH_S3
     normalFrames[numframes++] = screen->digitalWatchFace ? &Screen::drawDigitalClockFrame : &Screen::drawAnalogClockFrame;
 #endif
 
     // If we have a text message - show it next, unless it's a phone message and we aren't using any special modules
+    fsi.positions.textMessage = numframes;
     if (devicestate.has_rx_text_message && shouldDrawMessage(&devicestate.rx_text_message)) {
         normalFrames[numframes++] = drawTextMessageFrame;
     }
@@ -2046,11 +2085,14 @@ void Screen::setFrames()
     //
     // Since frames are basic function pointers, we have to use a helper to
     // call a method on debugInfo object.
+    fsi.positions.log = numframes;
     normalFrames[numframes++] = &Screen::drawDebugInfoTrampoline;
 
     // call a method on debugInfoScreen object (for more details)
+    fsi.positions.settings = numframes;
     normalFrames[numframes++] = &Screen::drawDebugInfoSettingsTrampoline;
 
+    fsi.positions.wifi = numframes;
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
     if (isWifiAvailable()) {
         // call a method on debugInfoScreen object (for more details)
@@ -2058,6 +2100,7 @@ void Screen::setFrames()
     }
 #endif
 
+    fsi.frameCount = numframes; // Total framecount is used to apply FOCUS_PRESERVE
     LOG_DEBUG("Finished building frames. numframes: %d\n", numframes);
 
     ui->setFrames(normalFrames, numframes);
@@ -2071,6 +2114,55 @@ void Screen::setFrames()
     prevFrame = -1; // Force drawNodeInfo to pick a new node (because our list
                     // just changed)
 
+    // Focus on a specific frame, in the frame set we just created
+    switch (focus) {
+    case FOCUS_DEFAULT:
+        ui->switchToFrame(0); // First frame
+        break;
+    case FOCUS_FAULT:
+        ui->switchToFrame(fsi.positions.fault);
+        break;
+    case FOCUS_TEXTMESSAGE:
+        ui->switchToFrame(fsi.positions.textMessage);
+        break;
+    case FOCUS_MODULE:
+        // Whichever frame was marked by MeshModule::requestFocus(), if any
+        // If no module requested focus, will show the first frame instead
+        ui->switchToFrame(fsi.positions.focusedModule);
+        break;
+
+    case FOCUS_PRESERVE:
+        // If we can identify which type of frame "originalPosition" was, can move directly to it in the new frameset
+        FramesetInfo &oldFsi = this->framesetInfo;
+        if (originalPosition == oldFsi.positions.log)
+            ui->switchToFrame(fsi.positions.log);
+        else if (originalPosition == oldFsi.positions.settings)
+            ui->switchToFrame(fsi.positions.settings);
+        else if (originalPosition == oldFsi.positions.wifi)
+            ui->switchToFrame(fsi.positions.wifi);
+
+        // If frame count has decreased
+        else if (fsi.frameCount < oldFsi.frameCount) {
+            uint8_t numDropped = oldFsi.frameCount - fsi.frameCount;
+            // Move n frames backwards
+            if (numDropped <= originalPosition)
+                ui->switchToFrame(originalPosition - numDropped);
+            // Unless that would put us "out of bounds" (< 0)
+            else
+                ui->switchToFrame(0);
+        }
+
+        // If we're not sure exactly which frame we were on, at least return to the same frame number
+        // (node frames; module frames)
+        else
+            ui->switchToFrame(originalPosition);
+
+        break;
+    }
+
+    // Store the info about this frameset, for future setFrames calls
+    this->framesetInfo = fsi;
+
     setFastFramerate(); // Draw ASAP
 }
 
@@ -2525,7 +2617,7 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
     switch (arg->getStatusType()) {
     case STATUS_TYPE_NODE:
         if (showingNormalScreen && nodeStatus->getLastNumTotal() != nodeStatus->getNumTotal()) {
-            setFrames(); // Regen the list of screens
+            setFrames(FOCUS_PRESERVE); // Regen the list of screen frames (returning to same frame, if possible)
         }
         nodeDB->updateGUI = false;
         break;
@@ -2537,23 +2629,33 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
 int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
 {
     if (showingNormalScreen) {
-        setFrames(); // Regen the list of screens (will show new text message)
+        // Outgoing message
+        if (packet->from == 0)
+            setFrames(FOCUS_PRESERVE); // Return to same frame (quietly hiding the rx text message frame)
+
+        // Incoming message
+        else
+            setFrames(FOCUS_TEXTMESSAGE); // Focus on the new message
     }
 
     return 0;
 }
 
+// Triggered by MeshModules
 int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 {
     if (showingNormalScreen) {
-        if (event->frameChanged) {
-            setFrames(); // Regen the list of screens (will show new text message)
-        } else if (event->needRedraw) {
+        // Regenerate the frameset, potentially honoring a module's internal requestFocus() call
+        if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET)
+            setFrames(FOCUS_MODULE);
+
+        // Regenerate the frameset, while attempting to maintain focus on the current frame
+        else if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND)
+            setFrames(FOCUS_PRESERVE);
+
+        // Don't regenerate the frameset, just re-draw whatever is on screen ASAP
+        else if (event->action == UIFrameEvent::Action::REDRAW_ONLY)
             setFastFramerate();
-            // TODO: We might also want switch to corresponding frame,
-            //       but we don't know the exact frame number.
-            // ui->switchToFrame(0);
-        }
     }
 
     return 0;
@@ -2588,6 +2690,24 @@ int Screen::handleInputEvent(const InputEvent *event)
     return 0;
 }
 
+int Screen::handleAdminMessage(const meshtastic_AdminMessage *arg)
+{
+    // Note: only selected admin messages notify this observer
+    // If you wish to handle a new type of message, you should modify AdminModule.cpp first
+
+    switch (arg->which_payload_variant) {
+    // Node removed manually (i.e. via app)
+    case meshtastic_AdminMessage_remove_by_nodenum_tag:
+        setFrames(FOCUS_PRESERVE);
+        break;
+
+    // Default no-op, in case the admin message observable gets used by other classes in future
+    default:
+        break;
+    }
+    return 0;
+}
+
 } // namespace graphics
 #else
 graphics::Screen::Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY) {}

src/graphics/Screen.h

@@ -45,6 +45,8 @@ class Screen
 #include <SH1106Wire.h>
 #elif defined(USE_SSD1306)
 #include <SSD1306Wire.h>
+#elif defined(USE_ST7789)
+#include <ST7789Spi.h>
 #else
 // the SH1106/SSD1306 variant is auto-detected
 #include <AutoOLEDWire.h>
@@ -171,9 +173,11 @@ class Screen : public concurrency::OSThread
     CallbackObserver<Screen, const meshtastic_MeshPacket *> textMessageObserver =
         CallbackObserver<Screen, const meshtastic_MeshPacket *>(this, &Screen::handleTextMessage);
     CallbackObserver<Screen, const UIFrameEvent *> uiFrameEventObserver =
-        CallbackObserver<Screen, const UIFrameEvent *>(this, &Screen::handleUIFrameEvent);
+        CallbackObserver<Screen, const UIFrameEvent *>(this, &Screen::handleUIFrameEvent); // Sent by Mesh Modules
     CallbackObserver<Screen, const InputEvent *> inputObserver =
         CallbackObserver<Screen, const InputEvent *>(this, &Screen::handleInputEvent);
+    CallbackObserver<Screen, const meshtastic_AdminMessage *> adminMessageObserver =
+        CallbackObserver<Screen, const meshtastic_AdminMessage *>(this, &Screen::handleAdminMessage);
 
   public:
     explicit Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY);
@@ -392,6 +396,7 @@ class Screen : public concurrency::OSThread
     int handleTextMessage(const meshtastic_MeshPacket *arg);
     int handleUIFrameEvent(const UIFrameEvent *arg);
     int handleInputEvent(const InputEvent *arg);
+    int handleAdminMessage(const meshtastic_AdminMessage *arg);
 
     /// Used to force (super slow) eink displays to draw critical frames
     void forceDisplay(bool forceUiUpdate = false);
@@ -448,8 +453,34 @@ class Screen : public concurrency::OSThread
     void handleShowPrevFrame();
     void handlePrint(const char *text);
     void handleStartFirmwareUpdateScreen();
-    /// Rebuilds our list of frames (screens) to default ones.
-    void setFrames();
+
+    // Info collected by setFrames method.
+    // Index location of specific frames. Used to apply the FrameFocus parameter of setFrames
+    struct FramesetInfo {
+        struct FramePositions {
+            uint8_t fault = 0;
+            uint8_t textMessage = 0;
+            uint8_t focusedModule = 0;
+            uint8_t log = 0;
+            uint8_t settings = 0;
+            uint8_t wifi = 0;
+        } positions;
+
+        uint8_t frameCount = 0;
+    } framesetInfo;
+
+    // Which frame we want to be displayed, after we regen the frameset by calling setFrames
+    enum FrameFocus : uint8_t {
+        FOCUS_DEFAULT,  // No specific frame
+        FOCUS_PRESERVE, // Return to the previous frame
+        FOCUS_FAULT,
+        FOCUS_TEXTMESSAGE,
+        FOCUS_MODULE, // Note: target module should call requestFocus(), otherwise no info about which module to focus
+    };
+
+    // Regenerate the normal set of frames, focusing a specific frame if requested
+    // Call when a frame should be added / removed, or custom frames should be cleared
+    void setFrames(FrameFocus focus = FOCUS_DEFAULT);
 
     /// Try to start drawing ASAP
     void setFastFramerate();

src/main.cpp

@@ -275,6 +275,9 @@ void setup()
     digitalWrite(VEXT_ENABLE_V05, 1); // turn on the lora antenna boost
     digitalWrite(ST7735_BL_V05, 1);   // turn on display backligth
     LOG_DEBUG("HELTEC Detect Tracker V1.1\n");
+#elif defined(VEXT_ENABLE) && defined(VEXT_ON_VALUE)
+    pinMode(VEXT_ENABLE, OUTPUT);
+    digitalWrite(VEXT_ENABLE, VEXT_ON_VALUE); // turn on the display power
 #elif defined(VEXT_ENABLE)
     pinMode(VEXT_ENABLE, OUTPUT);
     digitalWrite(VEXT_ENABLE, 0); // turn on the display power
@@ -305,6 +308,13 @@ void setup()
     digitalWrite(RESET_OLED, 1);
 #endif
 
+#ifdef PERIPHERAL_WARMUP_MS
+    // Some peripherals may require additional time to stabilize after power is connected
+    // e.g. I2C on Heltec Vision Master
+    LOG_INFO("Waiting for peripherals to stabilize\n");
+    delay(PERIPHERAL_WARMUP_MS);
+#endif
+
 #ifdef BUTTON_PIN
 #ifdef ARCH_ESP32
 
@@ -713,7 +723,8 @@ void setup()
 
 // Don't call screen setup until after nodedb is setup (because we need
 // the current region name)
-#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS) ||            \
+    defined(USE_ST7789)
     screen->setup();
 #elif defined(ARCH_PORTDUINO)
     if (screen_found.port != ScanI2C::I2CPort::NO_I2C || settingsMap[displayPanel]) {

src/mesh/Channels.cpp

@@ -277,6 +277,17 @@ const char *Channels::getName(size_t chIndex)
     return channelName;
 }
 
+bool Channels::isDefaultChannel(const meshtastic_Channel &ch)
+{
+    if (ch.settings.psk.size == 1 && ch.settings.psk.bytes[0] == 1) {
+        const char *presetName = DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false);
+        // Check if the name is the default derived from the modem preset
+        if (strcmp(ch.settings.name, presetName) == 0)
+            return true;
+    }
+    return false;
+}
+
 bool Channels::hasDefaultChannel()
 {
     // If we don't use a preset or the default frequency slot, or we override the frequency, we don't have a default channel
@@ -285,13 +296,8 @@ bool Channels::hasDefaultChannel()
     // Check if any of the channels are using the default name and PSK
     for (size_t i = 0; i < getNumChannels(); i++) {
         const auto &ch = getByIndex(i);
-        if (ch.settings.psk.size == 1 && ch.settings.psk.bytes[0] == 1) {
-            const char *name = getName(i);
-            const char *presetName = DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false);
-            // Check if the name is the default derived from the modem preset
-            if (strcmp(name, presetName) == 0)
-                return true;
-        }
+        if (isDefaultChannel(ch))
+            return true;
     }
     return false;
 }
@@ -324,4 +330,4 @@ bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
 int16_t Channels::setActiveByIndex(ChannelIndex channelIndex)
 {
     return setCrypto(channelIndex);
-}
+}

src/mesh/Channels.h

@@ -83,6 +83,9 @@ class Channels
      */
     int16_t setActiveByIndex(ChannelIndex channelIndex);
 
+    // Returns true if the channel has the default name and PSK
+    bool isDefaultChannel(const meshtastic_Channel &ch);
+
     // Returns true if we can be reached via a channel with the default settings given a region and modem preset
     bool hasDefaultChannel();
 
@@ -126,4 +129,4 @@ class Channels
 };
 
 /// Singleton channel table
-extern Channels channels;
+extern Channels channels;

src/mesh/Default.cpp

@@ -1,12 +1,5 @@
 #include "Default.h"
 
-uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
-{
-    if (configuredInterval > 0)
-        return configuredInterval * 1000;
-    return default_broadcast_interval_secs * 1000;
-}
-
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
 {
     if (configuredInterval > 0)
@@ -14,10 +7,37 @@ uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t
     return defaultInterval * 1000;
 }
 
+uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
+{
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return default_broadcast_interval_secs * 1000;
+}
+
 uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
 {
     if (configured > 0)
         return configured;
-
     return defaultValue;
+}
+/**
+ * Calculates the scaled value of the configured or default value in ms based on the number of online nodes.
+ *
+ * For example a default of 30 minutes (1800 seconds * 1000) would yield:
+ *   45 nodes = 2475 * 1000
+ *   60 nodes = 4500 * 1000
+ *   75 nodes = 6525 * 1000
+ *   90 nodes = 8550 * 1000
+ * @param configured The configured value.
+ * @param defaultValue The default value.
+ * @param numOnlineNodes The number of online nodes.
+ * @return The scaled value of the configured or default value.
+ */
+uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes)
+{
+    // If we are a router, we don't scale the value. It's already significantly higher.
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER)
+        return getConfiguredOrDefaultMs(configured, defaultValue);
+
+    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
 }

src/mesh/Default.h

@@ -5,6 +5,7 @@
 #define ONE_MINUTE_MS 60 * 1000
 
 #define default_gps_update_interval IF_ROUTER(ONE_DAY, 2 * 60)
+#define default_telemetry_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 30 * 60)
 #define default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 15 * 60)
 #define default_wait_bluetooth_secs IF_ROUTER(1, 60)
 #define default_sds_secs IF_ROUTER(ONE_DAY, UINT32_MAX) // Default to forever super deep sleep
@@ -28,4 +29,17 @@ class Default
     static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval);
     static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval);
     static uint32_t getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue);
+    static uint32_t getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes);
+
+  private:
+    static float congestionScalingCoefficient(int numOnlineNodes)
+    {
+        if (numOnlineNodes <= 40) {
+            return 1.0; // No scaling for 40 or fewer nodes
+        } else {
+            // Sscaling based on number of nodes over 40
+            int nodesOverForty = (numOnlineNodes - 40);
+            return 1.0 + (nodesOverForty * 0.075); // Each number of online node scales by 0.075
+        }
+    }
 };

src/mesh/MeshModule.cpp

@@ -284,4 +284,17 @@ AdminMessageHandleResult MeshModule::handleAdminMessageForAllModules(const mesht
         }
     }
     return handled;
-}
+}
+
+#if HAS_SCREEN
+// Would our module like its frame to be focused after Screen::setFrames has regenerated the list of frames?
+// Only considered if setFrames is triggered by a UIFrameEvent
+bool MeshModule::isRequestingFocus()
+{
+    if (_requestingFocus) {
+        _requestingFocus = false; // Consume the request
+        return true;
+    } else
+        return false;
+}
+#endif

src/mesh/MeshModule.h

@@ -35,10 +35,16 @@ enum class AdminMessageHandleResult {
 /*
  * This struct is used by Screen to figure out whether screen frame should be updated.
  */
-typedef struct _UIFrameEvent {
-    bool frameChanged;
-    bool needRedraw;
-} UIFrameEvent;
+struct UIFrameEvent {
+    // What do we actually want to happen?
+    enum Action {
+        REDRAW_ONLY,                    // Don't change which frames are show, just redraw, asap
+        REGENERATE_FRAMESET,            // Regenerate (change? add? remove?) screen frames, honoring requestFocus()
+        REGENERATE_FRAMESET_BACKGROUND, // Regenerate screen frames, attempting to remain on the same frame throughout
+    } action = REDRAW_ONLY;
+
+    // We might want to pass additional data inside this struct at some point
+};
 
 /** A baseclass for any mesh "module".
  *
@@ -73,6 +79,7 @@ class MeshModule
                                                                     meshtastic_AdminMessage *response);
 #if HAS_SCREEN
     virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) { return; }
+    virtual bool isRequestingFocus(); // Checked by screen, when regenerating frameset
 #endif
   protected:
     const char *name;
@@ -176,6 +183,19 @@ class MeshModule
         return AdminMessageHandleResult::NOT_HANDLED;
     };
 
+#if HAS_SCREEN
+    /** Request that our module's screen frame be focused when Screen::setFrames runs
+     * Only considered if Screen::setFrames is triggered via a UIFrameEvent
+     *
+     * Having this as a separate call, instead of part of the UIFrameEvent, allows the module to delay decision
+     * until drawFrame() is called. This required less restructuring.
+     */
+    bool _requestingFocus = false;
+    void requestFocus() { _requestingFocus = true; }
+#else
+    void requestFocus(){}; // No-op
+#endif
+
   private:
     /**
      * If any of the current chain of modules has already sent a reply, it will be here.  This is useful to allow

src/mesh/MeshService.cpp

@@ -94,7 +94,11 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
     } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
                nodeInfoModule) {
         LOG_INFO("Heard a node on channel %d we don't know, sending NodeInfo and asking for a response.\n", mp->channel);
-        nodeInfoModule->sendOurNodeInfo(mp->from, true, mp->channel);
+        if (airTime->isTxAllowedChannelUtil(true)) {
+            nodeInfoModule->sendOurNodeInfo(mp->from, true, mp->channel);
+        } else {
+            LOG_DEBUG("Skip sending NodeInfo due to > 25 percent channel util.\n");
+        }
     }
 
     printPacket("Forwarding to phone", mp);
@@ -289,6 +293,17 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p)
 {
     perhapsDecode(p);
 
+#ifdef ARCH_ESP32
+#if !MESHTASTIC_EXCLUDE_STOREFORWARD
+    if (moduleConfig.store_forward.enabled && storeForwardModule->isServer() &&
+        p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) {
+        releaseToPool(p); // Copy is already stored in StoreForward history
+        fromNum++;        // Notify observers for packet from radio
+        return;
+    }
+#endif
+#endif
+
     if (toPhoneQueue.numFree() == 0) {
         if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP ||
             p->decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP) {

src/mesh/MeshService.h

@@ -13,6 +13,11 @@
 #if defined(ARCH_PORTDUINO) && !HAS_RADIO
 #include "../platform/portduino/SimRadio.h"
 #endif
+#ifdef ARCH_ESP32
+#if !MESHTASTIC_EXCLUDE_STOREFORWARD
+#include "modules/esp32/StoreForwardModule.h"
+#endif
+#endif
 
 extern Allocator<meshtastic_QueueStatus> &queueStatusPool;
 extern Allocator<meshtastic_MqttClientProxyMessage> &mqttClientProxyMessagePool;
@@ -139,7 +144,7 @@ class MeshService
     /// returns 0 to allow further processing
     int onGPSChanged(const meshtastic::GPSStatus *arg);
 #endif
-    /// Handle a packet that just arrived from the radio.  This method does _ReliableRouternot_ free the provided packet.  If it
+    /// Handle a packet that just arrived from the radio.  This method does _not_ free the provided packet.  If it
     /// needs to keep the packet around it makes a copy
     int handleFromRadio(const meshtastic_MeshPacket *p);
     friend class RoutingModule;

src/mesh/MeshTypes.h

@@ -10,6 +10,8 @@ typedef uint32_t NodeNum;
 typedef uint32_t PacketId; // A packet sequence number
 
 #define NODENUM_BROADCAST UINT32_MAX
+#define NODENUM_BROADCAST_NO_LORA                                                                                                \
+    1 // Reserved to only deliver packets over high speed (non-lora) transports, such as MQTT or BLE mesh (not yet implemented)
 #define ERRNO_OK 0
 #define ERRNO_NO_INTERFACES 33
 #define ERRNO_UNKNOWN 32  // pick something that doesn't conflict with RH_ROUTER_ERROR_UNABLE_TO_DELIVER

src/mesh/NodeDB.cpp

@@ -268,7 +268,8 @@ void NodeDB::installDefaultConfig()
     // FIXME: Default to bluetooth capability of platform as default
     config.bluetooth.enabled = true;
     config.bluetooth.fixed_pin = defaultBLEPin;
-#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS) ||            \
+    defined(USE_ST7789)
     bool hasScreen = true;
 #elif ARCH_PORTDUINO
     bool hasScreen = false;
@@ -424,10 +425,13 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
 
 void NodeDB::initModuleConfigIntervals()
 {
-    moduleConfig.telemetry.device_update_interval = default_broadcast_interval_secs;
-    moduleConfig.telemetry.environment_update_interval = default_broadcast_interval_secs;
-    moduleConfig.telemetry.air_quality_interval = default_broadcast_interval_secs;
-    moduleConfig.neighbor_info.update_interval = default_broadcast_interval_secs;
+    // Zero out telemetry intervals so that they coalesce to defaults in Default.h
+    moduleConfig.telemetry.device_update_interval = 0;
+    moduleConfig.telemetry.environment_update_interval = 0;
+    moduleConfig.telemetry.air_quality_interval = 0;
+    moduleConfig.telemetry.power_update_interval = 0;
+    moduleConfig.neighbor_info.update_interval = 0;
+    moduleConfig.paxcounter.paxcounter_update_interval = 0;
 }
 
 void NodeDB::installDefaultChannels()
@@ -647,6 +651,26 @@ void NodeDB::loadFromDisk()
     if (state == LoadFileResult::SUCCESS) {
         LOG_INFO("Loaded OEMStore\n");
     }
+
+    // 2.4.X - configuration migration to update new default intervals
+    if (moduleConfig.version < 23) {
+        LOG_DEBUG("ModuleConfig version %d is stale, upgrading to new default intervals\n", moduleConfig.version);
+        moduleConfig.version = DEVICESTATE_CUR_VER;
+        if (moduleConfig.telemetry.device_update_interval == 900)
+            moduleConfig.telemetry.device_update_interval = 0;
+        if (moduleConfig.telemetry.environment_update_interval == 900)
+            moduleConfig.telemetry.environment_update_interval = 0;
+        if (moduleConfig.telemetry.air_quality_interval == 900)
+            moduleConfig.telemetry.air_quality_interval = 0;
+        if (moduleConfig.telemetry.power_update_interval == 900)
+            moduleConfig.telemetry.power_update_interval = 0;
+        if (moduleConfig.neighbor_info.update_interval == 900)
+            moduleConfig.neighbor_info.update_interval = 0;
+        if (moduleConfig.paxcounter.paxcounter_update_interval == 900)
+            moduleConfig.paxcounter.paxcounter_update_interval = 0;
+
+        saveToDisk(SEGMENT_MODULECONFIG);
+    }
 }
 
 /** Save a protobuf from a file, return true for success */

src/mesh/NodeDB.h

@@ -20,8 +20,8 @@ DeviceState versions used to be defined in the .proto file but really only this
 #define SEGMENT_DEVICESTATE 4
 #define SEGMENT_CHANNELS 8
 
-#define DEVICESTATE_CUR_VER 22
-#define DEVICESTATE_MIN_VER DEVICESTATE_CUR_VER
+#define DEVICESTATE_CUR_VER 23
+#define DEVICESTATE_MIN_VER 22
 
 extern meshtastic_DeviceState devicestate;
 extern meshtastic_ChannelFile channelFile;

src/mesh/PhoneAPI.cpp

@@ -503,6 +503,14 @@ bool PhoneAPI::available()
             return true;
         }
 
+#ifdef ARCH_ESP32
+#if !MESHTASTIC_EXCLUDE_STOREFORWARD
+        // Check if StoreForward has packets stored for us.
+        if (!packetForPhone && storeForwardModule)
+            packetForPhone = storeForwardModule->getForPhone();
+#endif
+#endif
+
         if (!packetForPhone)
             packetForPhone = service.getForPhone();
         hasPacket = !!packetForPhone;

src/mesh/ProtobufModule.h

@@ -13,6 +13,7 @@ template <class T> class ProtobufModule : protected SinglePortModule
     const pb_msgdesc_t *fields;
 
   public:
+    uint8_t numOnlineNodes = 0;
     /** Constructor
      * name is for debugging output
      */
@@ -61,6 +62,14 @@ template <class T> class ProtobufModule : protected SinglePortModule
         return sender;
     }
 
+    int handleStatusUpdate(const meshtastic::Status *arg)
+    {
+        if (arg->getStatusType() == STATUS_TYPE_NODE) {
+            numOnlineNodes = nodeStatus->getNumOnline();
+        }
+        return 0;
+    }
+
   private:
     /** Called to handle a particular incoming message
 

src/mesh/Router.cpp

@@ -92,22 +92,23 @@ void Router::enqueueReceivedMessage(meshtastic_MeshPacket *p)
 // FIXME, move this someplace better
 PacketId generatePacketId()
 {
-    static uint32_t i; // Note: trying to keep this in noinit didn't help for working across reboots
+    static uint32_t rollingPacketId; // Note: trying to keep this in noinit didn't help for working across reboots
     static bool didInit = false;
 
-    uint32_t numPacketId = UINT32_MAX;
-
     if (!didInit) {
         didInit = true;
 
         // pick a random initial sequence number at boot (to prevent repeated reboots always starting at 0)
         // Note: we mask the high order bit to ensure that we never pass a 'negative' number to random
-        i = random(numPacketId & 0x7fffffff);
-        LOG_DEBUG("Initial packet id %u, numPacketId %u\n", i, numPacketId);
+        rollingPacketId = random(UINT32_MAX & 0x7fffffff);
+        LOG_DEBUG("Initial packet id %u\n", rollingPacketId);
     }
 
-    i++;
-    PacketId id = (i % numPacketId) + 1; // return number between 1 and numPacketId (ie - never zero)
+    rollingPacketId++;
+
+    rollingPacketId &= UINT32_MAX >> 22;                                   // Mask out the top 22 bits
+    PacketId id = rollingPacketId | random(UINT32_MAX & 0x7fffffff) << 10; // top 22 bits
+    LOG_DEBUG("Partially randomized packet id %u\n", id);
     return id;
 }
 

src/mesh/compression/unishox2.cpp

@@ -15,6 +15,7 @@
  *
  * @author Arundale Ramanathan
  *
+ * Port for Particle (particle.io) / Aruino - Jonathan Greenblatt
  */
 /**
  * @file unishox2.c
@@ -36,6 +37,14 @@
 /// uint8_t is unsigned char
 typedef unsigned char uint8_t;
 
+const char *USX_FREQ_SEQ_DFLT[] = {"\": \"", "\": ", "</", "=\"", "\":\"", "://"};
+const char *USX_FREQ_SEQ_TXT[] = {" the ", " and ", "tion", " with", "ing", "ment"};
+const char *USX_FREQ_SEQ_URL[] = {"https://", "www.", ".com", "http://", ".org", ".net"};
+const char *USX_FREQ_SEQ_JSON[] = {"\": \"", "\": ", "\",", "}}}", "\":\"", "}}"};
+const char *USX_FREQ_SEQ_HTML[] = {"</", "=\"", "div", "href", "class", "<p>"};
+const char *USX_FREQ_SEQ_XML[] = {"</", "=\"", "\">", "<?xml version=\"1.0\"", "xmlns:", "://"};
+const char *USX_TEMPLATES[] = {"tfff-of-tfTtf:rf:rf.fffZ", "tfff-of-tf", "(fff) fff-ffff", "tf:rf:rf", 0};
+
 /// possible horizontal sets and states
 enum { USX_ALPHA = 0, USX_SYM, USX_NUM, USX_DICT, USX_DELTA, USX_NUM_TEMP };
 
@@ -57,7 +66,7 @@ uint8_t usx_code_94[94];
 uint8_t usx_vcodes[] = {0x00, 0x40, 0x60, 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xD8, 0xE0, 0xE4, 0xE8, 0xEC,
                         0xEE, 0xF0, 0xF2, 0xF4, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF};
 
-/// Length of each vertical code
+/// Length of each veritical code
 uint8_t usx_vcode_lens[] = {2, 3, 3, 4, 4, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};
 
 /// Vertical Codes and Set number for frequent sequences in sets USX_SYM and USX_NUM. First 3 bits indicate set (USX_SYM/USX_NUM)
@@ -188,7 +197,7 @@ int append_switch_code(char *out, int olen, int ol, uint8_t state)
     return ol;
 }
 
-/// Appends given horizontal and vertical code bits to out
+/// Appends given horizontal and veritical code bits to out
 int append_code(char *out, int olen, int ol, uint8_t code, uint8_t *state, const uint8_t usx_hcodes[],
                 const uint8_t usx_hcode_lens[])
 {
@@ -888,7 +897,7 @@ int read8bitCode(const char *in, int len, int bit_no)
     return code;
 }
 
-/// The list of vertical codes is split into 5 sections. Used by readVCodeIdx()
+/// The list of veritical codes is split into 5 sections. Used by readVCodeIdx()
 #define SECTION_COUNT 5
 /// Used by readVCodeIdx() for finding the section under which the code read using read8bitCode() falls
 uint8_t usx_vsections[] = {0x7F, 0xBF, 0xDF, 0xEF, 0xFF};
@@ -915,7 +924,7 @@ uint8_t usx_vcode_lookup[36] = {(1 << 5) + 0,  (1 << 5) + 0,  (2 << 5) + 1,  (2
 /// compared to using a 256 uint8_t buffer to decode the next 8 bits read by read8bitCode() \n
 /// by splitting the list of vertical codes. \n
 /// Decoder is designed for using less memory, not speed. \n
-/// Returns the vertical code index or 99 if match could not be found. \n
+/// Returns the veritical code index or 99 if match could not be found. \n
 /// Also updates bit_no_p with how many ever bits used by the vertical code.
 int readVCodeIdx(const char *in, int len, int *bit_no_p)
 {
@@ -1420,4 +1429,4 @@ int unishox2_decompress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *o
 int unishox2_decompress_simple(const char *in, int len, char *out)
 {
     return unishox2_decompress(in, len, UNISHOX_API_OUT_AND_LEN(out, INT_MAX - 1), USX_PSET_DFLT);
-}
+}

src/mesh/compression/unishox2.h

@@ -15,12 +15,7 @@
  *
  * @author Arundale Ramanathan
  *
- */
-
-/**
- * @file unishox2.h
- * @author Arundale Ramanathan, James Z. M. Gao
- * @brief API for Unishox2 Compression and Decompression
+ * Port for Particle (particle.io) / Aruino - Jonathan Greenblatt
  *
  * This file describes each function of the Unishox2 API \n
  * For finding out how this API can be used in your program, \n
@@ -45,7 +40,7 @@
  * The simple api, i.e. unishox2_(de)compress_simple will always omit the buffer length
  */
 #ifndef UNISHOX_API_WITH_OUTPUT_LEN
-#define UNISHOX_API_WITH_OUTPUT_LEN 0
+#define UNISHOX_API_WITH_OUTPUT_LEN 1
 #endif
 
 /// Upto 8 bits of initial magic bit sequence can be included. Bit count can be specified with UNISHOX_MAGIC_BIT_LEN
@@ -156,8 +151,8 @@
         3, 1, 3, 3, 3                                                                                                            \
     }
 
-//#define USX_HCODES_FAVOR_UMLAUT {0x00, 0x40, 0xE0, 0xC0, 0x80}
-//#define USX_HCODE_LENS_FAVOR_UMLAUT {2, 2, 3, 3, 2}
+// #define USX_HCODES_FAVOR_UMLAUT {0x00, 0x40, 0xE0, 0xC0, 0x80}
+// #define USX_HCODE_LENS_FAVOR_UMLAUT {2, 2, 3, 3, 2}
 
 /// Horizontal codes preset favouring umlaut letters
 #define USX_HCODES_FAVOR_UMLAUT                                                                                                  \
@@ -198,50 +193,13 @@
         2, 2, 2, 2, 0                                                                                                            \
     }
 
-/// Default frequently occurring sequences. When composition of text is know beforehand, the other sequences in this section can
-/// be used to achieve more compression.
-#define USX_FREQ_SEQ_DFLT                                                                                                        \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        "\": \"", "\": ", "</", "=\"", "\":\"", "://"                                                                            \
-    }
-/// Frequently occurring sequences in text content
-#define USX_FREQ_SEQ_TXT                                                                                                         \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        " the ", " and ", "tion", " with", "ing", "ment"                                                                         \
-    }
-/// Frequently occurring sequences in URL content
-#define USX_FREQ_SEQ_URL                                                                                                         \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        "https://", "www.", ".com", "http://", ".org", ".net"                                                                    \
-    }
-/// Frequently occurring sequences in JSON content
-#define USX_FREQ_SEQ_JSON                                                                                                        \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        "\": \"", "\": ", "\",", "}}}", "\":\"", "}}"                                                                            \
-    }
-/// Frequently occurring sequences in HTML content
-#define USX_FREQ_SEQ_HTML                                                                                                        \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        "</", "=\"", "div", "href", "class", "<p>"                                                                               \
-    }
-/// Frequently occurring sequences in XML content
-#define USX_FREQ_SEQ_XML                                                                                                         \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        "</", "=\"", "\">", "<?xml version=\"1.0\"", "xmlns:", "://"                                                             \
-    }
-
-/// Commonly occurring templates (ISO Date/Time, ISO Date, US Phone number, ISO Time, Unused)
-#define USX_TEMPLATES                                                                                                            \
-    (const char *[])                                                                                                             \
-    {                                                                                                                            \
-        "tfff-of-tfTtf:rf:rf.fffZ", "tfff-of-tf", "(fff) fff-ffff", "tf:rf:rf", 0                                                \
-    }
+extern const char *USX_FREQ_SEQ_DFLT[];
+extern const char *USX_FREQ_SEQ_TXT[];
+extern const char *USX_FREQ_SEQ_URL[];
+extern const char *USX_FREQ_SEQ_JSON[];
+extern const char *USX_FREQ_SEQ_HTML[];
+extern const char *USX_FREQ_SEQ_XML[];
+extern const char *USX_TEMPLATES[];
 
 /// Default preset parameter set. When composition of text is know beforehand, the other parameter sets in this section can be
 /// used to achieve more compression.
@@ -333,8 +291,8 @@ extern int unishox2_decompress_simple(const char *in, int len, char *out);
  * @param[in] olen           length of 'out' buffer in bytes. Can be omitted if sufficient buffer is provided
  * @param[in] usx_hcodes     Horizontal codes (array of bytes). See macro section for samples.
  * @param[in] usx_hcode_lens Length of each element in usx_hcodes array
- * @param[in] usx_freq_seq   Frequently occurring sequences. See USX_FREQ_SEQ_* macros for samples
- * @param[in] usx_templates  Templates of frequently occurring patterns. See USX_TEMPLATES macro.
+ * @param[in] usx_freq_seq   Frequently occuring sequences. See USX_FREQ_SEQ_* macros for samples
+ * @param[in] usx_templates  Templates of frequently occuring patterns. See USX_TEMPLATES macro.
  */
 extern int unishox2_compress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
                              const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[], const char *usx_freq_seq[],
@@ -352,8 +310,8 @@ extern int unishox2_compress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(ch
  * @param[in] olen           length of 'out' buffer in bytes. Can be omitted if sufficient buffer is provided
  * @param[in] usx_hcodes     Horizontal codes (array of bytes). See macro section for samples.
  * @param[in] usx_hcode_lens Length of each element in usx_hcodes array
- * @param[in] usx_freq_seq   Frequently occurring sequences. See USX_FREQ_SEQ_* macros for samples
- * @param[in] usx_templates  Templates of frequently occurring patterns. See USX_TEMPLATES macro.
+ * @param[in] usx_freq_seq   Frequently occuring sequences. See USX_FREQ_SEQ_* macros for samples
+ * @param[in] usx_templates  Templates of frequently occuring patterns. See USX_TEMPLATES macro.
  */
 extern int unishox2_decompress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
                                const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[], const char *usx_freq_seq[],
@@ -373,7 +331,7 @@ extern int unishox2_compress_lines(const char *in, int len, UNISHOX_API_OUT_AND_
                                    const char *usx_freq_seq[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
 /**
  * More Comprehensive API for de-compressing array of strings \n
- * This function is not be used in conjunction with unishox2_compress_lines()
+ * This function is not be used in conjuction with unishox2_compress_lines()
  *
  * See unishox2_decompress() function for parameter definitions. \n
  * Typically an array is compressed using unishox2_compress_lines() and \n
@@ -386,4 +344,4 @@ extern int unishox2_decompress_lines(const char *in, int len, UNISHOX_API_OUT_AN
                                      const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[],
                                      const char *usx_freq_seq[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
 
-#endif
+#endif

src/mesh/generated/meshtastic/apponly.pb.h

@@ -55,7 +55,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
-#define meshtastic_ChannelSet_size               674
+#define meshtastic_ChannelSet_size               676
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/config.pb.h

@@ -497,6 +497,8 @@ typedef struct _meshtastic_Config_LoRaConfig {
  Please respect your local laws and regulations. If you are a HAM, make sure you
  enable HAM mode and turn off encryption. */
     float override_frequency;
+    /* If true, disable the build-in PA FAN using pin define in RF95_FAN_EN. */
+    bool pa_fan_disabled;
     /* For testing it is useful sometimes to force a node to never listen to
  particular other nodes (simulating radio out of range). All nodenums listed
  in ignore_incoming will have packets they send dropped on receive (by router.cpp) */
@@ -618,7 +620,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0, 0}
 #define meshtastic_Config_init_zero              {0, {meshtastic_Config_DeviceConfig_init_zero}}
 #define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0, 0, "", 0}
@@ -627,7 +629,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
@@ -702,6 +704,7 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_override_duty_cycle_tag 12
 #define meshtastic_Config_LoRaConfig_sx126x_rx_boosted_gain_tag 13
 #define meshtastic_Config_LoRaConfig_override_frequency_tag 14
+#define meshtastic_Config_LoRaConfig_pa_fan_disabled_tag 15
 #define meshtastic_Config_LoRaConfig_ignore_incoming_tag 103
 #define meshtastic_Config_LoRaConfig_ignore_mqtt_tag 104
 #define meshtastic_Config_BluetoothConfig_enabled_tag 1
@@ -832,6 +835,7 @@ X(a, STATIC,   SINGULAR, UINT32,   channel_num,      11) \
 X(a, STATIC,   SINGULAR, BOOL,     override_duty_cycle,  12) \
 X(a, STATIC,   SINGULAR, BOOL,     sx126x_rx_boosted_gain,  13) \
 X(a, STATIC,   SINGULAR, FLOAT,    override_frequency,  14) \
+X(a, STATIC,   SINGULAR, BOOL,     pa_fan_disabled,  15) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
 X(a, STATIC,   SINGULAR, BOOL,     ignore_mqtt,     104)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
@@ -871,7 +875,7 @@ extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
 #define meshtastic_Config_BluetoothConfig_size   12
 #define meshtastic_Config_DeviceConfig_size      100
 #define meshtastic_Config_DisplayConfig_size     30
-#define meshtastic_Config_LoRaConfig_size        80
+#define meshtastic_Config_LoRaConfig_size        82
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     196
 #define meshtastic_Config_PositionConfig_size    62

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -307,7 +307,7 @@ extern const pb_msgdesc_t meshtastic_OEMStore_msg;
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_OEMStore_size
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_NodeInfoLite_size             166
-#define meshtastic_OEMStore_size                 3384
+#define meshtastic_OEMStore_size                 3388
 #define meshtastic_PositionLite_size             28
 
 #ifdef __cplusplus

src/mesh/generated/meshtastic/localonly.pb.h

@@ -181,8 +181,8 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
-#define meshtastic_LocalConfig_size              553
-#define meshtastic_LocalModuleConfig_size        685
+#define meshtastic_LocalConfig_size              555
+#define meshtastic_LocalModuleConfig_size        687
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/mesh.pb.h

@@ -176,6 +176,8 @@ typedef enum _meshtastic_HardwareModel {
     /* Heltec Mesh Node T114 board with nRF52840 CPU, and a 1.14 inch TFT display, Ultimate low-power design,
  specifically adapted for the Meshtatic project */
     meshtastic_HardwareModel_HELTEC_MESH_NODE_T114 = 69,
+    /* Sensecap Indicator from Seeed Studio. ESP32-S3 device with TFT and RP2040 coprocessor */
+    meshtastic_HardwareModel_SENSECAP_INDICATOR = 70,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
  ------------------------------------------------------------------------------------------------------------------------------------------ */

src/mesh/generated/meshtastic/module_config.pb.h

@@ -60,7 +60,9 @@ typedef enum _meshtastic_ModuleConfig_SerialConfig_Serial_Mode {
     meshtastic_ModuleConfig_SerialConfig_Serial_Mode_TEXTMSG = 3,
     meshtastic_ModuleConfig_SerialConfig_Serial_Mode_NMEA = 4,
     /* NMEA messages specifically tailored for CalTopo */
-    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO = 5
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO = 5,
+    /* Ecowitt WS85 weather station */
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85 = 6
 } meshtastic_ModuleConfig_SerialConfig_Serial_Mode;
 
 /* TODO: REPLACE */
@@ -273,6 +275,8 @@ typedef struct _meshtastic_ModuleConfig_StoreForwardConfig {
     uint32_t history_return_max;
     /* TODO: REPLACE */
     uint32_t history_return_window;
+    /* Set to true to let this node act as a server that stores received messages and resends them upon request. */
+    bool is_server;
 } meshtastic_ModuleConfig_StoreForwardConfig;
 
 /* Preferences for the RangeTestModule */
@@ -432,8 +436,8 @@ extern "C" {
 #define _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Baud)(meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600+1))
 
 #define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN meshtastic_ModuleConfig_SerialConfig_Serial_Mode_DEFAULT
-#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO
-#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO+1))
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85+1))
 
 #define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE
 #define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MAX meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK
@@ -474,7 +478,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_PaxcounterConfig_init_default {0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-#define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_default {0, 0, 0}
 #define meshtastic_ModuleConfig_TelemetryConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
@@ -490,7 +494,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_PaxcounterConfig_init_zero {0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-#define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_zero {0, 0, 0}
 #define meshtastic_ModuleConfig_TelemetryConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
@@ -560,6 +564,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_StoreForwardConfig_records_tag 3
 #define meshtastic_ModuleConfig_StoreForwardConfig_history_return_max_tag 4
 #define meshtastic_ModuleConfig_StoreForwardConfig_history_return_window_tag 5
+#define meshtastic_ModuleConfig_StoreForwardConfig_is_server_tag 6
 #define meshtastic_ModuleConfig_RangeTestConfig_enabled_tag 1
 #define meshtastic_ModuleConfig_RangeTestConfig_sender_tag 2
 #define meshtastic_ModuleConfig_RangeTestConfig_save_tag 3
@@ -743,7 +748,8 @@ X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
 X(a, STATIC,   SINGULAR, BOOL,     heartbeat,         2) \
 X(a, STATIC,   SINGULAR, UINT32,   records,           3) \
 X(a, STATIC,   SINGULAR, UINT32,   history_return_max,   4) \
-X(a, STATIC,   SINGULAR, UINT32,   history_return_window,   5)
+X(a, STATIC,   SINGULAR, UINT32,   history_return_window,   5) \
+X(a, STATIC,   SINGULAR, BOOL,     is_server,         6)
 #define meshtastic_ModuleConfig_StoreForwardConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_StoreForwardConfig_DEFAULT NULL
 
@@ -848,7 +854,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_RangeTestConfig_size 10
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_size 96
 #define meshtastic_ModuleConfig_SerialConfig_size 28
-#define meshtastic_ModuleConfig_StoreForwardConfig_size 22
+#define meshtastic_ModuleConfig_StoreForwardConfig_size 24
 #define meshtastic_ModuleConfig_TelemetryConfig_size 36
 #define meshtastic_ModuleConfig_size             257
 #define meshtastic_RemoteHardwarePin_size        21

src/mesh/generated/meshtastic/telemetry.pb.h

@@ -115,6 +115,10 @@ typedef struct _meshtastic_EnvironmentMetrics {
     float wind_speed;
     /* Weight in KG */
     float weight;
+    /* Wind gust in m/s */
+    float wind_gust;
+    /* Wind lull in m/s */
+    float wind_lull;
 } meshtastic_EnvironmentMetrics;
 
 /* Power Metrics (voltage / current / etc) */
@@ -205,13 +209,13 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_DeviceMetrics_init_default    {0, 0, 0, 0, 0}
-#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_PowerMetrics_init_default     {0, 0, 0, 0, 0, 0}
 #define meshtastic_AirQualityMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_default        {0, 0, {meshtastic_DeviceMetrics_init_default}}
 #define meshtastic_Nau7802Config_init_default    {0, 0}
 #define meshtastic_DeviceMetrics_init_zero       {0, 0, 0, 0, 0}
-#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_PowerMetrics_init_zero        {0, 0, 0, 0, 0, 0}
 #define meshtastic_AirQualityMetrics_init_zero   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_zero           {0, 0, {meshtastic_DeviceMetrics_init_zero}}
@@ -238,6 +242,8 @@ extern "C" {
 #define meshtastic_EnvironmentMetrics_wind_direction_tag 13
 #define meshtastic_EnvironmentMetrics_wind_speed_tag 14
 #define meshtastic_EnvironmentMetrics_weight_tag 15
+#define meshtastic_EnvironmentMetrics_wind_gust_tag 16
+#define meshtastic_EnvironmentMetrics_wind_lull_tag 17
 #define meshtastic_PowerMetrics_ch1_voltage_tag  1
 #define meshtastic_PowerMetrics_ch1_current_tag  2
 #define meshtastic_PowerMetrics_ch2_voltage_tag  3
@@ -289,7 +295,9 @@ X(a, STATIC,   SINGULAR, FLOAT,    ir_lux,           11) \
 X(a, STATIC,   SINGULAR, FLOAT,    uv_lux,           12) \
 X(a, STATIC,   SINGULAR, UINT32,   wind_direction,   13) \
 X(a, STATIC,   SINGULAR, FLOAT,    wind_speed,       14) \
-X(a, STATIC,   SINGULAR, FLOAT,    weight,           15)
+X(a, STATIC,   SINGULAR, FLOAT,    weight,           15) \
+X(a, STATIC,   SINGULAR, FLOAT,    wind_gust,        16) \
+X(a, STATIC,   SINGULAR, FLOAT,    wind_lull,        17)
 #define meshtastic_EnvironmentMetrics_CALLBACK NULL
 #define meshtastic_EnvironmentMetrics_DEFAULT NULL
 
@@ -357,10 +365,10 @@ extern const pb_msgdesc_t meshtastic_Nau7802Config_msg;
 #define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size
 #define meshtastic_AirQualityMetrics_size        72
 #define meshtastic_DeviceMetrics_size            27
-#define meshtastic_EnvironmentMetrics_size       73
+#define meshtastic_EnvironmentMetrics_size       85
 #define meshtastic_Nau7802Config_size            16
 #define meshtastic_PowerMetrics_size             30
-#define meshtastic_Telemetry_size                80
+#define meshtastic_Telemetry_size                92
 
 #ifdef __cplusplus
 } /* extern "C" */

src/modules/AdminModule.cpp

@@ -200,6 +200,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
     case meshtastic_AdminMessage_remove_by_nodenum_tag: {
         LOG_INFO("Client is receiving a remove_nodenum command.\n");
         nodeDB->removeNodeByNum(r->remove_by_nodenum);
+        this->notifyObservers(r); // Observed by screen
         break;
     }
     case meshtastic_AdminMessage_set_favorite_node_tag: {
@@ -391,6 +392,11 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         // Router Client is deprecated; Set it to client
         if (c.payload_variant.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT) {
             config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
+            if (moduleConfig.store_forward.enabled && !moduleConfig.store_forward.is_server) {
+                moduleConfig.store_forward.is_server = true;
+                changes |= SEGMENT_MODULECONFIG;
+                requiresReboot = true;
+            }
         }
         break;
     case meshtastic_Config_position_tag:

src/modules/AdminModule.h

@@ -7,7 +7,7 @@
 /**
  * Admin module for admin messages
  */
-class AdminModule : public ProtobufModule<meshtastic_AdminMessage>
+class AdminModule : public ProtobufModule<meshtastic_AdminMessage>, public Observable<const meshtastic_AdminMessage *>
 {
   public:
     /** Constructor

src/modules/AtakPluginModule.cpp

@@ -5,11 +5,8 @@
 #include "PowerFSM.h"
 #include "configuration.h"
 #include "main.h"
-#include "meshtastic/atak.pb.h"
-
-extern "C" {
 #include "mesh/compression/unishox2.h"
-}
+#include "meshtastic/atak.pb.h"
 
 AtakPluginModule *atakPluginModule;
 
@@ -69,30 +66,53 @@ void AtakPluginModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtast
         auto compressed = cloneTAKPacketData(t);
         compressed.is_compressed = true;
         if (t->has_contact) {
-            auto length = unishox2_compress_simple(t->contact.callsign, strlen(t->contact.callsign), compressed.contact.callsign);
+            auto length = unishox2_compress_lines(t->contact.callsign, strlen(t->contact.callsign), compressed.contact.callsign,
+                                                  sizeof(compressed.contact.callsign) - 1, USX_PSET_DFLT, NULL);
+            if (length < 0) {
+                LOG_WARN("Compression overflowed contact.callsign. Reverting to uncompressed packet\n");
+                return;
+            }
             LOG_DEBUG("Compressed callsign: %d bytes\n", length);
-
-            length = unishox2_compress_simple(t->contact.device_callsign, strlen(t->contact.device_callsign),
-                                              compressed.contact.device_callsign);
+            length = unishox2_compress_lines(t->contact.device_callsign, strlen(t->contact.device_callsign),
+                                             compressed.contact.device_callsign, sizeof(compressed.contact.device_callsign) - 1,
+                                             USX_PSET_DFLT, NULL);
+            if (length < 0) {
+                LOG_WARN("Compression overflowed contact.device_callsign. Reverting to uncompressed packet\n");
+                return;
+            }
             LOG_DEBUG("Compressed device_callsign: %d bytes\n", length);
         }
         if (t->which_payload_variant == meshtastic_TAKPacket_chat_tag) {
-            auto length = unishox2_compress_simple(t->payload_variant.chat.message, strlen(t->payload_variant.chat.message),
-                                                   compressed.payload_variant.chat.message);
+            auto length = unishox2_compress_lines(t->payload_variant.chat.message, strlen(t->payload_variant.chat.message),
+                                                  compressed.payload_variant.chat.message,
+                                                  sizeof(compressed.payload_variant.chat.message) - 1, USX_PSET_DFLT, NULL);
+            if (length < 0) {
+                LOG_WARN("Compression overflowed chat.message. Reverting to uncompressed packet\n");
+                return;
+            }
             LOG_DEBUG("Compressed chat message: %d bytes\n", length);
 
             if (t->payload_variant.chat.has_to) {
                 compressed.payload_variant.chat.has_to = true;
-                length = unishox2_compress_simple(t->payload_variant.chat.to, strlen(t->payload_variant.chat.to),
-                                                  compressed.payload_variant.chat.to);
+                length = unishox2_compress_lines(t->payload_variant.chat.to, strlen(t->payload_variant.chat.to),
+                                                 compressed.payload_variant.chat.to,
+                                                 sizeof(compressed.payload_variant.chat.to) - 1, USX_PSET_DFLT, NULL);
+                if (length < 0) {
+                    LOG_WARN("Compression overflowed chat.to. Reverting to uncompressed packet\n");
+                    return;
+                }
                 LOG_DEBUG("Compressed chat to: %d bytes\n", length);
             }
 
             if (t->payload_variant.chat.has_to_callsign) {
                 compressed.payload_variant.chat.has_to_callsign = true;
-                length =
-                    unishox2_compress_simple(t->payload_variant.chat.to_callsign, strlen(t->payload_variant.chat.to_callsign),
-                                             compressed.payload_variant.chat.to_callsign);
+                length = unishox2_compress_lines(t->payload_variant.chat.to_callsign, strlen(t->payload_variant.chat.to_callsign),
+                                                 compressed.payload_variant.chat.to_callsign,
+                                                 sizeof(compressed.payload_variant.chat.to_callsign) - 1, USX_PSET_DFLT, NULL);
+                if (length < 0) {
+                    LOG_WARN("Compression overflowed chat.to_callsign. Reverting to uncompressed packet\n");
+                    return;
+                }
                 LOG_DEBUG("Compressed chat to_callsign: %d bytes\n", length);
             }
         }
@@ -102,7 +122,7 @@ void AtakPluginModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtast
     } else {
         if (!t->is_compressed) {
             // Not compressed. Something is wrong
-            LOG_ERROR("Received uncompressed TAKPacket over radio!\n");
+            LOG_WARN("Received uncompressed TAKPacket over radio! Skipping\n");
             return;
         }
 
@@ -112,32 +132,55 @@ void AtakPluginModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtast
         uncompressed.is_compressed = false;
         if (t->has_contact) {
             auto length =
-                unishox2_decompress_simple(t->contact.callsign, strlen(t->contact.callsign), uncompressed.contact.callsign);
-
+                unishox2_decompress_lines(t->contact.callsign, strlen(t->contact.callsign), uncompressed.contact.callsign,
+                                          sizeof(uncompressed.contact.callsign) - 1, USX_PSET_DFLT, NULL);
+            if (length < 0) {
+                LOG_WARN("Decompression overflowed contact.callsign. Bailing out\n");
+                return;
+            }
             LOG_DEBUG("Decompressed callsign: %d bytes\n", length);
 
-            length = unishox2_decompress_simple(t->contact.device_callsign, strlen(t->contact.device_callsign),
-                                                uncompressed.contact.device_callsign);
-
+            length = unishox2_decompress_lines(t->contact.device_callsign, strlen(t->contact.device_callsign),
+                                               uncompressed.contact.device_callsign,
+                                               sizeof(uncompressed.contact.device_callsign) - 1, USX_PSET_DFLT, NULL);
+            if (length < 0) {
+                LOG_WARN("Decompression overflowed contact.device_callsign. Bailing out\n");
+                return;
+            }
             LOG_DEBUG("Decompressed device_callsign: %d bytes\n", length);
         }
         if (uncompressed.which_payload_variant == meshtastic_TAKPacket_chat_tag) {
-            auto length = unishox2_decompress_simple(t->payload_variant.chat.message, strlen(t->payload_variant.chat.message),
-                                                     uncompressed.payload_variant.chat.message);
+            auto length = unishox2_decompress_lines(t->payload_variant.chat.message, strlen(t->payload_variant.chat.message),
+                                                    uncompressed.payload_variant.chat.message,
+                                                    sizeof(uncompressed.payload_variant.chat.message) - 1, USX_PSET_DFLT, NULL);
+            if (length < 0) {
+                LOG_WARN("Decompression overflowed chat.message. Bailing out\n");
+                return;
+            }
             LOG_DEBUG("Decompressed chat message: %d bytes\n", length);
 
             if (t->payload_variant.chat.has_to) {
                 uncompressed.payload_variant.chat.has_to = true;
-                length = unishox2_decompress_simple(t->payload_variant.chat.to, strlen(t->payload_variant.chat.to),
-                                                    uncompressed.payload_variant.chat.to);
+                length = unishox2_decompress_lines(t->payload_variant.chat.to, strlen(t->payload_variant.chat.to),
+                                                   uncompressed.payload_variant.chat.to,
+                                                   sizeof(uncompressed.payload_variant.chat.to) - 1, USX_PSET_DFLT, NULL);
+                if (length < 0) {
+                    LOG_WARN("Decompression overflowed chat.to. Bailing out\n");
+                    return;
+                }
                 LOG_DEBUG("Decompressed chat to: %d bytes\n", length);
             }
 
             if (t->payload_variant.chat.has_to_callsign) {
                 uncompressed.payload_variant.chat.has_to_callsign = true;
                 length =
-                    unishox2_decompress_simple(t->payload_variant.chat.to_callsign, strlen(t->payload_variant.chat.to_callsign),
-                                               uncompressed.payload_variant.chat.to_callsign);
+                    unishox2_decompress_lines(t->payload_variant.chat.to_callsign, strlen(t->payload_variant.chat.to_callsign),
+                                              uncompressed.payload_variant.chat.to_callsign,
+                                              sizeof(uncompressed.payload_variant.chat.to_callsign) - 1, USX_PSET_DFLT, NULL);
+                if (length < 0) {
+                    LOG_WARN("Decompression overflowed chat.to_callsign. Bailing out\n");
+                    return;
+                }
                 LOG_DEBUG("Decompressed chat to_callsign: %d bytes\n", length);
             }
         }
@@ -148,4 +191,4 @@ void AtakPluginModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtast
         service.sendToPhone(decompressedCopy);
     }
     return;
-}
+}

src/modules/CannedMessageModule.cpp

@@ -148,8 +148,9 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
         if (this->currentMessageIndex == 0) {
             this->runState = CANNED_MESSAGE_RUN_STATE_FREETEXT;
 
-            UIFrameEvent e = {false, true};
-            e.frameChanged = true;
+            requestFocus(); // Tell Screen::setFrames to move to our module's frame, next time it runs
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
             this->notifyObservers(&e);
 
             return 0;
@@ -166,8 +167,8 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
         }
     }
     if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL)) {
-        UIFrameEvent e = {false, true};
-        e.frameChanged = true;
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
 
 #if !defined(T_WATCH_S3) && !defined(RAK14014)
@@ -353,6 +354,8 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
     }
 
     if (validEvent) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame, next time it runs
+
         // Let runOnce to be called immediately.
         if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_SELECT) {
             setIntervalFromNow(0); // on fast keypresses, this isn't fast enough.
@@ -378,6 +381,11 @@ void CannedMessageModule::sendText(NodeNum dest, ChannelIndex channel, const cha
         p->decoded.payload.size++;
     }
 
+    // Only receive routing messages when expecting ACK for a canned message
+    // Prevents the canned message module from regenerating the screen's frameset at unexpected times,
+    // or raising a UIFrameEvent before another module has the chance
+    this->waitingForAck = true;
+
     LOG_INFO("Sending message id=%d, dest=%x, msg=%.*s\n", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);
 
     service.sendToMesh(
@@ -393,13 +401,13 @@ int32_t CannedMessageModule::runOnce()
         return INT32_MAX;
     }
     // LOG_DEBUG("Check status\n");
-    UIFrameEvent e = {false, true};
+    UIFrameEvent e;
     if ((this->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) ||
         (this->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) || (this->runState == CANNED_MESSAGE_RUN_STATE_MESSAGE)) {
         // TODO: might have some feedback of sending state
         this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
         temporaryMessage = "";
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
         this->freetext = ""; // clear freetext
         this->cursor = 0;
@@ -412,7 +420,7 @@ int32_t CannedMessageModule::runOnce()
     } else if (((this->runState == CANNED_MESSAGE_RUN_STATE_ACTIVE) || (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT)) &&
                ((millis() - this->lastTouchMillis) > INACTIVATE_AFTER_MS)) {
         // Reset module
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
         this->freetext = ""; // clear freetext
         this->cursor = 0;
@@ -449,7 +457,7 @@ int32_t CannedMessageModule::runOnce()
                 this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
             }
         }
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
         this->freetext = ""; // clear freetext
         this->cursor = 0;
@@ -463,7 +471,7 @@ int32_t CannedMessageModule::runOnce()
     } else if ((this->runState != CANNED_MESSAGE_RUN_STATE_FREETEXT) && (this->currentMessageIndex == -1)) {
         this->currentMessageIndex = 0;
         LOG_DEBUG("First touch (%d):%s\n", this->currentMessageIndex, this->getCurrentMessage());
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->runState = CANNED_MESSAGE_RUN_STATE_ACTIVE;
     } else if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_UP) {
         if (this->messagesCount > 0) {
@@ -567,7 +575,7 @@ int32_t CannedMessageModule::runOnce()
             break;
         }
         if (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT) {
-            e.frameChanged = true;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
             switch (this->payload) { // code below all trigger the freetext window (where you type to send a message) or reset the
                                      // display back to the default window
             case 0x08:               // backspace
@@ -706,8 +714,8 @@ int CannedMessageModule::getPrevIndex()
 void CannedMessageModule::showTemporaryMessage(const String &message)
 {
     temporaryMessage = message;
-    UIFrameEvent e = {false, true};
-    e.frameChanged = true;
+    UIFrameEvent e;
+    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
     notifyObservers(&e);
     runState = CANNED_MESSAGE_RUN_STATE_MESSAGE;
     // run this loop again in 2 seconds, next iteration will clear the display
@@ -914,11 +922,13 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
     char buffer[50];
 
     if (temporaryMessage.length() != 0) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
         LOG_DEBUG("Drawing temporary message: %s", temporaryMessage.c_str());
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         display->drawString(display->getWidth() / 2 + x, 0 + y + 12, temporaryMessage);
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         String displayString;
@@ -940,6 +950,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             display->drawStringf(display->getWidth() / 2 + x, y + 130, buffer, rssiString, this->lastRxRssi);
         }
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         display->drawString(display->getWidth() / 2 + x, 0 + y + 12, "Sending...");
@@ -948,7 +959,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
         display->setFont(FONT_SMALL);
         display->drawString(10 + x, 0 + y + FONT_HEIGHT_SMALL, "Canned Message\nModule disabled.");
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT) {
-
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
 #if defined(T_WATCH_S3) || defined(RAK14014)
         drawKeyboard(display, state, 0, 0);
 #else
@@ -1030,16 +1041,18 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
 
 ProcessMessage CannedMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-    if (mp.decoded.portnum == meshtastic_PortNum_ROUTING_APP) {
+    if (mp.decoded.portnum == meshtastic_PortNum_ROUTING_APP && waitingForAck) {
         // look for a request_id
         if (mp.decoded.request_id != 0) {
-            UIFrameEvent e = {false, true};
-            e.frameChanged = true;
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
+            requestFocus(); // Tell Screen::setFrames that our module's frame should be shown, even if not "first" in the frameset
             this->runState = CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED;
             this->incoming = service.getNodenumFromRequestId(mp.decoded.request_id);
             meshtastic_Routing decoded = meshtastic_Routing_init_default;
             pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_Routing_fields, &decoded);
             this->ack = decoded.error_reason == meshtastic_Routing_Error_NONE;
+            waitingForAck = false; // No longer want routing packets
             this->notifyObservers(&e);
             // run the next time 2 seconds later
             setIntervalFromNow(2000);

src/modules/CannedMessageModule.h

@@ -81,9 +81,8 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
         }
 
         switch (p->decoded.portnum) {
-        case meshtastic_PortNum_TEXT_MESSAGE_APP:
         case meshtastic_PortNum_ROUTING_APP:
-            return true;
+            return waitingForAck;
         default:
             return false;
         }
@@ -140,7 +139,8 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     uint8_t numChannels = 0;
     ChannelIndex indexChannels[MAX_NUM_CHANNELS] = {0};
     NodeNum incoming = NODENUM_BROADCAST;
-    bool ack = false; // True means ACK, false means NAK (error_reason != NONE)
+    bool ack = false;           // True means ACK, false means NAK (error_reason != NONE)
+    bool waitingForAck = false; // Are currently interested in routing packets?
     float lastRxSnr = 0;
     int32_t lastRxRssi = 0;
 

src/modules/DetectionSensorModule.cpp

@@ -58,8 +58,8 @@ int32_t DetectionSensorModule::runOnce()
     // of heartbeat. We only do this if the minimum broadcast interval is greater than zero, otherwise we'll only broadcast state
     // change detections.
     else if (moduleConfig.detection_sensor.state_broadcast_secs > 0 &&
-             (millis() - lastSentToMesh) >=
-                 Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs)) {
+             (millis() - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs,
+                                                                              default_telemetry_broadcast_interval_secs)) {
         sendCurrentStateMessage();
         return DELAYED_INTERVAL;
     }

src/modules/NeighborInfoModule.cpp

@@ -39,11 +39,12 @@ NeighborInfoModule::NeighborInfoModule()
       concurrency::OSThread("NeighborInfoModule")
 {
     ourPortNum = meshtastic_PortNum_NEIGHBORINFO_APP;
+    nodeStatusObserver.observe(&nodeStatus->onNewStatus);
 
     if (moduleConfig.neighbor_info.enabled) {
         isPromiscuous = true; // Update neighbors from all packets
-        setIntervalFromNow(
-            Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs));
+        setIntervalFromNow(Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval,
+                                                             default_telemetry_broadcast_interval_secs));
     } else {
         LOG_DEBUG("NeighborInfoModule is disabled\n");
         disable();
@@ -119,7 +120,8 @@ int32_t NeighborInfoModule::runOnce()
     if (airTime->isTxAllowedChannelUtil(true) && airTime->isTxAllowedAirUtil()) {
         sendNeighborInfo(NODENUM_BROADCAST, false);
     }
-    return Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs);
+    return Default::getConfiguredOrDefaultMsScaled(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs,
+                                                   numOnlineNodes);
 }
 
 /*

src/modules/NeighborInfoModule.h

@@ -7,6 +7,9 @@
  */
 class NeighborInfoModule : public ProtobufModule<meshtastic_NeighborInfo>, private concurrency::OSThread
 {
+    CallbackObserver<NeighborInfoModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<NeighborInfoModule, const meshtastic::Status *>(this, &NeighborInfoModule::handleStatusUpdate);
+
     std::vector<meshtastic_Neighbor> neighbors;
 
   public:

src/modules/PositionModule.cpp

@@ -11,12 +11,12 @@
 #include "configuration.h"
 #include "gps/GeoCoord.h"
 #include "main.h"
+#include "mesh/compression/unishox2.h"
 #include "meshtastic/atak.pb.h"
 #include "sleep.h"
 #include "target_specific.h"
 
 extern "C" {
-#include "mesh/compression/unishox2.h"
 #include <Throttle.h>
 }
 
@@ -28,6 +28,8 @@ PositionModule::PositionModule()
 {
     precision = 0;        // safe starting value
     isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
+    nodeStatusObserver.observe(&nodeStatus->onNewStatus);
+
     if (config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_TAK_TRACKER)
         setIntervalFromNow(60 * 1000);
@@ -253,10 +255,12 @@ meshtastic_MeshPacket *PositionModule::allocAtakPli()
                                            .course = static_cast<uint16_t>(localPosition.ground_track),
                                        }}};
 
-    auto length = unishox2_compress_simple(owner.long_name, strlen(owner.long_name), takPacket.contact.device_callsign);
+    auto length = unishox2_compress_lines(owner.long_name, strlen(owner.long_name), takPacket.contact.device_callsign,
+                                          sizeof(takPacket.contact.device_callsign) - 1, USX_PSET_DFLT, NULL);
     LOG_DEBUG("Uncompressed device_callsign '%s' - %d bytes\n", owner.long_name, strlen(owner.long_name));
     LOG_DEBUG("Compressed device_callsign '%s' - %d bytes\n", takPacket.contact.device_callsign, length);
-    length = unishox2_compress_simple(owner.long_name, strlen(owner.long_name), takPacket.contact.callsign);
+    length = unishox2_compress_lines(owner.long_name, strlen(owner.long_name), takPacket.contact.callsign,
+                                     sizeof(takPacket.contact.callsign) - 1, USX_PSET_DFLT, NULL);
     mp->decoded.payload.size =
         pb_encode_to_bytes(mp->decoded.payload.bytes, sizeof(mp->decoded.payload.bytes), &meshtastic_TAKPacket_msg, &takPacket);
     return mp;
@@ -333,8 +337,8 @@ int32_t PositionModule::runOnce()
 
     // We limit our GPS broadcasts to a max rate
     uint32_t now = millis();
-    uint32_t intervalMs =
-        Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
+    uint32_t intervalMs = Default::getConfiguredOrDefaultMsScaled(config.position.position_broadcast_secs,
+                                                                  default_broadcast_interval_secs, numOnlineNodes);
     uint32_t msSinceLastSend = now - lastGpsSend;
     // Only send packets if the channel util. is less than 25% utilized or we're a tracker with less than 40% utilized.
     if (!airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&

src/modules/PositionModule.h

@@ -8,6 +8,9 @@
  */
 class PositionModule : public ProtobufModule<meshtastic_Position>, private concurrency::OSThread
 {
+    CallbackObserver<PositionModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<PositionModule, const meshtastic::Status *>(this, &PositionModule::handleStatusUpdate);
+
     /// The id of the last packet we sent, to allow us to cancel it if we make something fresher
     PacketId prevPacketId = 0;
 
@@ -59,7 +62,7 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
     void sendLostAndFoundText();
 
     const uint32_t minimumTimeThreshold =
-        Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);
+        Default::getConfiguredOrDefaultMsScaled(config.position.broadcast_smart_minimum_interval_secs, 30, numOnlineNodes);
 };
 
 struct SmartPosition {

src/modules/SerialModule.cpp

@@ -1,4 +1,5 @@
 #include "SerialModule.h"
+#include "GeoCoord.h"
 #include "MeshService.h"
 #include "NMEAWPL.h"
 #include "NodeDB.h"
@@ -66,7 +67,7 @@ SerialModule::SerialModule() : StreamAPI(&Serial2), concurrency::OSThread("Seria
 static Print *serialPrint = &Serial2;
 #endif
 
-char serialBytes[meshtastic_Constants_DATA_PAYLOAD_LEN];
+char serialBytes[512];
 size_t serialPayloadSize;
 
 SerialModuleRadio::SerialModuleRadio() : MeshModule("SerialModuleRadio")
@@ -198,8 +199,12 @@ int32_t SerialModule::runOnce()
                     }
                 }
             }
+
 #if !defined(TTGO_T_ECHO) && !defined(CANARYONE)
-            else {
+            else if ((moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85)) {
+                processWXSerial();
+
+            } else {
                 while (Serial2.available()) {
                     serialPayloadSize = Serial2.readBytes(serialBytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
                     serialModuleRadio->sendPayload();
@@ -213,6 +218,27 @@ int32_t SerialModule::runOnce()
     }
 }
 
+/**
+ * Sends telemetry packet over the mesh network.
+ *
+ * @param m The telemetry data to be sent
+ *
+ * @return void
+ *
+ * @throws None
+ */
+void SerialModule::sendTelemetry(meshtastic_Telemetry m)
+{
+    meshtastic_MeshPacket *p = router->allocForSending();
+    p->decoded.portnum = meshtastic_PortNum_TELEMETRY_APP;
+    p->decoded.payload.size =
+        pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_Telemetry_msg, &m);
+    p->to = NODENUM_BROADCAST;
+    p->decoded.want_response = false;
+    p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+    service.sendToMesh(p, RX_SRC_LOCAL, true);
+}
+
 /**
  * Allocates a new mesh packet for use as a reply to a received packet.
  *
@@ -357,4 +383,162 @@ uint32_t SerialModule::getBaudRate()
     }
     return BAUD;
 }
+
+/**
+ * Process the received weather station serial data, extract wind, voltage, and temperature information,
+ * calculate averages and send telemetry data over the mesh network.
+ *
+ * @return void
+ */
+void SerialModule::processWXSerial()
+{
+#if !defined(TTGO_T_ECHO) && !defined(CANARYONE)
+    static unsigned int lastAveraged = 0;
+    static unsigned int averageIntervalMillis = 300000; // 5 minutes hard coded.
+    static double dir_sum_sin = 0;
+    static double dir_sum_cos = 0;
+    static float velSum = 0;
+    static float gust = 0;
+    static float lull = -1;
+    static int velCount = 0;
+    static int dirCount = 0;
+    static char windDir[4] = "xxx";   // Assuming windDir is 3 characters long + null terminator
+    static char windVel[5] = "xx.x";  // Assuming windVel is 4 characters long + null terminator
+    static char windGust[5] = "xx.x"; // Assuming windGust is 4 characters long + null terminator
+    static char batVoltage[5] = "0.0V";
+    static char capVoltage[5] = "0.0V";
+    static float batVoltageF = 0;
+    static float capVoltageF = 0;
+    bool gotwind = false;
+
+    while (Serial2.available()) {
+        // clear serialBytes buffer
+        memset(serialBytes, '\0', sizeof(serialBytes));
+        // memset(formattedString, '\0', sizeof(formattedString));
+        serialPayloadSize = Serial2.readBytes(serialBytes, 512);
+        // check for a strings we care about
+        // example output of serial data fields from the WS85
+        // WindDir      = 79
+        // WindSpeed    = 0.5
+        // WindGust     = 0.6
+        // GXTS04Temp   = 24.4
+        if (serialPayloadSize > 0) {
+            // Define variables for line processing
+            int lineStart = 0;
+            int lineEnd = -1;
+
+            // Process each byte in the received data
+            for (size_t i = 0; i < serialPayloadSize; i++) {
+                // go until we hit the end of line and then process the line
+                if (serialBytes[i] == '\n') {
+                    lineEnd = i;
+                    // Extract the current line
+                    char line[meshtastic_Constants_DATA_PAYLOAD_LEN];
+                    memset(line, '\0', sizeof(line));
+                    memcpy(line, &serialBytes[lineStart], lineEnd - lineStart);
+
+                    if (strstr(line, "Wind") != NULL) // we have a wind line
+                    {
+                        gotwind = true;
+                        // Find the positions of "=" signs in the line
+                        char *windDirPos = strstr(line, "WindDir      = ");
+                        char *windSpeedPos = strstr(line, "WindSpeed    = ");
+                        char *windGustPos = strstr(line, "WindGust     = ");
+
+                        if (windDirPos != NULL) {
+                            // Extract data after "=" for WindDir
+                            strcpy(windDir, windDirPos + 15); // Add 15 to skip "WindDir = "
+                            double radians = toRadians(strtof(windDir, nullptr));
+                            dir_sum_sin += sin(radians);
+                            dir_sum_cos += cos(radians);
+                            dirCount++;
+                        } else if (windSpeedPos != NULL) {
+                            // Extract data after "=" for WindSpeed
+                            strcpy(windVel, windSpeedPos + 15); // Add 15 to skip "WindSpeed = "
+                            float newv = strtof(windVel, nullptr);
+                            velSum += newv;
+                            velCount++;
+                            if (newv < lull || lull == -1)
+                                lull = newv;
+
+                        } else if (windGustPos != NULL) {
+                            strcpy(windGust, windGustPos + 15); // Add 15 to skip "WindSpeed = "
+                            float newg = strtof(windGust, nullptr);
+                            if (newg > gust)
+                                gust = newg;
+                        }
+
+                        // these are also voltage data we care about possibly
+                    } else if (strstr(line, "BatVoltage") != NULL) { // we have a battVoltage line
+                        char *batVoltagePos = strstr(line, "BatVoltage     = ");
+                        if (batVoltagePos != NULL) {
+                            strcpy(batVoltage, batVoltagePos + 17); // 18 for ws 80, 17 for ws85
+                            batVoltageF = strtof(batVoltage, nullptr);
+                            break; // last possible data we want so break
+                        }
+                    } else if (strstr(line, "CapVoltage") != NULL) { // we have a cappVoltage line
+                        char *capVoltagePos = strstr(line, "CapVoltage     = ");
+                        if (capVoltagePos != NULL) {
+                            strcpy(capVoltage, capVoltagePos + 17); // 18 for ws 80, 17 for ws85
+                            capVoltageF = strtof(capVoltage, nullptr);
+                        }
+                    }
+
+                    // Update lineStart for the next line
+                    lineStart = lineEnd + 1;
+                }
+            }
+            break;
+            // clear the input buffer
+            while (Serial2.available() > 0) {
+                Serial2.read(); // Read and discard the bytes in the input buffer
+            }
+        }
+    }
+    if (gotwind) {
+
+        LOG_INFO("WS85 : %i %.1fg%.1f %.1fv %.1fv\n", atoi(windDir), strtof(windVel, nullptr), strtof(windGust, nullptr),
+                 batVoltageF, capVoltageF);
+    }
+    if (gotwind && millis() - lastAveraged > averageIntervalMillis) {
+        // calulate averages and send to the mesh
+        float velAvg = 1.0 * velSum / velCount;
+
+        double avgSin = dir_sum_sin / dirCount;
+        double avgCos = dir_sum_cos / dirCount;
+
+        double avgRadians = atan2(avgSin, avgCos);
+        float dirAvg = toDegrees(avgRadians);
+
+        if (dirAvg < 0) {
+            dirAvg += 360.0;
+        }
+        lastAveraged = millis();
+
+        // make a telemetry packet with the data
+        meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+        m.which_variant = meshtastic_Telemetry_environment_metrics_tag;
+        m.variant.environment_metrics.wind_speed = velAvg;
+        m.variant.environment_metrics.wind_direction = dirAvg;
+        m.variant.environment_metrics.wind_gust = gust;
+        m.variant.environment_metrics.wind_lull = lull;
+        m.variant.environment_metrics.voltage =
+            capVoltageF > batVoltageF ? capVoltageF : batVoltageF; // send the larger of the two voltage values.
+
+        LOG_INFO("WS85 Transmit speed=%fm/s, direction=%d , lull=%f, gust=%f, voltage=%f\n",
+                 m.variant.environment_metrics.wind_speed, m.variant.environment_metrics.wind_direction,
+                 m.variant.environment_metrics.wind_lull, m.variant.environment_metrics.wind_gust,
+                 m.variant.environment_metrics.voltage);
+
+        sendTelemetry(m);
+
+        // reset counters and gust/lull
+        velSum = velCount = dirCount = 0;
+        dir_sum_sin = dir_sum_cos = 0;
+        gust = 0;
+        lull = -1;
+    }
+#endif
+    return;
+}
 #endif

src/modules/SerialModule.h

@@ -28,6 +28,8 @@ class SerialModule : public StreamAPI, private concurrency::OSThread
 
   private:
     uint32_t getBaudRate();
+    void sendTelemetry(meshtastic_Telemetry m);
+    void processWXSerial();
 };
 
 extern SerialModule *serialModule;

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -47,7 +47,9 @@ int32_t AirQualityTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.air_quality_interval))) &&
+             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.air_quality_interval,
+                                                                                default_telemetry_broadcast_interval_secs,
+                                                                                numOnlineNodes))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();

src/modules/Telemetry/AirQualityTelemetry.h

@@ -10,6 +10,10 @@
 
 class AirQualityTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<AirQualityTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<AirQualityTelemetryModule, const meshtastic::Status *>(this,
+                                                                                &AirQualityTelemetryModule::handleStatusUpdate);
+
   public:
     AirQualityTelemetryModule()
         : concurrency::OSThread("AirQualityTelemetryModule"),
@@ -18,6 +22,7 @@ class AirQualityTelemetryModule : private concurrency::OSThread, public Protobuf
         lastMeasurementPacket = nullptr;
         setIntervalFromNow(10 * 1000);
         aqi = Adafruit_PM25AQI();
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
     }
 
   protected:

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -17,7 +17,9 @@ int32_t DeviceTelemetryModule::runOnce()
 {
     refreshUptime();
     if (((lastSentToMesh == 0) ||
-         ((uptimeLastMs - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.device_update_interval))) &&
+         ((uptimeLastMs - lastSentToMesh) >=
+          Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.device_update_interval,
+                                                  default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
         airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
         airTime->isTxAllowedAirUtil() && config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN) {

src/modules/Telemetry/DeviceTelemetry.h

@@ -7,6 +7,9 @@
 
 class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<DeviceTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<DeviceTelemetryModule, const meshtastic::Status *>(this, &DeviceTelemetryModule::handleStatusUpdate);
+
   public:
     DeviceTelemetryModule()
         : concurrency::OSThread("DeviceTelemetryModule"),
@@ -14,6 +17,7 @@ class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModu
     {
         uptimeWrapCount = 0;
         uptimeLastMs = millis();
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
         setIntervalFromNow(45 * 1000); // Wait until NodeInfo is sent
     }
     virtual bool wantUIFrame() { return false; }

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -33,6 +33,9 @@
 #include "Sensor/SHT31Sensor.h"
 #include "Sensor/SHT4XSensor.h"
 #include "Sensor/SHTC3Sensor.h"
+#ifdef T1000X_SENSOR_EN
+#include "Sensor/T1000xSensor.h"
+#endif
 #include "Sensor/TSL2591Sensor.h"
 #include "Sensor/VEML7700Sensor.h"
 
@@ -53,6 +56,9 @@ AHT10Sensor aht10Sensor;
 MLX90632Sensor mlx90632Sensor;
 DFRobotLarkSensor dfRobotLarkSensor;
 NAU7802Sensor nau7802Sensor;
+#ifdef T1000X_SENSOR_EN
+T1000xSensor t1000xSensor;
+#endif
 
 #define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
 #define DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN true
@@ -63,7 +69,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval,
+                                                                   default_telemetry_broadcast_interval_secs);
         LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.\n", nightyNightMs);
         doDeepSleep(nightyNightMs, true);
     }
@@ -91,6 +98,9 @@ int32_t EnvironmentTelemetryModule::runOnce()
             LOG_INFO("Environment Telemetry: Initializing\n");
             // it's possible to have this module enabled, only for displaying values on the screen.
             // therefore, we should only enable the sensor loop if measurement is also enabled
+#ifdef T1000X_SENSOR_EN // add by WayenWeng
+            result = t1000xSensor.runOnce();
+#else
             if (dfRobotLarkSensor.hasSensor())
                 result = dfRobotLarkSensor.runOnce();
             if (bmp085Sensor.hasSensor())
@@ -115,6 +125,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
                 result = ina219Sensor.runOnce();
             if (ina260Sensor.hasSensor())
                 result = ina260Sensor.runOnce();
+            if (ina3221Sensor.hasSensor())
+                result = ina3221Sensor.runOnce();
             if (veml7700Sensor.hasSensor())
                 result = veml7700Sensor.runOnce();
             if (tsl2591Sensor.hasSensor())
@@ -129,6 +141,7 @@ int32_t EnvironmentTelemetryModule::runOnce()
                 result = mlx90632Sensor.runOnce();
             if (nau7802Sensor.hasSensor())
                 result = nau7802Sensor.runOnce();
+#endif
         }
         return result;
     } else {
@@ -142,7 +155,9 @@ int32_t EnvironmentTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval))) &&
+             ((now - lastSentToMesh) >=
+              Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.environment_update_interval,
+                                                      default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
@@ -277,6 +292,10 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
     m->time = getTime();
     m->which_variant = meshtastic_Telemetry_environment_metrics_tag;
 
+#ifdef T1000X_SENSOR_EN // add by WayenWeng
+    valid = valid && t1000xSensor.getMetrics(m);
+    hasSensor = true;
+#else
     if (dfRobotLarkSensor.hasSensor()) {
         valid = valid && dfRobotLarkSensor.getMetrics(m);
         hasSensor = true;
@@ -325,6 +344,10 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
         valid = valid && ina260Sensor.getMetrics(m);
         hasSensor = true;
     }
+    if (ina3221Sensor.hasSensor()) {
+        valid = valid && ina3221Sensor.getMetrics(m);
+        hasSensor = true;
+    }
     if (veml7700Sensor.hasSensor()) {
         valid = valid && veml7700Sensor.getMetrics(m);
         hasSensor = true;
@@ -362,6 +385,7 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
         }
     }
 
+#endif
     return valid && hasSensor;
 }
 
@@ -499,6 +523,11 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
         if (result != AdminMessageHandleResult::NOT_HANDLED)
             return result;
     }
+    if (ina3221Sensor.hasSensor()) {
+        result = ina3221Sensor.handleAdminMessage(mp, request, response);
+        if (result != AdminMessageHandleResult::NOT_HANDLED)
+            return result;
+    }
     if (veml7700Sensor.hasSensor()) {
         result = veml7700Sensor.handleAdminMessage(mp, request, response);
         if (result != AdminMessageHandleResult::NOT_HANDLED)
@@ -537,4 +566,4 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
     return result;
 }
 
-#endif
+#endif

src/modules/Telemetry/EnvironmentTelemetry.h

@@ -11,12 +11,17 @@
 
 class EnvironmentTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<EnvironmentTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<EnvironmentTelemetryModule, const meshtastic::Status *>(this,
+                                                                                 &EnvironmentTelemetryModule::handleStatusUpdate);
+
   public:
     EnvironmentTelemetryModule()
         : concurrency::OSThread("EnvironmentTelemetryModule"),
           ProtobufModule("EnvironmentTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
         lastMeasurementPacket = nullptr;
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
         setIntervalFromNow(10 * 1000);
     }
     virtual bool wantUIFrame() override;

src/modules/Telemetry/PowerTelemetry.cpp

@@ -24,7 +24,8 @@ int32_t PowerTelemetryModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval,
+                                                                   default_telemetry_broadcast_interval_secs);
         LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.\n", nightyNightMs);
         doDeepSleep(nightyNightMs, true);
     }
@@ -70,7 +71,9 @@ int32_t PowerTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval))) &&
+             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.power_update_interval,
+                                                                                default_telemetry_broadcast_interval_secs,
+                                                                                numOnlineNodes))) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
             lastSentToMesh = now;

src/modules/Telemetry/PowerTelemetry.h

@@ -12,12 +12,16 @@
 
 class PowerTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<PowerTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<PowerTelemetryModule, const meshtastic::Status *>(this, &PowerTelemetryModule::handleStatusUpdate);
+
   public:
     PowerTelemetryModule()
         : concurrency::OSThread("PowerTelemetryModule"),
           ProtobufModule("PowerTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
         lastMeasurementPacket = nullptr;
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
         setIntervalFromNow(10 * 1000);
     }
     virtual bool wantUIFrame() override;

src/modules/Telemetry/Sensor/INA3221Sensor.cpp

@@ -27,22 +27,69 @@ int32_t INA3221Sensor::runOnce()
 
 void INA3221Sensor::setup() {}
 
+struct _INA3221Measurement INA3221Sensor::getMeasurement(ina3221_ch_t ch)
+{
+    struct _INA3221Measurement measurement;
+
+    measurement.voltage = ina3221.getVoltage(ch);
+    measurement.current = ina3221.getCurrent(ch);
+
+    return measurement;
+}
+
+struct _INA3221Measurements INA3221Sensor::getMeasurements()
+{
+    struct _INA3221Measurements measurements;
+
+    // INA3221 has 3 channels starting from 0
+    for (int i = 0; i < 3; i++) {
+        measurements.measurements[i] = getMeasurement((ina3221_ch_t)i);
+    }
+
+    return measurements;
+}
+
 bool INA3221Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
-    measurement->variant.environment_metrics.voltage = ina3221.getVoltage(INA3221_CH1);
-    measurement->variant.environment_metrics.current = ina3221.getCurrent(INA3221_CH1);
-    measurement->variant.power_metrics.ch1_voltage = ina3221.getVoltage(INA3221_CH1);
-    measurement->variant.power_metrics.ch1_current = ina3221.getCurrent(INA3221_CH1);
-    measurement->variant.power_metrics.ch2_voltage = ina3221.getVoltage(INA3221_CH2);
-    measurement->variant.power_metrics.ch2_current = ina3221.getCurrent(INA3221_CH2);
-    measurement->variant.power_metrics.ch3_voltage = ina3221.getVoltage(INA3221_CH3);
-    measurement->variant.power_metrics.ch3_current = ina3221.getCurrent(INA3221_CH3);
+    switch (measurement->which_variant) {
+    case meshtastic_Telemetry_environment_metrics_tag:
+        return getEnvironmentMetrics(measurement);
+
+    case meshtastic_Telemetry_power_metrics_tag:
+        return getPowerMetrics(measurement);
+    }
+
+    // unsupported metric
+    return false;
+}
+
+bool INA3221Sensor::getEnvironmentMetrics(meshtastic_Telemetry *measurement)
+{
+    struct _INA3221Measurement m = getMeasurement(ENV_CH);
+
+    measurement->variant.environment_metrics.voltage = m.voltage;
+    measurement->variant.environment_metrics.current = m.current;
+
+    return true;
+}
+
+bool INA3221Sensor::getPowerMetrics(meshtastic_Telemetry *measurement)
+{
+    struct _INA3221Measurements m = getMeasurements();
+
+    measurement->variant.power_metrics.ch1_voltage = m.measurements[INA3221_CH1].voltage;
+    measurement->variant.power_metrics.ch1_current = m.measurements[INA3221_CH1].current;
+    measurement->variant.power_metrics.ch2_voltage = m.measurements[INA3221_CH2].voltage;
+    measurement->variant.power_metrics.ch2_current = m.measurements[INA3221_CH2].current;
+    measurement->variant.power_metrics.ch3_voltage = m.measurements[INA3221_CH3].voltage;
+    measurement->variant.power_metrics.ch3_current = m.measurements[INA3221_CH3].current;
+
     return true;
 }
 
 uint16_t INA3221Sensor::getBusVoltageMv()
 {
-    return lround(ina3221.getVoltage(INA3221_CH1) * 1000);
+    return lround(ina3221.getVoltage(BAT_CH) * 1000);
 }
 
 #endif

src/modules/Telemetry/Sensor/INA3221Sensor.h

@@ -12,6 +12,21 @@ class INA3221Sensor : public TelemetrySensor, VoltageSensor
   private:
     INA3221 ina3221 = INA3221(INA3221_ADDR42_SDA);
 
+    // channel to report voltage/current for environment metrics
+    ina3221_ch_t ENV_CH = INA3221_CH1;
+
+    // channel to report battery voltage for device_battery_ina_address
+    ina3221_ch_t BAT_CH = INA3221_CH1;
+
+    // get a single measurement for a channel
+    struct _INA3221Measurement getMeasurement(ina3221_ch_t ch);
+
+    // get all measurements for all channels
+    struct _INA3221Measurements getMeasurements();
+
+    bool getEnvironmentMetrics(meshtastic_Telemetry *measurement);
+    bool getPowerMetrics(meshtastic_Telemetry *measurement);
+
   protected:
     void setup() override;
 
@@ -22,4 +37,14 @@ class INA3221Sensor : public TelemetrySensor, VoltageSensor
     virtual uint16_t getBusVoltageMv() override;
 };
 
+struct _INA3221Measurement {
+    float voltage;
+    float current;
+};
+
+struct _INA3221Measurements {
+    // INA3221 has 3 channels
+    struct _INA3221Measurement measurements[3];
+};
+
 #endif

src/modules/Telemetry/Sensor/T1000xSensor.cpp

@@ -0,0 +1,116 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(T1000X_SENSOR_EN)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "T1000xSensor.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_Sensor.h>
+
+#define T1000X_SENSE_SAMPLES 15
+#define T1000X_LIGHT_REF_VCC 2400
+
+#define HEATER_NTC_BX 4250   // thermistor coefficient B
+#define HEATER_NTC_RP 8250   // ohm, series resistance to thermistor
+#define HEATER_NTC_KA 273.15 // 25 Celsius at Kelvin
+#define NTC_REF_VCC 3000     // mV, output voltage of LDO
+
+// ntc res table
+uint32_t ntc_res2[136] = {
+    113347, 107565, 102116, 96978, 92132, 87559, 83242, 79166, 75316, 71677, 68237, 64991, 61919, 59011, 56258, 53650, 51178,
+    48835,  46613,  44506,  42506, 40600, 38791, 37073, 35442, 33892, 32420, 31020, 29689, 28423, 27219, 26076, 24988, 23951,
+    22963,  22021,  21123,  20267, 19450, 18670, 17926, 17214, 16534, 15886, 15266, 14674, 14108, 13566, 13049, 12554, 12081,
+    11628,  11195,  10780,  10382, 10000, 9634,  9284,  8947,  8624,  8315,  8018,  7734,  7461,  7199,  6948,  6707,  6475,
+    6253,   6039,   5834,   5636,  5445,  5262,  5086,  4917,  4754,  4597,  4446,  4301,  4161,  4026,  3896,  3771,  3651,
+    3535,   3423,   3315,   3211,  3111,  3014,  2922,  2834,  2748,  2666,  2586,  2509,  2435,  2364,  2294,  2228,  2163,
+    2100,   2040,   1981,   1925,  1870,  1817,  1766,  1716,  1669,  1622,  1578,  1535,  1493,  1452,  1413,  1375,  1338,
+    1303,   1268,   1234,   1202,  1170,  1139,  1110,  1081,  1053,  1026,  999,   974,   949,   925,   902,   880,   858,
+};
+
+int8_t ntc_temp2[136] = {
+    -30, -29, -28, -27, -26, -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8,
+    -7,  -6,  -5,  -4,  -3,  -2,  -1,  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14, 15,
+    16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37, 38,
+    39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60, 61,
+    62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83, 84,
+    85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105,
+};
+
+T1000xSensor::T1000xSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SENSOR_UNSET, "T1000x") {}
+
+int32_t T1000xSensor::runOnce()
+{
+    LOG_INFO("Init sensor: %s\n", sensorName);
+    if (!hasSensor()) {
+        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    }
+    return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+}
+
+void T1000xSensor::setup()
+{
+    // Set up oversampling and filter initialization
+}
+
+float T1000xSensor::getLux()
+{
+    uint32_t lux_vot = 0;
+    float lux_level = 0;
+
+    for (uint32_t i = 0; i < T1000X_SENSE_SAMPLES; i++) {
+        lux_vot += analogRead(T1000X_LUX_PIN);
+    }
+    lux_vot = lux_vot / T1000X_SENSE_SAMPLES;
+    lux_vot = ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * lux_vot;
+
+    if (lux_vot <= 80)
+        lux_level = 0;
+    else if (lux_vot >= 2480)
+        lux_level = 100;
+    else
+        lux_level = 100 * (lux_vot - 80) / T1000X_LIGHT_REF_VCC;
+
+    return lux_level;
+}
+
+float T1000xSensor::getTemp()
+{
+    uint32_t vcc_vot = 0, ntc_vot = 0;
+
+    uint8_t u8i = 0;
+    float Vout = 0, Rt = 0, temp = 0;
+    float Temp = 0;
+
+    for (uint32_t i = 0; i < T1000X_SENSE_SAMPLES; i++) {
+        vcc_vot += analogRead(T1000X_VCC_PIN);
+    }
+    vcc_vot = vcc_vot / T1000X_SENSE_SAMPLES;
+    vcc_vot = 2 * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * vcc_vot;
+
+    for (uint32_t i = 0; i < T1000X_SENSE_SAMPLES; i++) {
+        ntc_vot += analogRead(T1000X_NTC_PIN);
+    }
+    ntc_vot = ntc_vot / T1000X_SENSE_SAMPLES;
+    ntc_vot = ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * ntc_vot;
+
+    Vout = ntc_vot;
+    Rt = (HEATER_NTC_RP * vcc_vot) / Vout - HEATER_NTC_RP;
+    for (u8i = 0; u8i < 136; u8i++) {
+        if (Rt >= ntc_res2[u8i]) {
+            break;
+        }
+    }
+    temp = ntc_temp2[u8i - 1] + 1 * (ntc_res2[u8i - 1] - Rt) / (float)(ntc_res2[u8i - 1] - ntc_res2[u8i]);
+    Temp = (temp * 100 + 5) / 100; // half adjust
+
+    return Temp;
+}
+
+bool T1000xSensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.environment_metrics.temperature = getTemp();
+    measurement->variant.environment_metrics.lux = getLux();
+    return true;
+}
+
+#endif

src/modules/Telemetry/Sensor/T1000xSensor.h

@@ -0,0 +1,22 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+
+class T1000xSensor : public TelemetrySensor
+{
+  private:
+  protected:
+    virtual void setup() override;
+
+  public:
+    T1000xSensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual float getLux();
+    virtual float getTemp();
+};
+
+#endif

src/modules/WaypointModule.cpp

@@ -16,15 +16,31 @@ ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
     auto &p = mp.decoded;
     LOG_INFO("Received waypoint msg from=0x%0x, id=0x%x, msg=%.*s\n", mp.from, mp.id, p.payload.size, p.payload.bytes);
 #endif
-    UIFrameEvent e = {true, true};
     // We only store/display messages destined for us.
     // Keep a copy of the most recent text message.
     devicestate.rx_waypoint = mp;
     devicestate.has_rx_waypoint = true;
 
     powerFSM.trigger(EVENT_RECEIVED_MSG);
+
+#if HAS_SCREEN
+
+    UIFrameEvent e;
+
+    // New or updated waypoint: focus on this frame next time Screen::setFrames runs
+    if (shouldDraw()) {
+        requestFocus();
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+    }
+
+    // Deleting an old waypoint: remove the frame quietly, don't change frame position if possible
+    else
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND;
+
     notifyObservers(&e);
 
+#endif
+
     return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }
 

src/modules/esp32/AudioModule.cpp

@@ -190,13 +190,13 @@ int32_t AudioModule::runOnce()
 
             firstTime = false;
         } else {
-            UIFrameEvent e = {false, true};
+            UIFrameEvent e;
             // Check if PTT is pressed. TODO hook that into Onebutton/Interrupt drive.
             if (digitalRead(moduleConfig.audio.ptt_pin ? moduleConfig.audio.ptt_pin : PTT_PIN) == HIGH) {
                 if (radio_state == RadioState::rx) {
                     LOG_INFO("PTT pressed, switching to TX\n");
                     radio_state = RadioState::tx;
-                    e.frameChanged = true;
+                    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
                     this->notifyObservers(&e);
                 }
             } else {
@@ -209,7 +209,7 @@ int32_t AudioModule::runOnce()
                     }
                     tx_encode_frame_index = sizeof(tx_header);
                     radio_state = RadioState::rx;
-                    e.frameChanged = true;
+                    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
                     this->notifyObservers(&e);
                 }
             }

src/modules/esp32/PaxcounterModule.cpp

@@ -80,7 +80,7 @@ int32_t PaxcounterModule::runOnce()
             firstTime = false;
             LOG_DEBUG("Paxcounter starting up with interval of %d seconds\n",
                       Default::getConfiguredOrDefault(moduleConfig.paxcounter.paxcounter_update_interval,
-                                                      default_broadcast_interval_secs));
+                                                      default_telemetry_broadcast_interval_secs));
             struct libpax_config_t configuration;
             libpax_default_config(&configuration);
 
@@ -100,8 +100,8 @@ int32_t PaxcounterModule::runOnce()
         } else {
             sendInfo(NODENUM_BROADCAST);
         }
-        return Default::getConfiguredOrDefaultMs(moduleConfig.paxcounter.paxcounter_update_interval,
-                                                 default_broadcast_interval_secs);
+        return Default::getConfiguredOrDefaultMsScaled(moduleConfig.paxcounter.paxcounter_update_interval,
+                                                       default_telemetry_broadcast_interval_secs, numOnlineNodes);
     } else {
         return disable();
     }

src/modules/esp32/StoreForwardModule.cpp

@@ -35,13 +35,10 @@ int32_t StoreForwardModule::runOnce()
     if (moduleConfig.store_forward.enabled && is_server) {
         // Send out the message queue.
         if (this->busy) {
-            // Only send packets if the channel is less than 25% utilized.
-            if (airTime->isTxAllowedChannelUtil(true)) {
-                storeForwardModule->sendPayload(this->busyTo, this->packetHistoryTXQueue_index);
-                if (this->packetHistoryTXQueue_index < packetHistoryTXQueue_size - 1) {
-                    this->packetHistoryTXQueue_index++;
-                } else {
-                    this->packetHistoryTXQueue_index = 0;
+            // Only send packets if the channel is less than 25% utilized and until historyReturnMax
+            if (airTime->isTxAllowedChannelUtil(true) && this->requestCount < this->historyReturnMax) {
+                if (!storeForwardModule->sendPayload(this->busyTo, this->last_time)) {
+                    this->requestCount = 0;
                     this->busy = false;
                 }
             }
@@ -75,9 +72,6 @@ void StoreForwardModule::populatePSRAM()
     LOG_DEBUG("*** Before PSRAM initialization: heap %d/%d PSRAM %d/%d\n", memGet.getFreeHeap(), memGet.getHeapSize(),
               memGet.getFreePsram(), memGet.getPsramSize());
 
-    this->packetHistoryTXQueue =
-        static_cast<PacketHistoryStruct *>(ps_calloc(this->historyReturnMax, sizeof(PacketHistoryStruct)));
-
     /* Use a maximum of 2/3 the available PSRAM unless otherwise specified.
         Note: This needs to be done after every thing that would use PSRAM
     */
@@ -95,13 +89,15 @@ void StoreForwardModule::populatePSRAM()
 /**
  * Sends messages from the message history to the specified recipient.
  *
- * @param msAgo The number of milliseconds ago from which to start sending messages.
+ * @param sAgo The number of seconds ago from which to start sending messages.
  * @param to The recipient ID to send the messages to.
  */
-void StoreForwardModule::historySend(uint32_t msAgo, uint32_t to)
+void StoreForwardModule::historySend(uint32_t secAgo, uint32_t to)
 {
-    uint32_t lastIndex = lastRequest.find(to) != lastRequest.end() ? lastRequest[to] : 0;
-    uint32_t queueSize = storeForwardModule->historyQueueCreate(msAgo, to, &lastIndex);
+    this->last_time = getTime() < secAgo ? 0 : getTime() - secAgo;
+    uint32_t queueSize = getNumAvailablePackets(to, last_time);
+    if (queueSize > this->historyReturnMax)
+        queueSize = this->historyReturnMax;
 
     if (queueSize) {
         LOG_INFO("*** S&F - Sending %u message(s)\n", queueSize);
@@ -114,62 +110,66 @@ void StoreForwardModule::historySend(uint32_t msAgo, uint32_t to)
     sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_HISTORY;
     sf.which_variant = meshtastic_StoreAndForward_history_tag;
     sf.variant.history.history_messages = queueSize;
-    sf.variant.history.window = msAgo;
-    sf.variant.history.last_request = lastIndex;
-    lastRequest[to] = lastIndex;
+    sf.variant.history.window = secAgo * 1000;
+    sf.variant.history.last_request = lastRequest[to];
     storeForwardModule->sendMessage(to, sf);
+    setIntervalFromNow(this->packetTimeMax); // Delay start of sending payloads
 }
 
 /**
- * Creates a new history queue with messages that were received within the specified time frame.
+ * Returns the number of available packets in the message history for a specified destination node.
  *
- * @param msAgo The number of milliseconds ago to start the history queue.
- * @param to The NodeNum of the recipient.
- * @param last_request_index The index in the packet history of the last request from this node.
- * @return The ID of the newly created history queue.
+ * @param dest The destination node number.
+ * @param last_time The relative time to start counting messages from.
+ * @return The number of available packets in the message history.
  */
-uint32_t StoreForwardModule::historyQueueCreate(uint32_t msAgo, uint32_t to, uint32_t *last_request_index)
+uint32_t StoreForwardModule::getNumAvailablePackets(NodeNum dest, uint32_t last_time)
 {
-
-    this->packetHistoryTXQueue_size = 0;
-    // If our history was cleared, ignore the last request index
-    uint32_t last_index = *last_request_index > this->packetHistoryCurrent ? 0 : *last_request_index;
-
-    for (uint32_t i = last_index; i < this->packetHistoryCurrent; i++) {
-        /*
-            LOG_DEBUG("SF historyQueueCreate\n");
-            LOG_DEBUG("SF historyQueueCreate - time %d\n", this->packetHistory[i].time);
-            LOG_DEBUG("SF historyQueueCreate - millis %d\n", millis());
-            LOG_DEBUG("SF historyQueueCreate - math %d\n", (millis() - msAgo));
-        */
-        if (this->packetHistoryTXQueue_size < this->historyReturnMax) {
-            if (this->packetHistory[i].time && (this->packetHistory[i].time < (millis() - msAgo))) {
-                /*  Copy the messages that were received by the router in the last msAgo
-                    to the packetHistoryTXQueue structure.
-                    Client not interested in packets from itself and only in broadcast packets or packets towards it. */
-                if (this->packetHistory[i].from != to &&
-                    (this->packetHistory[i].to == NODENUM_BROADCAST || this->packetHistory[i].to == to)) {
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].time = this->packetHistory[i].time;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].to = this->packetHistory[i].to;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].from = this->packetHistory[i].from;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].channel = this->packetHistory[i].channel;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload_size =
-                        this->packetHistory[i].payload_size;
-                    memcpy(this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload, this->packetHistory[i].payload,
-                           meshtastic_Constants_DATA_PAYLOAD_LEN);
-                    this->packetHistoryTXQueue_size++;
-                    *last_request_index = i + 1; // Set to one higher such that we don't send the same message again
-
-                    LOG_DEBUG("*** PacketHistoryStruct time=%d, msg=%s\n", this->packetHistory[i].time,
-                              this->packetHistory[i].payload);
-                }
+    uint32_t count = 0;
+    if (lastRequest.find(dest) == lastRequest.end()) {
+        lastRequest[dest] = 0;
+    }
+    for (uint32_t i = lastRequest[dest]; i < this->packetHistoryTotalCount; i++) {
+        if (this->packetHistory[i].time && (this->packetHistory[i].time > last_time)) {
+            // Client is only interested in packets not from itself and only in broadcast packets or packets towards it.
+            if (this->packetHistory[i].from != dest &&
+                (this->packetHistory[i].to == NODENUM_BROADCAST || this->packetHistory[i].to == dest)) {
+                count++;
             }
-        } else {
-            LOG_WARN("*** S&F - Maximum history return reached.\n");
-            return this->packetHistoryTXQueue_size;
         }
     }
-    return this->packetHistoryTXQueue_size;
+    return count;
+}
+
+/**
+ * Allocates a mesh packet for sending to the phone.
+ *
+ * @return A pointer to the allocated mesh packet or nullptr if none is available.
+ */
+meshtastic_MeshPacket *StoreForwardModule::getForPhone()
+{
+    if (moduleConfig.store_forward.enabled && is_server) {
+        NodeNum to = nodeDB->getNodeNum();
+        if (!this->busy) {
+            // Get number of packets we're going to send in this loop
+            uint32_t histSize = getNumAvailablePackets(to, 0); // No time limit
+            if (histSize) {
+                this->busy = true;
+                this->busyTo = to;
+            } else {
+                return nullptr;
+            }
+        }
+
+        // We're busy with sending to us until no payload is available anymore
+        if (this->busy && this->busyTo == to) {
+            meshtastic_MeshPacket *p = preparePayload(to, 0, true); // No time limit
+            if (!p)                                                 // No more messages to send
+                this->busy = false;
+            return p;
+        }
+    }
+    return nullptr;
 }
 
 /**
@@ -181,66 +181,97 @@ void StoreForwardModule::historyAdd(const meshtastic_MeshPacket &mp)
 {
     const auto &p = mp.decoded;
 
-    if (this->packetHistoryCurrent == this->records) {
+    if (this->packetHistoryTotalCount == this->records) {
         LOG_WARN("*** S&F - PSRAM Full. Starting overwrite now.\n");
-        this->packetHistoryCurrent = 0;
-        this->packetHistoryMax = 0;
+        this->packetHistoryTotalCount = 0;
         for (auto &i : lastRequest) {
             i.second = 0; // Clear the last request index for each client device
         }
     }
 
-    this->packetHistory[this->packetHistoryCurrent].time = millis();
-    this->packetHistory[this->packetHistoryCurrent].to = mp.to;
-    this->packetHistory[this->packetHistoryCurrent].channel = mp.channel;
-    this->packetHistory[this->packetHistoryCurrent].from = mp.from;
-    this->packetHistory[this->packetHistoryCurrent].payload_size = p.payload.size;
-    memcpy(this->packetHistory[this->packetHistoryCurrent].payload, p.payload.bytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
+    this->packetHistory[this->packetHistoryTotalCount].time = getTime();
+    this->packetHistory[this->packetHistoryTotalCount].to = mp.to;
+    this->packetHistory[this->packetHistoryTotalCount].channel = mp.channel;
+    this->packetHistory[this->packetHistoryTotalCount].from = getFrom(&mp);
+    this->packetHistory[this->packetHistoryTotalCount].payload_size = p.payload.size;
+    memcpy(this->packetHistory[this->packetHistoryTotalCount].payload, p.payload.bytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
 
-    this->packetHistoryCurrent++;
-    this->packetHistoryMax++;
-}
-
-meshtastic_MeshPacket *StoreForwardModule::allocReply()
-{
-    auto reply = allocDataPacket(); // Allocate a packet for sending
-    return reply;
+    this->packetHistoryTotalCount++;
 }
 
 /**
  * Sends a payload to a specified destination node using the store and forward mechanism.
  *
  * @param dest The destination node number.
- * @param packetHistory_index The index of the packet in the packet history buffer.
+ * @param last_time The relative time to start sending messages from.
+ * @return True if a packet was successfully sent, false otherwise.
  */
-void StoreForwardModule::sendPayload(NodeNum dest, uint32_t packetHistory_index)
+bool StoreForwardModule::sendPayload(NodeNum dest, uint32_t last_time)
 {
-    LOG_INFO("*** Sending S&F Payload\n");
-    meshtastic_MeshPacket *p = allocReply();
-
-    p->to = dest;
-    p->from = this->packetHistoryTXQueue[packetHistory_index].from;
-    p->channel = this->packetHistoryTXQueue[packetHistory_index].channel;
-
-    // Let's assume that if the router received the S&F request that the client is in range.
-    //   TODO: Make this configurable.
-    p->want_ack = false;
-
-    meshtastic_StoreAndForward sf = meshtastic_StoreAndForward_init_zero;
-    sf.which_variant = meshtastic_StoreAndForward_text_tag;
-    sf.variant.text.size = this->packetHistoryTXQueue[packetHistory_index].payload_size;
-    memcpy(sf.variant.text.bytes, this->packetHistoryTXQueue[packetHistory_index].payload,
-           this->packetHistoryTXQueue[packetHistory_index].payload_size);
-    if (this->packetHistoryTXQueue[packetHistory_index].to == NODENUM_BROADCAST) {
-        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_BROADCAST;
-    } else {
-        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_DIRECT;
+    meshtastic_MeshPacket *p = preparePayload(dest, last_time);
+    if (p) {
+        LOG_INFO("*** Sending S&F Payload\n");
+        service.sendToMesh(p);
+        this->requestCount++;
+        return true;
     }
+    return false;
+}
 
-    p->decoded.payload.size =
-        pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_StoreAndForward_msg, &sf);
+/**
+ * Prepares a payload to be sent to a specified destination node from the S&F packet history.
+ *
+ * @param dest The destination node number.
+ * @param last_time The relative time to start sending messages from.
+ * @return A pointer to the prepared mesh packet or nullptr if none is available.
+ */
+meshtastic_MeshPacket *StoreForwardModule::preparePayload(NodeNum dest, uint32_t last_time, bool local)
+{
+    for (uint32_t i = lastRequest[dest]; i < this->packetHistoryTotalCount; i++) {
+        if (this->packetHistory[i].time && (this->packetHistory[i].time > last_time)) {
+            /*  Copy the messages that were received by the server in the last msAgo
+                to the packetHistoryTXQueue structure.
+                Client not interested in packets from itself and only in broadcast packets or packets towards it. */
+            if (this->packetHistory[i].from != dest &&
+                (this->packetHistory[i].to == NODENUM_BROADCAST || this->packetHistory[i].to == dest)) {
 
-    service.sendToMesh(p);
+                meshtastic_MeshPacket *p = allocDataPacket();
+
+                p->to = local ? this->packetHistory[i].to : dest; // PhoneAPI can handle original `to`
+                p->from = this->packetHistory[i].from;
+                p->channel = this->packetHistory[i].channel;
+                p->rx_time = this->packetHistory[i].time;
+
+                // Let's assume that if the server received the S&F request that the client is in range.
+                //   TODO: Make this configurable.
+                p->want_ack = false;
+
+                if (local) { // PhoneAPI gets normal TEXT_MESSAGE_APP
+                    p->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
+                    memcpy(p->decoded.payload.bytes, this->packetHistory[i].payload, this->packetHistory[i].payload_size);
+                    p->decoded.payload.size = this->packetHistory[i].payload_size;
+                } else {
+                    meshtastic_StoreAndForward sf = meshtastic_StoreAndForward_init_zero;
+                    sf.which_variant = meshtastic_StoreAndForward_text_tag;
+                    sf.variant.text.size = this->packetHistory[i].payload_size;
+                    memcpy(sf.variant.text.bytes, this->packetHistory[i].payload, this->packetHistory[i].payload_size);
+                    if (this->packetHistory[i].to == NODENUM_BROADCAST) {
+                        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_BROADCAST;
+                    } else {
+                        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_DIRECT;
+                    }
+
+                    p->decoded.payload.size = pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes),
+                                                                 &meshtastic_StoreAndForward_msg, &sf);
+                }
+
+                lastRequest[dest] = i + 1; // Update the last request index for the client device
+
+                return p;
+            }
+        }
+    }
+    return nullptr;
 }
 
 /**
@@ -257,11 +288,7 @@ void StoreForwardModule::sendMessage(NodeNum dest, const meshtastic_StoreAndForw
 
     p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
 
-    // FIXME - Determine if the delayed packet is broadcast or delayed. For now, assume
-    //  everything is broadcast.
-    p->delayed = meshtastic_MeshPacket_Delayed_DELAYED_BROADCAST;
-
-    // Let's assume that if the router received the S&F request that the client is in range.
+    // Let's assume that if the server received the S&F request that the client is in range.
     //   TODO: Make this configurable.
     p->want_ack = false;
     p->decoded.want_response = false;
@@ -283,6 +310,35 @@ void StoreForwardModule::sendMessage(NodeNum dest, meshtastic_StoreAndForward_Re
     storeForwardModule->sendMessage(dest, sf);
 }
 
+/**
+ * Sends a text message with an error (busy or channel not available) to the specified destination node.
+ *
+ * @param dest The destination node number.
+ * @param want_response True if the original message requested a response, false otherwise.
+ */
+void StoreForwardModule::sendErrorTextMessage(NodeNum dest, bool want_response)
+{
+    meshtastic_MeshPacket *pr = allocDataPacket();
+    pr->to = dest;
+    pr->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+    pr->want_ack = false;
+    pr->decoded.want_response = false;
+    pr->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
+    const char *str;
+    if (this->busy) {
+        str = "** S&F - Busy. Try again shortly.";
+    } else {
+        str = "** S&F - Not available on this channel.";
+    }
+    LOG_WARN("%s\n", str);
+    memcpy(pr->decoded.payload.bytes, str, strlen(str));
+    pr->decoded.payload.size = strlen(str);
+    if (want_response) {
+        ignoreRequest = true; // This text message counts as response.
+    }
+    service.sendToMesh(pr);
+}
+
 /**
  * Sends statistics about the store and forward module to the specified node.
  *
@@ -294,8 +350,8 @@ void StoreForwardModule::statsSend(uint32_t to)
 
     sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_STATS;
     sf.which_variant = meshtastic_StoreAndForward_stats_tag;
-    sf.variant.stats.messages_total = this->packetHistoryMax;
-    sf.variant.stats.messages_saved = this->packetHistoryCurrent;
+    sf.variant.stats.messages_total = this->records;
+    sf.variant.stats.messages_saved = this->packetHistoryTotalCount;
     sf.variant.stats.messages_max = this->records;
     sf.variant.stats.up_time = millis() / 1000;
     sf.variant.stats.requests = this->requests;
@@ -319,51 +375,37 @@ ProcessMessage StoreForwardModule::handleReceived(const meshtastic_MeshPacket &m
 #ifdef ARCH_ESP32
     if (moduleConfig.store_forward.enabled) {
 
-        // The router node should not be sending messages as a client
-        if ((getFrom(&mp) != nodeDB->getNodeNum())) {
+        if ((mp.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) && is_server) {
+            auto &p = mp.decoded;
+            if (mp.to == nodeDB->getNodeNum() && (p.payload.bytes[0] == 'S') && (p.payload.bytes[1] == 'F') &&
+                (p.payload.bytes[2] == 0x00)) {
+                LOG_DEBUG("*** Legacy Request to send\n");
 
-            if ((mp.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) && is_server) {
-                auto &p = mp.decoded;
-                if (mp.to == nodeDB->getNodeNum() && (p.payload.bytes[0] == 'S') && (p.payload.bytes[1] == 'F') &&
-                    (p.payload.bytes[2] == 0x00)) {
-                    LOG_DEBUG("*** Legacy Request to send\n");
-
-                    // Send the last 60 minutes of messages.
-                    if (this->busy) {
-                        storeForwardModule->sendMessage(getFrom(&mp), meshtastic_StoreAndForward_RequestResponse_ROUTER_BUSY);
-                        LOG_INFO("*** S&F - Busy. Try again shortly.\n");
-                        meshtastic_MeshPacket *pr = allocReply();
-                        pr->to = getFrom(&mp);
-                        pr->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
-                        pr->want_ack = false;
-                        pr->decoded.want_response = false;
-                        pr->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
-                        memcpy(pr->decoded.payload.bytes, "** S&F - Busy. Try again shortly.", 34);
-                        pr->decoded.payload.size = 34;
-                        service.sendToMesh(pr);
-                    } else {
-                        storeForwardModule->historySend(historyReturnWindow * 60000, getFrom(&mp));
-                    }
+                // Send the last 60 minutes of messages.
+                if (this->busy || channels.isDefaultChannel(channels.getByIndex(mp.channel))) {
+                    sendErrorTextMessage(getFrom(&mp), mp.decoded.want_response);
                 } else {
-                    storeForwardModule->historyAdd(mp);
-                    LOG_INFO("*** S&F stored. Message history contains %u records now.\n", this->packetHistoryCurrent);
+                    storeForwardModule->historySend(historyReturnWindow * 60, getFrom(&mp));
                 }
-            } else if (mp.decoded.portnum == meshtastic_PortNum_STORE_FORWARD_APP) {
-                auto &p = mp.decoded;
-                meshtastic_StoreAndForward scratch;
-                meshtastic_StoreAndForward *decoded = NULL;
-                if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
-                    if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_StoreAndForward_msg, &scratch)) {
-                        decoded = &scratch;
-                    } else {
-                        LOG_ERROR("Error decoding protobuf module!\n");
-                        // if we can't decode it, nobody can process it!
-                        return ProcessMessage::STOP;
-                    }
-                    return handleReceivedProtobuf(mp, decoded) ? ProcessMessage::STOP : ProcessMessage::CONTINUE;
+            } else {
+                storeForwardModule->historyAdd(mp);
+                LOG_INFO("*** S&F stored. Message history contains %u records now.\n", this->packetHistoryTotalCount);
+            }
+        } else if (getFrom(&mp) != nodeDB->getNodeNum() && mp.decoded.portnum == meshtastic_PortNum_STORE_FORWARD_APP) {
+            auto &p = mp.decoded;
+            meshtastic_StoreAndForward scratch;
+            meshtastic_StoreAndForward *decoded = NULL;
+            if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+                if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_StoreAndForward_msg, &scratch)) {
+                    decoded = &scratch;
+                } else {
+                    LOG_ERROR("Error decoding protobuf module!\n");
+                    // if we can't decode it, nobody can process it!
+                    return ProcessMessage::STOP;
                 }
-            } // all others are irrelevant
-        }
+                return handleReceivedProtobuf(mp, decoded) ? ProcessMessage::STOP : ProcessMessage::CONTINUE;
+            }
+        } // all others are irrelevant
     }
 
 #endif
@@ -394,7 +436,7 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
             // stop sending stuff, the client wants to abort or has another error
             if ((this->busy) && (this->busyTo == getFrom(&mp))) {
                 LOG_ERROR("*** Client in ERROR or ABORT requested\n");
-                this->packetHistoryTXQueue_index = 0;
+                this->requestCount = 0;
                 this->busy = false;
             }
         }
@@ -405,15 +447,14 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
             requests_history++;
             LOG_INFO("*** Client Request to send HISTORY\n");
             // Send the last 60 minutes of messages.
-            if (this->busy) {
-                storeForwardModule->sendMessage(getFrom(&mp), meshtastic_StoreAndForward_RequestResponse_ROUTER_BUSY);
-                LOG_INFO("*** S&F - Busy. Try again shortly.\n");
+            if (this->busy || channels.isDefaultChannel(channels.getByIndex(mp.channel))) {
+                sendErrorTextMessage(getFrom(&mp), mp.decoded.want_response);
             } else {
                 if ((p->which_variant == meshtastic_StoreAndForward_history_tag) && (p->variant.history.window > 0)) {
                     // window is in minutes
-                    storeForwardModule->historySend(p->variant.history.window * 60000, getFrom(&mp));
+                    storeForwardModule->historySend(p->variant.history.window * 60, getFrom(&mp));
                 } else {
-                    storeForwardModule->historySend(historyReturnWindow * 60000, getFrom(&mp)); // defaults to 4 hours
+                    storeForwardModule->historySend(historyReturnWindow * 60, getFrom(&mp)); // defaults to 4 hours
                 }
             }
         }
@@ -451,7 +492,7 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
         if (is_client) {
             LOG_DEBUG("*** StoreAndForward_RequestResponse_ROUTER_BUSY\n");
             // retry in messages_saved * packetTimeMax ms
-            retry_delay = millis() + packetHistoryCurrent * packetTimeMax *
+            retry_delay = millis() + getNumAvailablePackets(this->busyTo, this->last_time) * packetTimeMax *
                                          (meshtastic_StoreAndForward_RequestResponse_ROUTER_ERROR ? 2 : 1);
         }
         break;
@@ -482,8 +523,6 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
             LOG_DEBUG("*** Router Response STATS\n");
             // These fields only have informational purpose on a client. Fill them to consume later.
             if (p->which_variant == meshtastic_StoreAndForward_stats_tag) {
-                this->packetHistoryMax = p->variant.stats.messages_total;
-                this->packetHistoryCurrent = p->variant.stats.messages_saved;
                 this->records = p->variant.stats.messages_max;
                 this->requests = p->variant.stats.requests;
                 this->requests_history = p->variant.stats.requests_history;
@@ -508,7 +547,7 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
     default:
         break; // no need to do anything
     }
-    return true; // There's no need for others to look at this message.
+    return false; // RoutingModule sends it to the phone
 }
 
 StoreForwardModule::StoreForwardModule()
@@ -532,9 +571,8 @@ StoreForwardModule::StoreForwardModule()
     if (moduleConfig.store_forward.enabled) {
 
         // Router
-        if ((config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER) ||
-            (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT)) {
-            LOG_INFO("*** Initializing Store & Forward Module in Router mode\n");
+        if ((config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER || moduleConfig.store_forward.is_server)) {
+            LOG_INFO("*** Initializing Store & Forward Module in Server mode\n");
             if (memGet.getPsramSize() > 0) {
                 if (memGet.getFreePsram() >= 1024 * 1024) {
 

src/modules/esp32/StoreForwardModule.h

@@ -25,12 +25,9 @@ class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<
     char routerMessage[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
 
     PacketHistoryStruct *packetHistory = 0;
-    uint32_t packetHistoryCurrent = 0;
-    uint32_t packetHistoryMax = 0;
-
-    PacketHistoryStruct *packetHistoryTXQueue = 0;
-    uint32_t packetHistoryTXQueue_size = 0;
-    uint32_t packetHistoryTXQueue_index = 0;
+    uint32_t packetHistoryTotalCount = 0;
+    uint32_t last_time = 0;
+    uint32_t requestCount = 0;
 
     uint32_t packetTimeMax = 5000; // Interval between sending history packets as a server.
 
@@ -52,18 +49,21 @@ class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<
      */
     void historyAdd(const meshtastic_MeshPacket &mp);
     void statsSend(uint32_t to);
-    void historySend(uint32_t msAgo, uint32_t to);
-
-    uint32_t historyQueueCreate(uint32_t msAgo, uint32_t to, uint32_t *last_request_index);
+    void historySend(uint32_t secAgo, uint32_t to);
+    uint32_t getNumAvailablePackets(NodeNum dest, uint32_t last_time);
 
     /**
      * Send our payload into the mesh
      */
-    void sendPayload(NodeNum dest = NODENUM_BROADCAST, uint32_t packetHistory_index = 0);
+    bool sendPayload(NodeNum dest = NODENUM_BROADCAST, uint32_t packetHistory_index = 0);
+    meshtastic_MeshPacket *preparePayload(NodeNum dest, uint32_t packetHistory_index, bool local = false);
     void sendMessage(NodeNum dest, const meshtastic_StoreAndForward &payload);
     void sendMessage(NodeNum dest, meshtastic_StoreAndForward_RequestResponse rr);
+    void sendErrorTextMessage(NodeNum dest, bool want_response);
+    meshtastic_MeshPacket *getForPhone();
+    // Returns true if we are configured as server AND we could allocate PSRAM.
+    bool isServer() { return is_server; }
 
-    virtual meshtastic_MeshPacket *allocReply() override;
     /*
       -Override the wantPacket method.
     */

src/mqtt/MQTT.cpp

@@ -135,6 +135,10 @@ void MQTT::onReceive(char *topic, byte *payload, size_t length)
             LOG_ERROR("Invalid MQTT service envelope, topic %s, len %u!\n", topic, length);
             return;
         } else {
+            if (e.channel_id == NULL || e.gateway_id == NULL) {
+                LOG_ERROR("Invalid MQTT service envelope, topic %s, len %u!\n", topic, length);
+                return;
+            }
             meshtastic_Channel ch = channels.getByName(e.channel_id);
             if (strcmp(e.gateway_id, owner.id) == 0) {
                 // Generate an implicit ACK towards ourselves (handled and processed only locally!) for this message.
@@ -188,12 +192,10 @@ MQTT::MQTT() : concurrency::OSThread("mqtt"), mqttQueue(MAX_MQTT_QUEUE)
         mqtt = this;
 
         if (*moduleConfig.mqtt.root) {
-            statusTopic = moduleConfig.mqtt.root + statusTopic;
             cryptTopic = moduleConfig.mqtt.root + cryptTopic;
             jsonTopic = moduleConfig.mqtt.root + jsonTopic;
             mapTopic = moduleConfig.mqtt.root + mapTopic;
         } else {
-            statusTopic = "msh" + statusTopic;
             cryptTopic = "msh" + cryptTopic;
             jsonTopic = "msh" + jsonTopic;
             mapTopic = "msh" + mapTopic;
@@ -216,7 +218,7 @@ MQTT::MQTT() : concurrency::OSThread("mqtt"), mqttQueue(MAX_MQTT_QUEUE)
             enabled = true;
             runASAP = true;
             reconnectCount = 0;
-            publishStatus();
+            publishNodeInfo();
         }
         // preflightSleepObserver.observe(&preflightSleep);
     } else {
@@ -281,7 +283,7 @@ void MQTT::reconnect()
             runASAP = true;
             reconnectCount = 0;
 
-            publishStatus();
+            publishNodeInfo();
             return; // Don't try to connect directly to the server
         }
 #if HAS_NETWORKING
@@ -330,15 +332,14 @@ void MQTT::reconnect()
         LOG_INFO("Attempting to connect directly to MQTT server %s, port: %d, username: %s, password: %s\n", serverAddr,
                  serverPort, mqttUsername, mqttPassword);
 
-        auto myStatus = (statusTopic + owner.id);
-        bool connected = pubSub.connect(owner.id, mqttUsername, mqttPassword, myStatus.c_str(), 1, true, "offline");
+        bool connected = pubSub.connect(owner.id, mqttUsername, mqttPassword);
         if (connected) {
             LOG_INFO("MQTT connected\n");
             enabled = true; // Start running background process again
             runASAP = true;
             reconnectCount = 0;
 
-            publishStatus();
+            publishNodeInfo();
             sendSubscriptions();
         } else {
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
@@ -437,14 +438,10 @@ int32_t MQTT::runOnce()
     return 30000;
 }
 
-/// FIXME, include more information in the status text
-void MQTT::publishStatus()
+void MQTT::publishNodeInfo()
 {
-    auto myStatus = (statusTopic + owner.id);
-    bool ok = publish(myStatus.c_str(), "online", true);
-    LOG_INFO("published online=%d\n", ok);
+    // TODO: NodeInfo broadcast over MQTT only (NODENUM_BROADCAST_NO_LORA)
 }
-
 void MQTT::publishQueuedMessages()
 {
     if (!mqttQueue.isEmpty()) {
@@ -680,8 +677,10 @@ std::string MQTT::meshPacketToJson(meshtastic_MeshPacket *mp)
                     msgPayload["lux"] = new JSONValue(decoded->variant.environment_metrics.lux);
                     msgPayload["white_lux"] = new JSONValue(decoded->variant.environment_metrics.white_lux);
                     msgPayload["iaq"] = new JSONValue((uint)decoded->variant.environment_metrics.iaq);
-                    msgPayload["wind_speed"] = new JSONValue((uint)decoded->variant.environment_metrics.wind_speed);
+                    msgPayload["wind_speed"] = new JSONValue(decoded->variant.environment_metrics.wind_speed);
                     msgPayload["wind_direction"] = new JSONValue((uint)decoded->variant.environment_metrics.wind_direction);
+                    msgPayload["wind_gust"] = new JSONValue(decoded->variant.environment_metrics.wind_gust);
+                    msgPayload["wind_lull"] = new JSONValue(decoded->variant.environment_metrics.wind_lull);
                 } else if (decoded->which_variant == meshtastic_Telemetry_power_metrics_tag) {
                     msgPayload["voltage_ch1"] = new JSONValue(decoded->variant.power_metrics.ch1_voltage);
                     msgPayload["current_ch1"] = new JSONValue(decoded->variant.power_metrics.ch1_current);

src/mqtt/MQTT.h

@@ -81,10 +81,9 @@ class MQTT : private concurrency::OSThread
     virtual int32_t runOnce() override;
 
   private:
-    std::string statusTopic = "/2/stat/"; // For "online"/"offline" message
-    std::string cryptTopic = "/2/e/";     // msh/2/e/CHANNELID/NODEID
-    std::string jsonTopic = "/2/json/";   // msh/2/json/CHANNELID/NODEID
-    std::string mapTopic = "/2/map/";     // For protobuf-encoded MapReport messages
+    std::string cryptTopic = "/2/e/";   // msh/2/e/CHANNELID/NODEID
+    std::string jsonTopic = "/2/json/"; // msh/2/json/CHANNELID/NODEID
+    std::string mapTopic = "/2/map/";   // For protobuf-encoded MapReport messages
 
     // For map reporting (only applies when enabled)
     const uint32_t default_map_position_precision = 14;         // defaults to max. offset of ~1459m
@@ -110,9 +109,10 @@ class MQTT : private concurrency::OSThread
     /// Called when a new publish arrives from the MQTT server
     std::string meshPacketToJson(meshtastic_MeshPacket *mp);
 
-    void publishStatus();
     void publishQueuedMessages();
 
+    void publishNodeInfo();
+
     // Check if we should report unencrypted information about our node for consumption by a map
     void perhapsReportToMap();
 

src/platform/esp32/architecture.h

@@ -151,6 +151,14 @@
 #define HW_VENDOR meshtastic_HardwareModel_RADIOMASTER_900_BANDIT_NANO
 #elif defined(HELTEC_CAPSULE_SENSOR_V3)
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_CAPSULE_SENSOR_V3
+#elif defined(HELTEC_VISION_MASTER_T190)
+#define HW_VENDOR meshtastic_HardwareModel_HELTEC_VISION_MASTER_T190
+#elif defined(HELTEC_VISION_MASTER_E213)
+#define HW_VENDOR meshtastic_HardwareModel_HELTEC_VISION_MASTER_E213
+#elif defined(HELTEC_VISION_MASTER_E290)
+#define HW_VENDOR meshtastic_HardwareModel_HELTEC_VISION_MASTER_E290
+#elif defined(HELTEC_MESH_NODE_T114)
+#define HW_VENDOR meshtastic_HardwareModel_HELTEC_MESH_NODE_T114
 #endif
 
 // -----------------------------------------------------------------------------

src/platform/esp32/main-esp32.cpp

@@ -91,8 +91,12 @@ void enableSlowCLK()
 
 void esp32Setup()
 {
+    /* We explicitly don't want to do call randomSeed,
+    // as that triggers the esp32 core to use a less secure pseudorandom function.
     uint32_t seed = esp_random();
     LOG_DEBUG("Setting random seed %u\n", seed);
+    randomSeed(seed);
+    */
 
     LOG_DEBUG("Total heap: %d\n", ESP.getHeapSize());
     LOG_DEBUG("Free heap: %d\n", ESP.getFreeHeap());

src/platform/nrf52/BLEDfuScure.cpp

@@ -0,0 +1,144 @@
+/**************************************************************************/
+/*!
+    @file     BLEDfu.cpp
+    @author   hathach (tinyusb.org)
+
+    @section LICENSE
+
+    Software License Agreement (BSD License)
+
+    Copyright (c) 2018, Adafruit Industries (adafruit.com)
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+    1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holders nor the
+    names of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/**************************************************************************/
+
+#include "BLEDfuSecure.h"
+#include "bluefruit.h"
+
+#define DFU_REV_APPMODE 0x0001
+
+const uint16_t UUID16_SVC_DFU_OTA = 0xFE59;
+
+const uint8_t UUID128_CHR_DFU_CONTROL[16] = {0x50, 0xEA, 0xDA, 0x30, 0x88, 0x83, 0xB8, 0x9F,
+                                             0x60, 0x4F, 0x15, 0xF3, 0x03, 0x00, 0xC9, 0x8E};
+
+extern "C" void bootloader_util_app_start(uint32_t start_addr);
+
+static uint16_t crc16(const uint8_t *data_p, uint8_t length)
+{
+    uint8_t x;
+    uint16_t crc = 0xFFFF;
+
+    while (length--) {
+        x = crc >> 8 ^ *data_p++;
+        x ^= x >> 4;
+        crc = (crc << 8) ^ ((uint16_t)(x << 12)) ^ ((uint16_t)(x << 5)) ^ ((uint16_t)x);
+    }
+    return crc;
+}
+
+static void bledfu_control_wr_authorize_cb(uint16_t conn_hdl, BLECharacteristic *chr, ble_gatts_evt_write_t *request)
+{
+    if ((request->handle == chr->handles().value_handle) && (request->op != BLE_GATTS_OP_PREP_WRITE_REQ) &&
+        (request->op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) && (request->op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)) {
+        BLEConnection *conn = Bluefruit.Connection(conn_hdl);
+
+        ble_gatts_rw_authorize_reply_params_t reply = {.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE};
+
+        if (!chr->indicateEnabled(conn_hdl)) {
+            reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_CPS_CCCD_CONFIG_ERROR;
+            sd_ble_gatts_rw_authorize_reply(conn_hdl, &reply);
+            return;
+        }
+
+        reply.params.write.gatt_status = BLE_GATT_STATUS_SUCCESS;
+        sd_ble_gatts_rw_authorize_reply(conn_hdl, &reply);
+
+        enum { START_DFU = 1 };
+        if (request->data[0] == START_DFU) {
+            // Peer data information so that bootloader could re-connect after reboot
+            typedef struct {
+                ble_gap_addr_t addr;
+                ble_gap_irk_t irk;
+                ble_gap_enc_key_t enc_key;
+                uint8_t sys_attr[8];
+                uint16_t crc16;
+            } peer_data_t;
+
+            VERIFY_STATIC(offsetof(peer_data_t, crc16) == 60);
+
+            /* Save Peer data
+             * Peer data address is defined in bootloader linker @0x20007F80
+             * - If bonded : save Security information
+             * - Otherwise : save Address for direct advertising
+             *
+             * TODO may force bonded only for security reason
+             */
+            peer_data_t *peer_data = (peer_data_t *)(0x20007F80UL);
+            varclr(peer_data);
+
+            // Get CCCD
+            uint16_t sysattr_len = sizeof(peer_data->sys_attr);
+            sd_ble_gatts_sys_attr_get(conn_hdl, peer_data->sys_attr, &sysattr_len, BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS);
+
+            // Get Bond Data or using Address if not bonded
+            peer_data->addr = conn->getPeerAddr();
+
+            if (conn->secured()) {
+                bond_keys_t bkeys;
+                if (conn->loadBondKey(&bkeys)) {
+                    peer_data->addr = bkeys.peer_id.id_addr_info;
+                    peer_data->irk = bkeys.peer_id.id_info;
+                    peer_data->enc_key = bkeys.own_enc;
+                }
+            }
+
+            // Calculate crc
+            peer_data->crc16 = crc16((uint8_t *)peer_data, offsetof(peer_data_t, crc16));
+
+            // Initiate DFU Sequence and reboot into DFU OTA mode
+            Bluefruit.Advertising.restartOnDisconnect(false);
+            conn->disconnect();
+
+            NRF_POWER->GPREGRET = 0xB1;
+            NVIC_SystemReset();
+        }
+    }
+}
+
+BLEDfuSecure::BLEDfuSecure(void) : BLEService(UUID16_SVC_DFU_OTA), _chr_control(UUID128_CHR_DFU_CONTROL) {}
+
+err_t BLEDfuSecure::begin(void)
+{
+    // Invoke base class begin()
+    VERIFY_STATUS(BLEService::begin());
+
+    _chr_control.setProperties(CHR_PROPS_WRITE | CHR_PROPS_INDICATE);
+    _chr_control.setMaxLen(23);
+    _chr_control.setWriteAuthorizeCallback(bledfu_control_wr_authorize_cb);
+    VERIFY_STATUS(_chr_control.begin());
+
+    return ERROR_NONE;
+}

src/platform/nrf52/BLEDfuSecure.h

@@ -0,0 +1,55 @@
+/**************************************************************************/
+/*!
+    @file     BLEDfu.h
+    @author   hathach (tinyusb.org)
+
+    @section LICENSE
+
+    Software License Agreement (BSD License)
+
+    Copyright (c) 2018, Adafruit Industries (adafruit.com)
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+    1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holders nor the
+    names of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/**************************************************************************/
+#ifndef BLEDFUSECURE_H_
+#define BLEDFUSECURE_H_
+
+#include "bluefruit_common.h"
+
+#include "BLECharacteristic.h"
+#include "BLEService.h"
+
+class BLEDfuSecure : public BLEService
+{
+  protected:
+    BLECharacteristic _chr_control;
+
+  public:
+    BLEDfuSecure(void);
+
+    virtual err_t begin(void);
+};
+
+#endif /* BLEDFUSECURE_H_ */

src/platform/nrf52/NRF52Bluetooth.cpp

@@ -1,4 +1,5 @@
 #include "NRF52Bluetooth.h"
+#include "BLEDfuSecure.h"
 #include "BluetoothCommon.h"
 #include "PowerFSM.h"
 #include "configuration.h"
@@ -15,8 +16,12 @@ static BLECharacteristic logRadio = BLECharacteristic(BLEUuid(LOGRADIO_UUID_16))
 
 static BLEDis bledis; // DIS (Device Information Service) helper class instance
 static BLEBas blebas; // BAS (Battery Service) helper class instance
-
+#ifndef BLE_DFU_SECURE
 static BLEDfu bledfu; // DFU software update helper service
+#else
+static BLEDfuSecure bledfusecure;                                             // DFU software update helper service
+#endif
+
 // This scratch buffer is used for various bluetooth reads/writes - but it is safe because only one bt operation can be in
 // process at once
 // static uint8_t trBytes[_max(_max(_max(_max(ToRadio_size, RadioConfig_size), User_size), MyNodeInfo_size), FromRadio_size)];
@@ -247,8 +252,13 @@ void NRF52Bluetooth::setup()
     // Set the connect/disconnect callback handlers
     Bluefruit.Periph.setConnectCallback(onConnect);
     Bluefruit.Periph.setDisconnectCallback(onDisconnect);
+#ifndef BLE_DFU_SECURE
     bledfu.setPermission(SECMODE_ENC_WITH_MITM, SECMODE_ENC_WITH_MITM);
     bledfu.begin(); // Install the DFU helper
+#else
+    bledfusecure.setPermission(SECMODE_ENC_WITH_MITM, SECMODE_ENC_WITH_MITM); // add by WayenWeng
+    bledfusecure.begin();                                                     // Install the DFU helper
+#endif
     // Configure and Start the Device Information Service
     LOG_INFO("Configuring the Device Information Service\n");
     bledis.setModel(optstr(HW_VERSION));

src/platform/nrf52/main-nrf52.cpp

@@ -234,6 +234,18 @@ void cpuDeepSleep(uint32_t msecToWake)
     // RAK-12039 set pin for Air quality sensor
     digitalWrite(AQ_SET_PIN, LOW);
 #endif
+#ifdef RAK14014
+    // GPIO restores input status, otherwise there will be leakage current
+    nrf_gpio_cfg_default(TFT_BL);
+    nrf_gpio_cfg_default(TFT_DC);
+    nrf_gpio_cfg_default(TFT_CS);
+    nrf_gpio_cfg_default(TFT_SCLK);
+    nrf_gpio_cfg_default(TFT_MOSI);
+    nrf_gpio_cfg_default(TFT_MISO);
+    nrf_gpio_cfg_default(SCREEN_TOUCH_INT);
+    nrf_gpio_cfg_default(WB_I2C1_SCL);
+    nrf_gpio_cfg_default(WB_I2C1_SDA);
+#endif
 #endif
     // Sleepy trackers or sensors can low power "sleep"
     // Don't enter this if we're sleeping portMAX_DELAY, since that's a shutdown event
@@ -274,5 +286,10 @@ void clearBonds()
 
 void enterDfuMode()
 {
+// SDK kit does not have native USB like almost all other NRF52 boards
+#ifdef NRF_USE_SERIAL_DFU
+    enterSerialDfu();
+#else
     enterUf2Dfu();
+#endif
 }

src/platform/nrf52/softdevice/nrf_sdm.h

@@ -377,4 +377,4 @@ SVCALL(SD_SOFTDEVICE_VECTOR_TABLE_BASE_SET, uint32_t, sd_softdevice_vector_table
 
 /**
   @}
-*/
+*/

src/sleep.cpp

@@ -37,10 +37,7 @@ Observable<void *> preflightSleep;
 
 /// Called to tell observers we are now entering sleep and you should prepare.  Must return 0
 /// notifySleep will be called for light or deep sleep, notifyDeepSleep is only called for deep sleep
-/// notifyGPSSleep will be called when config.position.gps_enabled is set to 0 or from buttonthread when GPS_POWER_TOGGLE is
-/// enabled.
 Observable<void *> notifySleep, notifyDeepSleep;
-Observable<void *> notifyGPSSleep;
 
 // deep sleep support
 RTC_DATA_ATTR int bootCount = 0;
@@ -240,11 +237,6 @@ void doDeepSleep(uint32_t msecToWake, bool skipPreflight = false)
 #ifdef PIN_POWER_EN
     pinMode(PIN_POWER_EN, INPUT); // power off peripherals
     // pinMode(PIN_POWER_EN1, INPUT_PULLDOWN);
-#endif
-#if HAS_GPS
-    // Kill GPS power completely (even if previously we just had it in sleep mode)
-    if (gps)
-        gps->setGPSPower(false, false, 0);
 #endif
     setLed(false);
 
@@ -257,6 +249,8 @@ void doDeepSleep(uint32_t msecToWake, bool skipPreflight = false)
 #elif defined(VEXT_ENABLE_V05)
     digitalWrite(VEXT_ENABLE_V05, 0); // turn off the lora amplifier power
     digitalWrite(ST7735_BL_V05, 0);   // turn off the display power
+#elif defined(VEXT_ENABLE) && defined(VEXT_ON_VALUE)
+    digitalWrite(VEXT_ENABLE, !VEXT_ON_VALUE); // turn on the display power
 #elif defined(VEXT_ENABLE)
     digitalWrite(VEXT_ENABLE, 1); // turn off the display power
 #endif

src/sleep.h

@@ -41,8 +41,6 @@ extern Observable<void *> notifySleep;
 /// Called to tell observers we are now entering (deep) sleep and you should prepare.  Must return 0
 extern Observable<void *> notifyDeepSleep;
 
-/// Called to tell GPS thread to enter deep sleep independently of LoRa/MCU sleep, prior to full poweroff. Must return 0
-extern Observable<void *> notifyGPSSleep;
 void enableModemSleep();
 #ifdef ARCH_ESP32
 void enableLoraInterrupt();

variants/diy/nrf52_promicro_diy_tcxo/variant.cpp

@@ -28,4 +28,11 @@ const uint32_t g_ADigitalPinMap[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 
     // P1
-    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
+    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
+
+void initVariant()
+{
+    // 3V3 Power Rail
+    pinMode(PIN_3V3_EN, OUTPUT);
+    digitalWrite(PIN_3V3_EN, HIGH);
+}

variants/diy/nrf52_promicro_diy_xtal/variant.cpp

@@ -28,4 +28,11 @@ const uint32_t g_ADigitalPinMap[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 
     // P1
-    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
+    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
+
+void initVariant()
+{
+    // 3V3 Power Rail
+    pinMode(PIN_3V3_EN, OUTPUT);
+    digitalWrite(PIN_3V3_EN, HIGH);
+}

variants/heltec_capsule_sensor_v3/variant.h

@@ -1,5 +1,5 @@
 #define LED_PIN 33
-#define LED_PIN2 34 
+#define LED_PIN2 34
 #define EXT_PWR_DETECT 35
 
 #define BUTTON_PIN 18

variants/heltec_mesh_node_t114/platformio.ini

@@ -0,0 +1,15 @@
+; First prototype nrf52840/sx1262 device
+[env:heltec-mesh-node-t114]
+extends = nrf52840_base
+board = heltec_mesh_node_t114
+debug_tool = jlink
+
+# add -DCFG_SYSVIEW if you want to use the Segger systemview tool for OS profiling.
+build_flags = ${nrf52840_base.build_flags} -Ivariants/heltec_mesh_node_t114
+        -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m4/fpv4-sp-d16-hard"
+
+build_src_filter = ${nrf52_base.build_src_filter} +<../variants/heltec_mesh_node_t114> 
+lib_deps = 
+  ${nrf52840_base.lib_deps}
+  lewisxhe/PCF8563_Library@^1.0.1
+  https://github.com/Bei-Ji-Quan/st7789#b8e7e076714b670764139289d3829b0beff67edb