Merge remote-tracking branch 'origin/master' into 2.6

2026-10-18 09:21:43 +10:00 · 2025-02-06 14:20:46 -06:00
parent 87601f4760 cb0519dd9c
commit b183febd3c
152 changed files with 3981 additions and 1947 deletions
@@ -0,0 +1,52 @@
+# This container is used to build Meshtastic with the libraries required by the fuzzer.
+# ClusterFuzzLite starts the container, runs the build.sh script, and then exits.
+
+# As this is not a long running service, health-checks are not required. ClusterFuzzLite
+# also only works if the user remains unchanged from the base image (it expects to run
+# as root).
+# trunk-ignore-all(trivy/DS026): No healthcheck is needed for this builder container
+# trunk-ignore-all(checkov/CKV_DOCKER_2): No healthcheck is needed for this builder container
+# trunk-ignore-all(checkov/CKV_DOCKER_3): We must run as root for this container
+# trunk-ignore-all(trivy/DS002): We must run as root for this container
+# trunk-ignore-all(checkov/CKV_DOCKER_8): We must run as root for this container
+# trunk-ignore-all(hadolint/DL3002): We must run as root for this container
+
+FROM gcr.io/oss-fuzz-base/base-builder:v1
+
+ENV PIP_ROOT_USER_ACTION=ignore
+
+# trunk-ignore(hadolint/DL3008): apt packages are not pinned.
+# trunk-ignore(terrascan/AC_DOCKER_0002): apt packages are not pinned.
+RUN apt-get update && apt-get install --no-install-recommends -y \
+        cmake git zip libgpiod-dev libbluetooth-dev libi2c-dev \
+        libunistring-dev libmicrohttpd-dev libgnutls28-dev libgcrypt20-dev \
+        libusb-1.0-0-dev libssl-dev pkg-config && \
+    apt-get clean && rm -rf /var/lib/apt/lists/* && \
+    pip install --no-cache-dir -U \
+        platformio==6.1.16 \
+        grpcio-tools==1.68.1 \
+        meshtastic==2.5.9
+
+# Ugly hack to avoid clang detecting a conflict between the math "log" function and the "log" function in framework-portduino/cores/portduino/logging.h
+RUN sed -i -e 's/__MATHCALL_VEC (log,, (_Mdouble_ __x));//' /usr/include/x86_64-linux-gnu/bits/mathcalls.h
+
+# A few dependencies are too old on the base-builder image. More recent versions are built from source.
+WORKDIR $SRC
+RUN git config --global advice.detachedHead false && \
+    git clone --depth 1 --branch 0.8.0 https://github.com/jbeder/yaml-cpp.git && \
+    git clone --depth 1 --branch v2.3.3 https://github.com/babelouest/orcania.git && \
+    git clone --depth 1 --branch v1.4.20 https://github.com/babelouest/yder.git && \
+    git clone --depth 1 --branch v2.7.15 https://github.com/babelouest/ulfius.git
+
+COPY ./.clusterfuzzlite/build.sh $SRC/
+
+WORKDIR $SRC/firmware
+COPY . $SRC/firmware/
+
+# https://docs.platformio.org/en/latest/envvars.html
+ENV PLATFORMIO_CORE_DIR=$SRC/pio/core \
+    PLATFORMIO_LIBDEPS_DIR=$SRC/pio/libdeps \
+    PLATFORMIO_PACKAGES_DIR=$SRC/pio/packages \
+    PLATFORMIO_SETTING_ENABLE_CACHE=No \
+    PIO_ENV=buildroot
+RUN platformio pkg install --environment $PIO_ENV
@@ -0,0 +1,59 @@
+# ClusterFuzzLite for Meshtastic
+
+This directory contains the fuzzer implementation for Meshtastic using the ClusterFuzzLite framework.
+See the [ClusterFuzzLite documentation](https://google.github.io/clusterfuzzlite/) for more details.
+
+## Running locally
+
+ClusterFuzzLite uses the OSS-Fuzz toolchain. To build the fuzzer manually, first grab a copy of OSS-Fuzz.
+
+```shell
+git clone https://github.com/google/oss-fuzz.git
+cd oss-fuzz
+```
+
+To build the fuzzer, run:
+
+```shell
+python3 infra/helper.py build_image --external $PATH_TO_MESHTASTIC_FIRMWARE_DIRECTORY
+python3 infra/helper.py build_fuzzers --external $PATH_TO_MESHTASTIC_FIRMWARE_DIRECTORY --sanitizer address
+```
+
+To run the fuzzer, run:
+
+```shell
+python3 infra/helper.py run_fuzzer --external --corpus-dir=<path-to-temp-corpus-dir> $PATH_TO_MESHTASTIC_FIRMWARE_DIRECTORY router_fuzzer
+```
+
+More background on these commands can be found in the
+[ClusterFuzzLite documentation](https://google.github.io/clusterfuzzlite/build-integration/#testing-locally).
+
+## router_fuzzer.cpp
+
+This fuzzer submits MeshPacket protos to the `Router::enqueueReceivedMessage` method. It takes the binary
+data from the fuzzer and decodes that data to a MeshPacket using nanopb. A few fields in
+the MeshPacket are modified by the fuzzer.
+
+- If the `to` field is 0, it will be replaced with the NodeID of the running node.
+- If the `from` field is 0, it will be replaced with the NodeID of the running node.
+- If the `id` field is 0, it will be replaced with an incrementing counter value.
+- If the `pki_encrypted` field is true, the `public_key` field will be populated with the first admin key.
+
+The `router_fuzzer_seed_corpus.py` file contains a list of MeshPackets. It is run from inside build.sh and
+writes the binary MeshPacket protos to files. These files are use used by the fuzzer as its initial seed data,
+helping the fuzzer to start off with a few known inputs.
+
+### Interpreting a fuzzer crash
+
+If the fuzzer crashes, it'll write the input bytes used for the test case to a file and notify about the
+location of that file. The contents of the file are a binary serialized MeshPacket protobuf. The following
+snippet of Python code can be used to parse the file into a human readable form.
+
+```python
+from meshtastic.protobuf import mesh_pb2
+
+mesh_pb2.MeshPacket.FromString(open("crash-XXXX-file", "rb").read())
+```
+
+Consider adding any such crash results to the `router_fuzzer_seed_corpus.py` file to ensure there a isn't
+a future regression for that crash test case.
@@ -0,0 +1,71 @@
+#!/bin/bash -eu
+
+# Build Meshtastic and a few needed dependencies using clang++
+# and the OSS-Fuzz required build flags.
+
+env
+
+cd "$SRC"
+NPROC=$(nproc || echo 1)
+
+LDFLAGS=-lpthread cmake -S "$SRC/yaml-cpp" -B "$WORK/yaml-cpp/$SANITIZER" \
+	-DBUILD_SHARED_LIBS=OFF
+cmake --build "$WORK/yaml-cpp/$SANITIZER" -j "$NPROC"
+cmake --install "$WORK/yaml-cpp/$SANITIZER" --prefix /usr
+
+cmake -S "$SRC/orcania" -B "$WORK/orcania/$SANITIZER" \
+	-DBUILD_STATIC=ON
+cmake --build "$WORK/orcania/$SANITIZER" -j "$NPROC"
+cmake --install "$WORK/orcania/$SANITIZER" --prefix /usr
+
+cmake -S "$SRC/yder" -B "$WORK/yder/$SANITIZER" \
+	-DBUILD_STATIC=ON -DWITH_JOURNALD=OFF
+cmake --build "$WORK/yder/$SANITIZER" -j "$NPROC"
+cmake --install "$WORK/yder/$SANITIZER" --prefix /usr
+
+cmake -S "$SRC/ulfius" -B "$WORK/ulfius/$SANITIZER" \
+	-DBUILD_STATIC=ON -DWITH_JANSSON=OFF -DWITH_CURL=OFF -DWITH_WEBSOCKET=OFF
+cmake --build "$WORK/ulfius/$SANITIZER" -j "$NPROC"
+cmake --install "$WORK/ulfius/$SANITIZER" --prefix /usr
+
+cd "$SRC/firmware"
+
+PLATFORMIO_EXTRA_SCRIPTS=$(echo -e "pre:.clusterfuzzlite/platformio-clusterfuzzlite-pre.py\npost:.clusterfuzzlite/platformio-clusterfuzzlite-post.py")
+STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp bluez --silence-errors)
+export PLATFORMIO_EXTRA_SCRIPTS
+export STATIC_LIBS
+export PLATFORMIO_WORKSPACE_DIR="$WORK/pio/$SANITIZER"
+export TARGET_CC=$CC
+export TARGET_CXX=$CXX
+export TARGET_LD=$CXX
+export TARGET_AR=llvm-ar
+export TARGET_AS=llvm-as
+export TARGET_OBJCOPY=llvm-objcopy
+export TARGET_RANLIB=llvm-ranlib
+
+mkdir -p "$OUT/lib"
+
+cp .clusterfuzzlite/*_fuzzer.options "$OUT/"
+
+for f in .clusterfuzzlite/*_fuzzer.cpp; do
+	fuzzer=$(basename "$f" .cpp)
+	cp -f "$f" src/fuzzer.cpp
+	pio run -vvv --environment "$PIO_ENV"
+	program="$PLATFORMIO_WORKSPACE_DIR/build/$PIO_ENV/program"
+	cp "$program" "$OUT/$fuzzer"
+
+	# Copy shared libraries used by the fuzzer.
+	read -d '' -ra shared_libs < <(ldd "$program" | sed -n 's/[^=]\+=> \([^ ]\+\).*/\1/p') || true
+	cp -f "${shared_libs[@]}" "$OUT/lib/"
+
+	# Build the initial fuzzer seed corpus.
+	corpus_name="${fuzzer}_seed_corpus"
+	corpus_generator="$PWD/.clusterfuzzlite/${corpus_name}.py"
+	if [[ -f $corpus_generator ]]; then
+		mkdir "$corpus_name"
+		pushd "$corpus_name"
+		python3 "$corpus_generator"
+		popd
+		zip -D "$OUT/${corpus_name}.zip" "$corpus_name"/*
+	fi
+done
@@ -0,0 +1,35 @@
+"""PlatformIO build script (post: runs after other Meshtastic scripts)."""
+
+import os
+import shlex
+
+from SCons.Script import DefaultEnvironment
+
+env = DefaultEnvironment()
+
+# Remove any static libraries from the LIBS environment. Static libraries are
+# handled in platformio-clusterfuzzlite-pre.py.
+static_libs = set(lib[2:] for lib in shlex.split(os.getenv("STATIC_LIBS")))
+env.Replace(
+    LIBS=[
+        lib for lib in env["LIBS"] if not (isinstance(lib, str) and lib in static_libs)
+    ],
+)
+
+# FrameworkArduino/portduino/main.cpp contains the "main" function the binary.
+# The fuzzing framework also provides a "main" function and needs to be run
+# before Meshtastic is started. We rename the "main" function for Meshtastic to
+# "portduino_main" here so that it can be called inside the fuzzer.
+env.AddPostAction(
+    "$BUILD_DIR/FrameworkArduino/portduino/main.cpp.o",
+    env.VerboseAction(
+        " ".join(
+            [
+                "$OBJCOPY",
+                "--redefine-sym=main=portduino_main",
+                "$BUILD_DIR/FrameworkArduino/portduino/main.cpp.o",
+            ]
+        ),
+        "Renaming main symbol to portduino_main",
+    ),
+)
@@ -0,0 +1,52 @@
+"""PlatformIO build script (pre: runs before other Meshtastic scripts).
+
+ClusterFuzzLite executes in a different container from the build. During the build,
+attempt to link statically to as many dependencies as possible. For dependencies that
+do not have static libraries, the shared library files are copied to the output
+directory by the build.sh script.
+"""
+
+import glob
+import os
+import shlex
+
+from SCons.Script import DefaultEnvironment, Literal
+
+env = DefaultEnvironment()
+
+cxxflags = shlex.split(os.getenv("CXXFLAGS"))
+sanitizer_flags = shlex.split(os.getenv("SANITIZER_FLAGS"))
+lib_fuzzing_engine = shlex.split(os.getenv("LIB_FUZZING_ENGINE"))
+statics = glob.glob("/usr/lib/lib*.a") + glob.glob("/usr/lib/*/lib*.a")
+no_static = set(("-ldl",))
+
+
+def replaceStatic(lib):
+    """Replace -l<libname> with the static .a file for the library."""
+    if not lib.startswith("-l") or lib in no_static:
+        return lib
+    static_name = f"/lib{lib[2:]}.a"
+    static = [s for s in statics if s.endswith(static_name)]
+    if len(static) == 1:
+        return static[0]
+    return lib
+
+
+# Setup the environment for building with Clang and the OSS-Fuzz required build flags.
+env.Append(
+    CFLAGS=os.getenv("CFLAGS"),
+    CXXFLAGS=cxxflags,
+    LIBSOURCE_DIRS=["/usr/lib/x86_64-linux-gnu"],
+    LINKFLAGS=cxxflags
+    + sanitizer_flags
+    + lib_fuzzing_engine
+    + ["-stdlib=libc++", "-std=c++17"],
+    _LIBFLAGS=[replaceStatic(s) for s in shlex.split(os.getenv("STATIC_LIBS"))]
+    + [
+        "/usr/lib/x86_64-linux-gnu/libunistring.a",  # Needs to be at the end.
+        # Find the shared libraries in a subdirectory named lib
+        # within the same directory as the binary.
+        Literal("-Wl,-rpath,$ORIGIN/lib"),
+        "-Wl,-z,origin",
+    ],
+)
@@ -0,0 +1 @@
+language: c++
@@ -0,0 +1,206 @@
+// Fuzzer implementation that sends MeshPackets to Router::enqueueReceivedMessage.
+#include <condition_variable>
+#include <cstdlib>
+#include <mutex>
+#include <pb_decode.h>
+#include <stdexcept>
+#include <string>
+#include <thread>
+
+#include "PortduinoGPIO.h"
+#include "PortduinoGlue.h"
+#include "PowerFSM.h"
+#include "mesh/MeshTypes.h"
+#include "mesh/NodeDB.h"
+#include "mesh/Router.h"
+#include "mesh/TypeConversions.h"
+#include "mesh/mesh-pb-constants.h"
+
+namespace
+{
+constexpr uint32_t nodeId = 0x12345678;
+// Set to true when lateInitVariant finishes. Used to ensure lateInitVariant was called during startup.
+bool hasBeenConfigured = false;
+
+// These are used to block the Arduino loop() function until a fuzzer input is ready. This is
+// an optimization that prevents a sleep from happening before the loop is run. The Arduino loop
+// function calls loopCanSleep() before sleeping. loopCanSleep is implemented here in the fuzzer
+// and blocks until runLoopOnce() is called to signal for the loop to run.
+bool fuzzerRunning = false;  // Set to true once LLVMFuzzerTestOneInput has started running.
+bool loopCanRun = true;      // The main Arduino loop() can run when this is true.
+bool loopIsWaiting = false;  // The main Arduino loop() is waiting to be signaled to run.
+bool loopShouldExit = false; // Indicates that the main Arduino thread should exit by throwing ShouldExitException.
+std::mutex loopLock;
+std::condition_variable loopCV;
+std::thread meshtasticThread;
+
+// This exception is thrown when the portuino main thread should exit.
+class ShouldExitException : public std::runtime_error
+{
+  public:
+    using std::runtime_error::runtime_error;
+};
+
+// Start the loop for one test case and wait till the loop has completed. This ensures fuzz
+// test cases do not overlap with one another. This helps the fuzzer attribute a crash to the
+// single, currently running, test case.
+void runLoopOnce()
+{
+    realHardware = true; // Avoids delay(100) within portduino/main.cpp
+    std::unique_lock<std::mutex> lck(loopLock);
+    fuzzerRunning = true;
+    loopCanRun = true;
+    loopCV.notify_one();
+    loopCV.wait(lck, [] { return !loopCanRun && loopIsWaiting; });
+}
+} // namespace
+
+// Called in the main Arduino loop function to determine if the loop can delay/sleep before running again.
+// We use this as a way to block the loop from sleeping and to start the loop function immediately when a
+// fuzzer input is ready.
+bool loopCanSleep()
+{
+    std::unique_lock<std::mutex> lck(loopLock);
+    loopIsWaiting = true;
+    loopCV.notify_one();
+    loopCV.wait(lck, [] { return loopCanRun || loopShouldExit; });
+    loopIsWaiting = false;
+    if (loopShouldExit)
+        throw ShouldExitException("exit");
+    if (!fuzzerRunning)
+        return true;    // The loop can sleep before the fuzzer starts.
+    loopCanRun = false; // Only run the loop once before waiting again.
+    return false;
+}
+
+// Called just prior to starting Meshtastic. Allows for setting config values before startup.
+void lateInitVariant()
+{
+    settingsMap[logoutputlevel] = level_error;
+    channelFile.channels[0] = meshtastic_Channel{
+        .has_settings = true,
+        .settings =
+            meshtastic_ChannelSettings{
+                .psk = {.size = 1, .bytes = {/*defaultpskIndex=*/1}},
+                .name = "LongFast",
+                .uplink_enabled = true,
+                .has_module_settings = true,
+                .module_settings = {.position_precision = 16},
+            },
+        .role = meshtastic_Channel_Role_PRIMARY,
+    };
+    config.security.admin_key[0] = {
+        .size = 32,
+        .bytes = {0xcd, 0xc0, 0xb4, 0x3c, 0x53, 0x24, 0xdf, 0x13, 0xca, 0x5a, 0xa6, 0x0c, 0x0d, 0xec, 0x85, 0x5a,
+                  0x4c, 0xf6, 0x1a, 0x96, 0x04, 0x1a, 0x3e, 0xfc, 0xbb, 0x8e, 0x33, 0x71, 0xe5, 0xfc, 0xff, 0x3c},
+    };
+    config.security.admin_key_count = 1;
+    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
+    moduleConfig.has_mqtt = true;
+    moduleConfig.mqtt = meshtastic_ModuleConfig_MQTTConfig{
+        .enabled = true,
+        .proxy_to_client_enabled = true,
+    };
+    moduleConfig.has_store_forward = true;
+    moduleConfig.store_forward = meshtastic_ModuleConfig_StoreForwardConfig{
+        .enabled = true,
+        .history_return_max = 4,
+        .history_return_window = 600,
+        .is_server = true,
+    };
+    meshtastic_Position fixedGPS = meshtastic_Position{
+        .has_latitude_i = true,
+        .latitude_i = static_cast<uint32_t>(1 * 1e7),
+        .has_longitude_i = true,
+        .longitude_i = static_cast<uint32_t>(3 * 1e7),
+        .has_altitude = true,
+        .altitude = 64,
+        .location_source = meshtastic_Position_LocSource_LOC_MANUAL,
+    };
+    nodeDB->setLocalPosition(fixedGPS);
+    config.has_position = true;
+    config.position.fixed_position = true;
+    meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    info->has_position = true;
+    info->position = TypeConversions::ConvertToPositionLite(fixedGPS);
+    hasBeenConfigured = true;
+}
+
+extern "C" {
+int portduino_main(int argc, char **argv); // Renamed "main" function from Meshtastic binary.
+
+// Start Meshtastic in a thread and wait till it has reached the ON state.
+int LLVMFuzzerInitialize(int *argc, char ***argv)
+{
+    settingsMap[maxtophone] = 5;
+
+    meshtasticThread = std::thread([program = *argv[0]]() {
+        char nodeIdStr[12];
+        strcpy(nodeIdStr, std::to_string(nodeId).c_str());
+        int argc = 7;
+        char *argv[] = {program, "-d", "/tmp/meshtastic", "-h", nodeIdStr, "-p", "0", nullptr};
+        try {
+            portduino_main(argc, argv);
+        } catch (const ShouldExitException &) {
+        }
+    });
+    std::atexit([] {
+        {
+            const std::lock_guard<std::mutex> lck(loopLock);
+            loopShouldExit = true;
+            loopCV.notify_one();
+        }
+        meshtasticThread.join();
+    });
+
+    // Wait for startup.
+    for (int i = 1; i < 20; ++i) {
+        if (powerFSM.getState() == &stateON) {
+            assert(hasBeenConfigured);
+            assert(router);
+            assert(nodeDB);
+            return 0;
+        }
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
+    return 1;
+}
+
+// This is the main entrypoint for the fuzzer (the fuzz target). The fuzzer will provide an array of bytes to be
+// interpreted by this method. To keep things simple, the bytes are interpreted as a binary serialized MeshPacket
+// proto. Any crashes discovered by the fuzzer will be written to a file. Unserialize that file to print the MeshPacket
+// that caused the failure.
+//
+// This guide provides best practices for writing a fuzzer target.
+// https://github.com/google/fuzzing/blob/master/docs/good-fuzz-target.md
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t length)
+{
+    meshtastic_MeshPacket p = meshtastic_MeshPacket_init_default;
+    pb_istream_t stream = pb_istream_from_buffer(data, length);
+    // Ignore any inputs that fail to decode or have fields set that are not transmitted over LoRa.
+    if (!pb_decode(&stream, &meshtastic_MeshPacket_msg, &p) || p.rx_time || p.rx_snr || p.priority || p.rx_rssi || p.delayed ||
+        p.public_key.size || p.next_hop || p.relay_node || p.tx_after)
+        return -1; // Reject: The input will not be added to the corpus.
+    if (p.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+        meshtastic_Data d;
+        stream = pb_istream_from_buffer(p.decoded.payload.bytes, p.decoded.payload.size);
+        if (!pb_decode(&stream, &meshtastic_Data_msg, &d))
+            return -1; // Reject: The input will not be added to the corpus.
+    }
+
+    // Provide default values for a few fields so the fuzzer doesn't need to guess them.
+    if (p.from == 0)
+        p.from = nodeDB->getNodeNum();
+    if (p.to == 0)
+        p.to = nodeDB->getNodeNum();
+    static uint32_t packetId = 0;
+    if (p.id == 0)
+        p.id == ++packetId;
+    if (p.pki_encrypted && config.security.admin_key_count)
+        memcpy(&p.public_key, &config.security.admin_key[0], sizeof(p.public_key));
+
+    router->enqueueReceivedMessage(packetPool.allocCopy(p));
+    runLoopOnce();
+    return 0; // Accept: The input may be added to the corpus.
+}
+}
@@ -0,0 +1,2 @@
+[libfuzzer]
+max_len=256
@@ -0,0 +1,168 @@
+"""Generate an initial set of MeshPackets.
+
+The fuzzer uses these MeshPackets as an initial seed of test candidates.
+
+It's also good to add any previously discovered crash test cases to this list
+to avoid future regressions.
+
+If left unset, the following values will be automatically set by the fuzzer.
+  - to: automatically set to the running node's NodeID
+  - from: automatically set to the running node's NodeID
+  - id: automatically set to the value of an incrementing counter
+
+Additionally, if `pki_encrypted` is populated in the packet, the first admin key
+will be copied into the `public_key` field.
+"""
+
+import base64
+
+from meshtastic import BROADCAST_NUM
+from meshtastic.protobuf import (
+    admin_pb2,
+    atak_pb2,
+    mesh_pb2,
+    portnums_pb2,
+    telemetry_pb2,
+)
+
+
+def From(node: int = 9):
+    """Return a dict suitable for **kwargs for populating the 'from' field.
+
+    'from' is a reserved keyword in Python. It can't be used directly as an
+    argument to the MeshPacket constructor. Rather **From() can be used as
+    the final argument to provide the from node as a **kwarg.
+
+    Defaults to 9 if no value is provided.
+    """
+    return {"from": node}
+
+
+packets = (
+    (
+        "position",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.POSITION_APP,
+                payload=mesh_pb2.Position(
+                    latitude_i=int(1 * 1e7),
+                    longitude_i=int(2 * 1e7),
+                    altitude=5,
+                    precision_bits=32,
+                ).SerializeToString(),
+            ),
+            to=BROADCAST_NUM,
+            **From(),
+        ),
+    ),
+    (
+        "telemetry",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.TELEMETRY_APP,
+                payload=telemetry_pb2.Telemetry(
+                    time=1736192207,
+                    device_metrics=telemetry_pb2.DeviceMetrics(
+                        battery_level=101,
+                        channel_utilization=8,
+                        air_util_tx=2,
+                        uptime_seconds=42,
+                    ),
+                ).SerializeToString(),
+            ),
+            to=BROADCAST_NUM,
+            **From(),
+        ),
+    ),
+    (
+        "text",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.TEXT_MESSAGE_APP,
+                payload=b"Hello world",
+            ),
+            to=BROADCAST_NUM,
+            **From(),
+        ),
+    ),
+    (
+        "user",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.NODEINFO_APP,
+                payload=mesh_pb2.User(
+                    id="!00000009",
+                    long_name="Node 9",
+                    short_name="N9",
+                    macaddr=b"\x00\x00\x00\x00\x00\x09",
+                    hw_model=mesh_pb2.HardwareModel.RAK4631,
+                    public_key=base64.b64decode(
+                        "L0ih/6F41itofdE8mYyHk1SdfOJ/QRM1KQ+pO4vEEjQ="
+                    ),
+                ).SerializeToString(),
+            ),
+            **From(),
+        ),
+    ),
+    (
+        "traceroute",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.TRACEROUTE_APP,
+                payload=mesh_pb2.RouteDiscovery(
+                    route=[10],
+                ).SerializeToString(),
+            ),
+            **From(),
+        ),
+    ),
+    (
+        "routing",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.ROUTING_APP,
+                payload=mesh_pb2.Routing(
+                    error_reason=mesh_pb2.Routing.NO_RESPONSE,
+                ).SerializeToString(),
+            ),
+            **From(),
+        ),
+    ),
+    (
+        "admin",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.ADMIN_APP,
+                payload=admin_pb2.AdminMessage(
+                    get_owner_request=True,
+                ).SerializeToString(),
+            ),
+            pki_encrypted=True,
+            **From(),
+        ),
+    ),
+    (
+        "atak",
+        mesh_pb2.MeshPacket(
+            decoded=mesh_pb2.Data(
+                portnum=portnums_pb2.PortNum.ATAK_PLUGIN,
+                payload=atak_pb2.TAKPacket(
+                    is_compressed=True,
+                    # Note, the strings are not valid for a compressed message, but will
+                    # give the fuzzer a starting point.
+                    contact=atak_pb2.Contact(
+                        callsign="callsign", device_callsign="device_callsign"
+                    ),
+                    chat=atak_pb2.GeoChat(
+                        message="message", to="to", to_callsign="to_callsign"
+                    ),
+                ).SerializeToString(),
+            ),
+            **From(),
+        ),
+    ),
+)
+
+for name, packet in packets:
+    with open(f"{name}.MeshPacket", "wb") as f:
+        f.write(packet.SerializeToString())
@@ -0,0 +1 @@
+.gitignore
@@ -68,6 +68,12 @@ runs:
          sed -i '/DDEBUG_HEAP/d' ${INI_FILE}
        done

+    - name: PlatformIO ${{ inputs.arch }} download cache
+      uses: actions/cache@v4
+      with:
+        path: ~/.platformio/.cache
+        key: pio-cache-${{ inputs.arch }}-${{ hashFiles('.github/actions/**', '**.ini') }}
+
    - name: Build ${{ inputs.board }}
      shell: bash
      run: ${{ inputs.build-script-path }} ${{ inputs.board }}
@@ -20,19 +20,16 @@ runs:
      shell: bash
      run: |
        sudo apt-get -y update --fix-missing
-        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev
+        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev lsb-release

    - name: Setup Python
      uses: actions/setup-python@v5
      with:
        python-version: 3.x
-
-    # - name: Cache python libs
-    #   uses: actions/cache@v4
-    #   id: cache-pip # needed in if test
-    #   with:
-    #     path: ~/.cache/pip
-    #     key: ${{ runner.os }}-pip
+        cache: pip
+        cache-dependency-path: |
+          .github/actions/**
+          **.ini

    - name: Upgrade python tools
      shell: bash
@@ -1,51 +0,0 @@
-name: Build Docker
-
-on: workflow_call
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-native:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Docker login
-        if: ${{ github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
-        uses: docker/login-action@v3
-        with:
-          username: meshtastic
-          password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}
-
-      - name: Docker setup
-        if: ${{ github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
-        uses: docker/setup-buildx-action@v3
-
-      - name: Docker build and push tagged versions
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./Dockerfile
-          push: true
-          tags: meshtastic/meshtasticd:${{ steps.version.outputs.long }}
-
-      - name: Docker build and push
-        if: ${{ github.ref == 'refs/heads/master' && github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./Dockerfile
-          push: true
-          tags: meshtastic/meshtasticd:latest
@@ -1,38 +0,0 @@
-name: Build Native
-
-on: workflow_call
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-native:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Setup native build
-        id: base
-        uses: ./.github/actions/setup-native
-
-      - name: Build Native
-        run: bin/build-native.sh
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-native-${{ steps.version.outputs.long }}.zip
-          overwrite: true
-          path: |
-            release/meshtasticd_linux_x86_64
-            bin/config-dist.yaml
@@ -1,52 +0,0 @@
-name: Build Raspbian
-
-on: workflow_call
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-raspbian:
-    runs-on: [self-hosted, linux, ARM64]
-    steps:
-      - name: Install libbluetooth
-        shell: bash
-        run: |
-          sudo apt-get update -y --fix-missing
-          sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Upgrade python tools
-        shell: bash
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio adafruit-nrfutil
-          pip install -U meshtastic --pre
-
-      - name: Upgrade platformio
-        shell: bash
-        run: |
-          pio upgrade
-
-      - name: Build Raspbian
-        run: bin/build-native.sh
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-raspbian-${{ steps.version.outputs.long }}.zip
-          overwrite: true
-          path: |
-            release/meshtasticd_linux_aarch64
-            bin/config-dist.yaml
@@ -1,52 +0,0 @@
-name: Build Raspbian Arm
-
-on: workflow_call
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-raspbian-armv7l:
-    runs-on: [self-hosted, linux, ARM]
-    steps:
-      - name: Install libbluetooth
-        shell: bash
-        run: |
-          sudo apt-get update -y --fix-missing
-          sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Upgrade python tools
-        shell: bash
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio adafruit-nrfutil
-          pip install -U meshtastic --pre
-
-      - name: Upgrade platformio
-        shell: bash
-        run: |
-          pio upgrade
-
-      - name: Build Raspbian
-        run: bin/build-native.sh
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-raspbian-armv7l-${{ steps.version.outputs.long }}.zip
-          overwrite: true
-          path: |
-            release/meshtasticd_linux_armv7l
-            bin/config-dist.yaml
@@ -1,4 +1,4 @@
-name: Nightly Debian Packaging
+name: Daily Packaging
 on:
  schedule:
    - cron: 0 9 * * *
@@ -8,16 +8,24 @@ on:
      - master
    paths:
      - debian/**
-      - .github/workflows/nightly_debian.yml
+      - "*.rpkg"
+      - .github/workflows/nightly_packaging.yml
      - .github/workflows/build_debian_src.yml
      - .github/workflows/package_ppa.yml
      - .github/workflows/package_obs.yml
+      - .github/workflows/hook_copr.yml

 permissions:
  contents: write
  packages: write

 jobs:
+  docker-multiarch:
+    uses: ./.github/workflows/docker_manifest.yml
+    with:
+      release_channel: daily
+    secrets: inherit
+
  package-ppa:
    strategy:
      fail-fast: false
@@ -25,13 +33,19 @@ jobs:
        series: [plucky, oracular, noble, jammy]
    uses: ./.github/workflows/package_ppa.yml
    with:
-      ppa_repo: daily
+      ppa_repo: ppa:meshtastic/daily
      series: ${{ matrix.series }}
    secrets: inherit

  package-obs:
    uses: ./.github/workflows/package_obs.yml
    with:
-      obs_repo: meshtasticd
+      obs_project: network:Meshtastic:daily
      series: unstable
    secrets: inherit
+
+  hook-copr:
+    uses: ./.github/workflows/hook_copr.yml
+    with:
+      copr_project: daily
+    secrets: inherit
@@ -0,0 +1,92 @@
+name: Build Docker
+
+# Build Docker image, push untagged (digest-only)
+
+on:
+  workflow_call:
+    secrets:
+      DOCKER_FIRMWARE_TOKEN:
+        required: false # Only required for push
+    inputs:
+      distro:
+        description: Distro to target
+        required: true
+        type: string
+        # choices: [debian, alpine]
+      platform:
+        description: Platform to target
+        required: true
+        type: string
+      runs-on:
+        description: Runner to use
+        required: true
+        type: string
+      push:
+        description: Push images to registry
+        required: false
+        type: boolean
+        default: false
+    outputs:
+      digest:
+        description: Digest of built image
+        value: ${{ jobs.docker-build.outputs.digest }}
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  docker-build:
+    outputs:
+      digest: ${{ steps.docker_variant.outputs.digest }}
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - name: Get release version string
+        run: |
+          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Docker login
+        if: ${{ inputs.push }}
+        uses: docker/login-action@v3
+        with:
+          username: meshtastic
+          password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker setup
+        uses: docker/setup-buildx-action@v3
+
+      - name: Sanitize platform string
+        id: sanitize_platform
+        # Replace slashes with underscores
+        run: echo "cleaned_platform=${{ inputs.platform }}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+
+      - name: Docker tag
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: meshtastic/meshtasticd
+          tags: |
+            GHA-${{ steps.version.outputs.long }}-${{ inputs.distro }}-${{ steps.sanitize_platform.outputs.cleaned_platform }}
+          flavor: latest=false
+
+      - name: Docker build and push
+        uses: docker/build-push-action@v6
+        id: docker_variant
+        with:
+          context: .
+          file: |
+            ${{ contains(inputs.distro, 'debian') && './Dockerfile' || contains(inputs.distro, 'alpine') && './alpine.Dockerfile' }}
+          push: ${{ inputs.push }}
+          tags: ${{ steps.meta.outputs.tags }} # Tag is only meant to be consumed by the "manifest" job
+          platforms: ${{ inputs.platform }}
@@ -0,0 +1,186 @@
+name: Build Docker Multi-Arch Manifest
+
+on:
+  workflow_call:
+    secrets:
+      DOCKER_FIRMWARE_TOKEN:
+        required: true
+    inputs:
+      release_channel:
+        description: Release channel to target
+        required: true
+        type: string
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  docker-debian-amd64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: true
+    secrets: inherit
+
+  docker-debian-arm64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
+  docker-debian-armv7:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
+  docker-alpine-amd64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: true
+    secrets: inherit
+
+  docker-alpine-arm64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
+  docker-alpine-armv7:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
+  docker-manifest:
+    needs:
+      # Debian
+      - docker-debian-amd64
+      - docker-debian-arm64
+      - docker-debian-armv7
+      # Alpine
+      - docker-alpine-amd64
+      - docker-alpine-arm64
+      - docker-alpine-armv7
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - name: Get release version string
+        run: |
+          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+          echo "short=$(./bin/buildinfo.py short)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Enumerate tags
+        shell: python
+        run: |
+          import os
+
+          short = "${{ steps.version.outputs.short }}"
+          long = "${{ steps.version.outputs.long }}"
+          release_channel = "${{ inputs.release_channel }}"
+          tags = {
+            "beta": {
+              "debian": [
+                f"{short}", f"{long}", f"{short}-beta", f"{long}-beta", "beta", "latest",
+                f"{short}-debian", f"{long}-debian", f"{short}-beta-debian", f"{long}-beta-debian", "beta-debian"
+              ],
+              "alpine": [
+                f"{short}-alpine", f"{long}-alpine", f"{short}-beta-alpine", f"{long}-beta-alpine", "beta-alpine"
+              ]
+            },
+            "alpha": {
+              "debian": [
+                f"{short}-alpha", f"{long}-alpha", "alpha",
+                f"{short}-alpha-debian", f"{long}-alpha-debian", "alpha-debian"
+              ],
+              "alpine": [
+                f"{short}-alpha-alpine", f"{long}-alpha-alpine", "alpha-alpine"
+              ]
+            },
+            "daily": {
+              "debian": ["daily", "daily-debian"],
+              "alpine": ["daily-alpine"]
+            }
+          }
+
+          with open(os.environ["GITHUB_OUTPUT"], "a") as fh:
+            fh.write("debian<<EOF\n")
+            fh.write("\n".join(tags[release_channel]["debian"]))
+            fh.write("\nEOF\n")
+
+            fh.write("alpine<<EOF\n")
+            fh.write("\n".join(tags[release_channel]["alpine"]))
+            fh.write("\nEOF\n")
+        id: tags
+
+      - name: Docker login
+        uses: docker/login-action@v3
+        with:
+          username: meshtastic
+          password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}
+
+      - name: Docker meta (Debian)
+        id: meta_debian
+        uses: docker/metadata-action@v5
+        with:
+          images: meshtastic/meshtasticd
+          tags: |
+            ${{ steps.tags.outputs.debian }}
+          flavor: latest=false
+
+      - name: Create Docker manifest (Debian)
+        id: manifest_debian
+        uses: int128/docker-manifest-create-action@v2
+        with:
+          tags: |
+            ${{ steps.meta_debian.outputs.tags }}
+          push: true
+          sources: |
+            meshtastic/meshtasticd@${{ needs.docker-debian-amd64.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-debian-arm64.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-debian-armv7.outputs.digest }}
+
+      - name: Docker meta (Alpine)
+        id: meta_alpine
+        uses: docker/metadata-action@v5
+        with:
+          images: meshtastic/meshtasticd
+          tags: |
+            ${{ steps.tags.outputs.alpine }}
+
+      - name: Create Docker manifest (Alpine)
+        id: manifest_alpine
+        uses: int128/docker-manifest-create-action@v2
+        with:
+          tags: |
+            ${{ steps.meta_alpine.outputs.tags }}
+          push: true
+          sources: |
+            meshtastic/meshtasticd@${{ needs.docker-alpine-amd64.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-alpine-arm64.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-alpine-armv7.outputs.digest }}
@@ -0,0 +1,38 @@
+name: Trigger COPR build
+
+on:
+  workflow_call:
+    secrets:
+      COPR_API_CONFIG:
+    inputs:
+      copr_project:
+        description: COPR project to target
+        required: true
+        type: string
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  build-copr-hook:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          ref: ${{ github.ref }}
+          repository: ${{ github.repository }}
+
+      - name: Trigger COPR build
+        uses: vidplace7/copr-build@main
+        id: copr_build
+        env:
+          COPR_API_TOKEN_CONFIG: ${{ secrets.COPR_API_CONFIG }}
+        with:
+          owner: "@meshtastic"
+          package-name: meshtasticd
+          project-name: ${{ inputs.copr_project }}
+          git-remote: "${{ github.server_url }}/${{ github.repository }}.git"
+          committish: ${{ github.sha }}
@@ -128,22 +128,47 @@ jobs:
    with:
      board: ${{ matrix.board }}

-  package-raspbian:
-    uses: ./.github/workflows/package_raspbian.yml
-
-  package-raspbian-armv7l:
-    uses: ./.github/workflows/package_raspbian_armv7l.yml
-
-  package-native:
-    uses: ./.github/workflows/package_amd64.yml
+  build-debian-src:
+    uses: ./.github/workflows/build_debian_src.yml
+    with:
+      series: UNRELEASED
+      build_location: local
+    secrets: inherit

  test-native:
    uses: ./.github/workflows/test_native.yml

-  build-docker:
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/build_docker.yml
-    secrets: inherit
+  docker-debian-amd64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-alpine-amd64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-debian-arm64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: false
+
+  docker-debian-armv7:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
+      push: false

  after-checks:
    runs-on: ubuntu-latest
@@ -254,13 +279,7 @@ jobs:
    if: ${{ github.event_name == 'workflow_dispatch' }}
    outputs:
      upload_url: ${{ steps.create_release.outputs.upload_url }}
-    needs:
-      [
-        gather-artifacts,
-        package-raspbian,
-        package-raspbian-armv7l,
-        package-native,
-      ]
+    needs: [gather-artifacts, build-debian-src]
    steps:
      - name: Checkout
        uses: actions/checkout@v4
@@ -271,8 +290,12 @@ jobs:
          python-version: 3.x

      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        run: |
+          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+          echo "deb=$(./bin/buildinfo.py deb)" >> $GITHUB_OUTPUT
        id: version
+        env:
+          BUILD_LOCATION: local

      - name: Create release
        uses: softprops/action-gh-release@v2
@@ -285,25 +308,26 @@ jobs:
          body: |
            Autogenerated by github action, developer should edit as required before publishing...

-      - name: Download deb files
+      - name: Download source deb
        uses: actions/download-artifact@v4
        with:
-          pattern: meshtasticd_${{ steps.version.outputs.long }}_*.deb
+          pattern: firmware-debian-${{ steps.version.outputs.deb }}~UNRELEASED-src
          merge-multiple: true
-          path: ./output
+          path: ./output/debian-src
+
+      - name: Zip source deb
+        working-directory: output
+        run: zip -j -9 -r ./meshtasticd-${{ steps.version.outputs.deb }}-src.zip ./debian-src

      # For diagnostics
      - name: Display structure of downloaded files
        run: ls -lR

-      - name: Add deb files to release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: v${{ steps.version.outputs.long }}
-          files: |
-            ./output/meshtasticd_${{ steps.version.outputs.long }}_arm64.deb
-            ./output/meshtasticd_${{ steps.version.outputs.long }}_armhf.deb
-            ./output/meshtasticd_${{ steps.version.outputs.long }}_amd64.deb
+      - name: Add source deb to release
+        run: |
+          gh release upload v${{ steps.version.outputs.long }} ./output/meshtasticd-${{ steps.version.outputs.deb }}-src.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Bump version.properties
        run: >-
@@ -373,9 +397,8 @@ jobs:
        run: ls -lR

      - name: Add bins and debug elfs to release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: v${{ steps.version.outputs.long }}
-          files: |
-            ./firmware-${{matrix.arch}}-${{ steps.version.outputs.long }}.zip
-            ./debug-elfs-${{matrix.arch}}-${{ steps.version.outputs.long }}.zip
+        run: |
+          gh release upload v${{ steps.version.outputs.long }} ./firmware-${{matrix.arch}}-${{ steps.version.outputs.long }}.zip
+          gh release upload v${{ steps.version.outputs.long }} ./debug-elfs-${{matrix.arch}}-${{ steps.version.outputs.long }}.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,90 +0,0 @@
-name: Package Native
-
-on:
-  workflow_call:
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-native:
-    uses: ./.github/workflows/build_native.yml
-
-  package-native:
-    runs-on: ubuntu-22.04
-    needs: build-native
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Pull web ui
-        uses: dsaltares/fetch-gh-release-asset@master
-        with:
-          repo: meshtastic/web
-          file: build.tar
-          target: build.tar
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: firmware-native-${{ steps.version.outputs.long }}.zip
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: build .debpkg
-        run: |
-          mkdir -p .debpkg/DEBIAN
-          mkdir -p .debpkg/usr/share/meshtasticd/web
-          mkdir -p .debpkg/usr/sbin
-          mkdir -p .debpkg/etc/meshtasticd
-          mkdir -p .debpkg/etc/meshtasticd/config.d
-          mkdir -p .debpkg/etc/meshtasticd/available.d
-          mkdir -p .debpkg/usr/lib/systemd/system/
-          tar -xf build.tar -C .debpkg/usr/share/meshtasticd/web
-          shopt -s dotglob nullglob
-          if [ -d .debpkg/usr/share/meshtasticd/web/build ]; then mv  .debpkg/usr/share/meshtasticd/web/build/* .debpkg/usr/share/meshtasticd/web/; fi
-          if [ -d .debpkg/usr/share/meshtasticd/web/build ]; then rmdir .debpkg/usr/share/meshtasticd/web/build; fi
-          if [ -d .debpkg/usr/share/meshtasticd/web/.DS_Store ]; then rm -f .debpkg/usr/share/meshtasticd/web/.DS_Store; fi
-          gunzip .debpkg/usr/share/meshtasticd/web/ -r
-          cp release/meshtasticd_linux_x86_64 .debpkg/usr/sbin/meshtasticd
-          cp bin/config-dist.yaml .debpkg/etc/meshtasticd/config.yaml
-          cp bin/config.d/* .debpkg/etc/meshtasticd/available.d/ -r
-          chmod +x .debpkg/usr/sbin/meshtasticd
-          cp bin/meshtasticd.service .debpkg/usr/lib/systemd/system/meshtasticd.service
-          echo "/etc/meshtasticd/config.yaml" > .debpkg/DEBIAN/conffiles
-          chmod +x .debpkg/DEBIAN/conffiles
-          # Transition /usr/share/doc/meshtasticd to /usr/share/meshtasticd
-          echo "rm -rf /usr/share/doc/meshtasticd" > .debpkg/DEBIAN/preinst
-          chmod +x .debpkg/DEBIAN/preinst
-          echo "ln -sf /usr/share/meshtasticd /usr/share/doc/meshtasticd" > .debpkg/DEBIAN/postinst
-          chmod +x .debpkg/DEBIAN/postinst
-
-      - uses: jiro4989/build-deb-action@v3
-        with:
-          package: meshtasticd
-          package_root: .debpkg
-          maintainer: Jonathan Bennett
-          version: ${{ steps.version.outputs.long }} # refs/tags/v*.*.*
-          arch: amd64
-          depends: libyaml-cpp0.7, openssl, libulfius2.7, libi2c0
-          desc: Native Linux Meshtastic binary.
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: meshtasticd_${{ steps.version.outputs.long }}_amd64.deb
-          overwrite: true
-          path: |
-            ./*.deb
@@ -3,11 +3,13 @@ name: Package for OpenSUSE Build Service
 on:
  workflow_call:
    secrets:
+      OBS_PASSWORD:
+        required: true
      PPA_GPG_PRIVATE_KEY:
        required: true
    inputs:
-      obs_repo:
-        description: Meshtastic OBS repo to target
+      obs_project:
+        description: Meshtastic OBS project to target
        required: true
        type: string
      series:
@@ -64,40 +66,45 @@ jobs:
      - name: Display structure of downloaded files
        run: ls -lah

-      # - name: Configure osc
-      #   shell: bash
-      #   env:
-      #     OBS_USERNAME: ${{ secrets.OBS_USERNAME }}
-      #     OBS_PASSWORD: ${{ secrets.OBS_PASSWORD }}
-      #   run: |
-      #     mkdir -p ~/.config/osc
-      #     echo -e "[https://api.opensuse.org]\n" > ~/.config/osc/oscrc
-      #     echo -e "user = $OBS_USERNAME" >> ~/.config/osc/oscrc
-      #     echo -e "pass = $OBS_PASSWORD" >> ~/.config/osc/oscrc
-      #     echo -e "aliases = obs" >> ~/.config/osc/oscrc
-      #     # Authenticate to OBS
-      #     osc meta prj -v
+      - name: Configure osc
+        env:
+          OBS_USERNAME: meshtastic
+        run: |
+          # Setup OpenSUSE Build Service credentials
+          mkdir -p ~/.config/osc
+          echo "[general]" > ~/.config/osc/oscrc
+          echo "apiurl=https://api.opensuse.org" >> ~/.config/osc/oscrc
+          echo "[https://api.opensuse.org]" >> ~/.config/osc/oscrc
+          echo "user=${{ env.OBS_USERNAME }}" >> ~/.config/osc/oscrc
+          echo "pass=${{ secrets.OBS_PASSWORD }}" >> ~/.config/osc/oscrc
+          echo "credentials_mgr_class=osc.credentials.PlaintextConfigFileCredentialsManager" >> ~/.config/osc/oscrc
+          # Create a temporary directory for osc checkout
+          mkdir -p osc

-      # - name: Upload Package to OBS
-      #   shell: bash
-      #   run: |
-      #     # Define your OBS project and repository
-      #     OBS_PROJECT="application:meshtastic"
-      #     OBS_REPO="${{ inputs.obs_repo }}"
+      # Intentionally fail if credentials are invalid
+      # Update secrets if this returns `401`
+      - name: Verify OBS authentication
+        run: osc token

-      #     # Create a temporary directory for osc
-      #     mkdir -p /tmp/osc/$OBS_PROJECT/$OBS_REPO
-      #     cd /tmp/osc/$OBS_PROJECT/$OBS_REPO
+      - name: Upload package to OBS
+        shell: bash
+        working-directory: osc
+        env:
+          OBS_PROJECT: ${{ inputs.obs_project }}
+          OBS_PACKAGE: meshtasticd
+        run: |
+          # Initialize the package in the current directory
+          osc checkout --output-dir . $OBS_PROJECT $OBS_PACKAGE

-      #     # Initialize the package directory
-      #     osc checkout $OBS_PROJECT $OBS_REPO
+          # Remove the existing package files
+          rm -rf *.dsc *.tar.xz

-      #     # Copy package files to the osc directory
-      #     cp $GITHUB_WORKSPACE/*.dsc .
-      #     cp $GITHUB_WORKSPACE/*.tar.xz .
+          # Copy new package files to the directory
+          cp $GITHUB_WORKSPACE/*.dsc .
+          cp $GITHUB_WORKSPACE/*.tar.xz .

-      #     # Add files to osc
-      #     osc addremove
+          # Add/Remove the files
+          osc addremove

-      #     # Commit and push the changes
-      #     osc commit -m "Automated upload from GitHub Actions"
+          # Commit changes and push to OpenSUSE Build Service
+          osc commit -m "GitHub Actions: ${{ steps.version.outputs.deb }}~${{ inputs.series }}"
@@ -71,4 +71,4 @@ jobs:
      - name: Publish with dput
        if: ${{ github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
        run: |
-          dput ppa:meshtastic/${{ inputs.ppa_repo }} meshtasticd_${{ steps.version.outputs.deb }}~${{ inputs.series }}_source.changes
+          dput ${{ inputs.ppa_repo }} meshtasticd_${{ steps.version.outputs.deb }}~${{ inputs.series }}_source.changes
@@ -1,90 +0,0 @@
-name: Package Raspbian
-
-on:
-  workflow_call:
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-raspbian:
-    uses: ./.github/workflows/build_raspbian.yml
-
-  package-raspbian:
-    runs-on: ubuntu-22.04
-    needs: build-raspbian
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Pull web ui
-        uses: dsaltares/fetch-gh-release-asset@master
-        with:
-          repo: meshtastic/web
-          file: build.tar
-          target: build.tar
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: firmware-raspbian-${{ steps.version.outputs.long }}.zip
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: build .debpkg
-        run: |
-          mkdir -p .debpkg/DEBIAN
-          mkdir -p .debpkg/usr/share/meshtasticd/web
-          mkdir -p .debpkg/usr/sbin
-          mkdir -p .debpkg/etc/meshtasticd
-          mkdir -p .debpkg/etc/meshtasticd/config.d
-          mkdir -p .debpkg/etc/meshtasticd/available.d
-          mkdir -p .debpkg/usr/lib/systemd/system/
-          tar -xf build.tar -C .debpkg/usr/share/meshtasticd/web
-          shopt -s dotglob nullglob
-          if [ -d .debpkg/usr/share/meshtasticd/web/build ]; then mv  .debpkg/usr/share/meshtasticd/web/build/* .debpkg/usr/share/meshtasticd/web/; fi
-          if [ -d .debpkg/usr/share/meshtasticd/web/build ]; then rmdir .debpkg/usr/share/meshtasticd/web/build; fi
-          if [ -d .debpkg/usr/share/meshtasticd/web/.DS_Store ]; then rm -f .debpkg/usr/share/meshtasticd/web/.DS_Store; fi
-          gunzip .debpkg/usr/share/meshtasticd/web/ -r
-          cp release/meshtasticd_linux_aarch64 .debpkg/usr/sbin/meshtasticd
-          cp bin/config-dist.yaml .debpkg/etc/meshtasticd/config.yaml
-          cp bin/config.d/* .debpkg/etc/meshtasticd/available.d/ -r
-          chmod +x .debpkg/usr/sbin/meshtasticd
-          cp bin/meshtasticd.service .debpkg/usr/lib/systemd/system/meshtasticd.service
-          echo "/etc/meshtasticd/config.yaml" > .debpkg/DEBIAN/conffiles
-          chmod +x .debpkg/DEBIAN/conffiles
-          # Transition /usr/share/doc/meshtasticd to /usr/share/meshtasticd
-          echo "rm -rf /usr/share/doc/meshtasticd" > .debpkg/DEBIAN/preinst
-          chmod +x .debpkg/DEBIAN/preinst
-          echo "ln -sf /usr/share/meshtasticd /usr/share/doc/meshtasticd" > .debpkg/DEBIAN/postinst
-          chmod +x .debpkg/DEBIAN/postinst
-
-      - uses: jiro4989/build-deb-action@v3
-        with:
-          package: meshtasticd
-          package_root: .debpkg
-          maintainer: Jonathan Bennett
-          version: ${{ steps.version.outputs.long }} # refs/tags/v*.*.*
-          arch: arm64
-          depends: libyaml-cpp0.7, openssl, libulfius2.7, libi2c0
-          desc: Native Linux Meshtastic binary.
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: meshtasticd_${{ steps.version.outputs.long }}_arm64.deb
-          overwrite: true
-          path: |
-            ./*.deb
@@ -1,90 +0,0 @@
-name: Package Raspbian
-
-on:
-  workflow_call:
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  packages: write
-
-jobs:
-  build-raspbian_armv7l:
-    uses: ./.github/workflows/build_raspbian_armv7l.yml
-
-  package-raspbian_armv7l:
-    runs-on: ubuntu-22.04
-    needs: build-raspbian_armv7l
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Pull web ui
-        uses: dsaltares/fetch-gh-release-asset@master
-        with:
-          repo: meshtastic/web
-          file: build.tar
-          target: build.tar
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: firmware-raspbian-armv7l-${{ steps.version.outputs.long }}.zip
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: build .debpkg
-        run: |
-          mkdir -p .debpkg/DEBIAN
-          mkdir -p .debpkg/usr/share/meshtasticd/web
-          mkdir -p .debpkg/usr/sbin
-          mkdir -p .debpkg/etc/meshtasticd
-          mkdir -p .debpkg/etc/meshtasticd/config.d
-          mkdir -p .debpkg/etc/meshtasticd/available.d
-          mkdir -p .debpkg/usr/lib/systemd/system/
-          tar -xf build.tar -C .debpkg/usr/share/meshtasticd/web
-          shopt -s dotglob nullglob
-          if [ -d .debpkg/usr/share/meshtasticd/web/build ]; then mv  .debpkg/usr/share/meshtasticd/web/build/* .debpkg/usr/share/meshtasticd/web/; fi
-          if [ -d .debpkg/usr/share/meshtasticd/web/build ]; then rmdir .debpkg/usr/share/meshtasticd/web/build; fi
-          if [ -d .debpkg/usr/share/meshtasticd/web/.DS_Store ]; then rm -f .debpkg/usr/share/meshtasticd/web/.DS_Store; fi
-          gunzip .debpkg/usr/share/meshtasticd/web/ -r
-          cp release/meshtasticd_linux_armv7l .debpkg/usr/sbin/meshtasticd
-          cp bin/config-dist.yaml .debpkg/etc/meshtasticd/config.yaml
-          cp bin/config.d/* .debpkg/etc/meshtasticd/available.d/ -r
-          chmod +x .debpkg/usr/sbin/meshtasticd
-          cp bin/meshtasticd.service .debpkg/usr/lib/systemd/system/meshtasticd.service
-          echo "/etc/meshtasticd/config.yaml" > .debpkg/DEBIAN/conffiles
-          chmod +x .debpkg/DEBIAN/conffiles
-          # Transition /usr/share/doc/meshtasticd to /usr/share/meshtasticd
-          echo "rm -rf /usr/share/doc/meshtasticd" > .debpkg/DEBIAN/preinst
-          chmod +x .debpkg/DEBIAN/preinst
-          echo "ln -sf /usr/share/meshtasticd /usr/share/doc/meshtasticd" > .debpkg/DEBIAN/postinst
-          chmod +x .debpkg/DEBIAN/postinst
-
-      - uses: jiro4989/build-deb-action@v3
-        with:
-          package: meshtasticd
-          package_root: .debpkg
-          maintainer: Jonathan Bennett
-          version: ${{ steps.version.outputs.long }} # refs/tags/v*.*.*
-          arch: armhf
-          depends: libyaml-cpp0.7, openssl, libulfius2.7, libi2c0
-          desc: Native Linux Meshtastic binary.
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: meshtasticd_${{ steps.version.outputs.long }}_armhf.deb
-          overwrite: true
-          path: |
-            ./*.deb
@@ -4,9 +4,18 @@ on:
  release:
    types: [published, released]

-permissions: read-all
+permissions:
+  contents: write
+  packages: write

 jobs:
+  build-docker:
+    uses: ./.github/workflows/docker_manifest.yml
+    with:
+      release_channel: |-
+        ${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
+    secrets: inherit
+
  package-ppa:
    strategy:
      fail-fast: false
@@ -15,13 +24,22 @@ jobs:
    uses: ./.github/workflows/package_ppa.yml
    with:
      ppa_repo: |-
-        ${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
+        ppa:meshtastic/${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
      series: ${{ matrix.series }}
    secrets: inherit

-  # package-obs:
-  #   uses: ./.github/workflows/package_obs.yml
-  #   with:
-  #     obs_repo: meshtasticd
-  #     series: ${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
-  #   secrets: inherit
+  package-obs:
+    uses: ./.github/workflows/package_obs.yml
+    with:
+      obs_project: |-
+        network:Meshtastic:${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
+      series: |-
+        ${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
+    secrets: inherit
+
+  hook-copr:
+    uses: ./.github/workflows/hook_copr.yml
+    with:
+      copr_project: |-
+        ${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
+    secrets: inherit
@@ -90,7 +90,7 @@ jobs:
        run: sed -i 's/-DBUILD_EPOCH=$UNIX_TIME/#-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini

      - name: PlatformIO Tests
-        run: platformio test -e coverage --junit-output-path testreport.xml
+        run: platformio test -e coverage -v --junit-output-path testreport.xml

      - name: Save test results
        if: always() # run this step even if previous step failed
@@ -12,6 +12,9 @@ web.tar
 *.code-workspace

 .idea
+.platformio
+.local
+.cache

 .DS_Store
 Thumbs.db
@@ -38,7 +38,8 @@ USER root
 RUN apt-get update && apt-get --no-install-recommends -y install libc-bin libc6 libgpiod2 libyaml-cpp0.7 libi2c0 libulfius2.7 libusb-1.0-0-dev liborcania2.3 libssl3 && \
    apt-get clean && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /var/lib/meshtasticd \
-    && mkdir -p /etc/meshtasticd/config.d
+    && mkdir -p /etc/meshtasticd/config.d \
+    && mkdir -p /etc/meshtasticd/ssl

 # Fetch compiled binary from the builder
 COPY --from=builder /tmp/firmware/release/meshtasticd /usr/sbin/
@@ -29,7 +29,8 @@ USER root

 RUN apk add libstdc++ libgpiod yaml-cpp libusb i2c-tools \
    && mkdir -p /var/lib/meshtasticd \
-    && mkdir -p /etc/meshtasticd/config.d
+    && mkdir -p /etc/meshtasticd/config.d \
+    && mkdir -p /etc/meshtasticd/ssl
 COPY --from=builder /tmp/firmware/release/meshtasticd /usr/sbin/

 WORKDIR /var/lib/meshtasticd
@@ -4,7 +4,7 @@ platform = platformio/nordicnrf52@^10.7.0
 extends = arduino_base
 platform_packages =
  ; our custom Git version until they merge our PR
-  framework-arduinoadafruitnrf52 @ https://github.com/geeksville/Adafruit_nRF52_Arduino.git
+  framework-arduinoadafruitnrf52 @ https://github.com/meshtastic/Adafruit_nRF52_Arduino.git#e13f5820002a4fb2a5e6754b42ace185277e5adf
  toolchain-gccarmnoneeabi@~1.90301.0

 build_type = debug
@@ -25,7 +25,7 @@ lib_deps =
  ${networking_base.lib_deps}
  ${radiolib_base.lib_deps}
  rweather/Crypto@^0.4.0
-  https://github.com/lovyan03/LovyanGFX.git#1401c28a47646fe00538d487adcb2eb3c72de805
+  lovyan03/LovyanGFX@^1.2.0
  https://github.com/pine64/libch341-spi-userspace#a9b17e3452f7fb747000d9b4ad4409155b39f6ef

 build_flags =
@@ -40,4 +40,4 @@ build_flags =
  -lgpiod
  -lyaml-cpp
  -li2c
-  -std=c++17
+  -std=c++17
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+sed -i 's/#-DBUILD_EPOCH=$UNIX_TIME/-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
+
+export PIP_BREAK_SYSTEM_PACKAGES=1
+
+if (echo $2 | grep -q "esp32"); then
+  bin/build-esp32.sh $1
+elif (echo $2 | grep -q "nrf52"); then
+  bin/build-nrf52.sh $1
+elif (echo $2 | grep -q "stm32"); then
+  bin/build-stm32.sh $1
+elif (echo $2 | grep -q "rpi2040"); then
+  bin/build-rpi2040.sh $1
+else
+  echo "Unknown target $2"
+  exit 1
+fi
@@ -23,6 +23,47 @@ Lora:
 #  Busy: 20
 #  Reset: 18

+### The Radxa Zero 3E/W employs multiple gpio chips.
+### Each gpio pin must be unique, but can be assigned to a specific gpio chip and line.
+### In case solely a no. is given, the default gpio chip and pin == line will be employed.
+###
+#  Module: sx1262  # Radxa Zero 3E/W + Ebyte E22-900M30S
+#  DIO2_AS_RF_SWITCH: true
+#  DIO3_TCXO_VOLTAGE: 1.8
+#  CS:             # NSS     PIN_24 -> chip 4, line 22
+#    pin: 24
+#    gpiochip: 4
+#    line: 22
+#  SCK:            # SCK     PIN_23 -> chip 4, line 18
+#    pin: 23
+#    gpiochip: 4
+#    line: 18
+#  Busy:           # BUSY    PIN_29 -> chip 3!, line 11
+#    pin: 29
+#    gpiochip: 3
+#    line: 11
+#  MOSI:           # MOSI    PIN_19 -> chip 4, line 19
+#    pin: 19
+#    gpiochip: 4
+#    line: 19
+#  MISO:           # MISO    PIN_21 -> chip 4, line 21
+#    pin: 21
+#    gpiochip: 4
+#    line: 21
+#  Reset:          # NRST    PIN_27 -> chip 4, line 10
+#    pin: 27
+#    gpiochip: 4
+#    line: 10
+#  IRQ:            # DIO1    PIN_28 -> chip 4, line 11
+#    pin: 28
+#    gpiochip: 4
+#    line: 11
+#  RXen:           # RXEN    PIN_22 -> chip 3!, line 17
+#    pin: 22
+#    gpiochip: 3
+#    line: 17
+#  TXen: RADIOLIB_NC # TXEN   no PIN, no line, fallback to default gpio chip
+
 #  Module: sx1268  # SX1268-based modules, tested with Ebyte E22 400M33S
 #  CS: 21
 #  IRQ: 16
@@ -37,9 +78,11 @@ Lora:
 #  TXen: x  # TX and RX enable pins
 #  RXen: x

+#  SX126X_MAX_POWER: 8  # Limit the output power to 8 dBm, useful for amped nodes
+
 #  spiSpeed: 2000000

-### Set gpio chip to use in /dev/. Defaults to 0.
+### Set default/fallback gpio chip to use in /dev/. Defaults to 0.
 ### Notably the Raspberry Pi 5 puts the GPIO header on gpiochip4
 #  gpiochip: 4

@@ -141,6 +184,8 @@ Logging:
 Webserver:
 #  Port: 443 # Port for Webserver & Webservices
 #  RootPath: /usr/share/meshtasticd/web # Root Dir of WebServer
+#  SSLKey: /etc/meshtasticd/ssl/private_key.pem # Path to SSL Key, generated if not present
+#  SSLCert: /etc/meshtasticd/ssl/certificate.pem # Path to SSL Certificate, generated if not present

 General:
  MaxNodes: 200
@@ -0,0 +1,9 @@
+Lora:
+  Module: sx1262  # BananaPi-BPI-R4 SPI via 26p GPIO Header
+##  CS: 28
+  IRQ: 50
+  Busy: 62
+  Reset: 51
+  spidev: spidev1.0
+  DIO2_AS_RF_SWITCH: true
+  DIO3_TCXO_VOLTAGE: true
@@ -7,3 +7,6 @@ Lora:
  TXen: 13
  RXen: 12
  DIO3_TCXO_VOLTAGE: true
+  # Only for E22-900M33S:
+  # Limit the output power to 8 dBm
+  # SX126X_MAX_POWER: 8
@@ -73,7 +73,7 @@ shift "$((OPTIND - 1))"
 if [ -f "${FILENAME}" ] && [ -n "${FILENAME##*"update"*}" ]; then
 	echo "Trying to flash ${FILENAME}, but first erasing and writing system information"
 	$ESPTOOL_CMD erase_flash
-	$ESPTOOL_CMD write_flash 0x00 ${FILENAME}
+	$ESPTOOL_CMD write_flash 0x00 "${FILENAME}"
 	# Account for S3 board's different OTA partition
 	if [ -n "${FILENAME##*"s3"*}" ] && [ -n "${FILENAME##*"-v3"*}" ] && [ -n "${FILENAME##*"t-deck"*}" ] && [ -n "${FILENAME##*"wireless-paper"*}" ] && [ -n "${FILENAME##*"wireless-tracker"*}" ] && [ -n "${FILENAME##*"station-g2"*}" ] && [ -n "${FILENAME##*"unphone"*}" ]; then
 		if [ -n "${FILENAME##*"esp32c3"*}" ]; then
@@ -102,7 +102,7 @@ pref_flags = []
 for pref in userPrefs:
    if userPrefs[pref].startswith("{"):
        pref_flags.append("-D" + pref + "=" + userPrefs[pref])
-    elif userPrefs[pref].replace(".", "").isdigit():
+    elif userPrefs[pref].lstrip("-").replace(".", "").isdigit():
        pref_flags.append("-D" + pref + "=" + userPrefs[pref])
    elif userPrefs[pref] == "true" or userPrefs[pref] == "false":
        pref_flags.append("-D" + pref + "=" + userPrefs[pref])
@@ -0,0 +1,12 @@
+function meshtastic_version {
+    meshtastic_version=$(python3 bin/buildinfo.py short)
+    echo -n "$meshtastic_version"
+}
+function git_commits_num {
+    total_commits=$(git rev-list --all --count)
+    echo -n "$total_commits"
+}
+function git_commit_sha {
+    commit_sha=$(git rev-parse --short HEAD)
+    echo -n "$commit_sha"
+}
@@ -1,5 +1,9 @@
-meshtasticd (2.5.19.0) UNRELEASED; urgency=medium
+meshtasticd (2.5.22.0) UNRELEASED; urgency=medium

  * Initial packaging
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump

- -- Austin Lane <vidplace7@gmail.com>  Thu, 02 Jan 2025 12:00:00 +0000
+ -- Austin Lane <github-actions[bot]@users.noreply.github.com>  Wed, 05 Feb 2025 01:10:33 +0000
@@ -11,7 +11,7 @@ platformio pkg install -e native -t platformio/tool-scons@4.40502.0
 tar -cf pio.tar pio/
 rm -rf pio
 # Download the latest meshtastic/web release build.tar to `web.tar`
-curl -L https://github.com/meshtastic/web/releases/download/latest/build.tar -o web.tar
+curl -L https://github.com/meshtastic/web/releases/latest/download/build.tar -o web.tar

 package=$(dpkg-parsechangelog --show-field Source)

@@ -1,4 +1,5 @@
 etc/meshtasticd
 etc/meshtasticd/config.d
 etc/meshtasticd/available.d
-usr/share/meshtasticd/web
+usr/share/meshtasticd/web
+etc/meshtasticd/ssl
@@ -0,0 +1,94 @@
+# meshtasticd spec file for RPM-based distributions
+#
+# Build locally with:
+# ```
+# sudo dnf install rpkg-util
+# rpkg local
+# ```
+#
+# See:
+# - https://docs.pagure.org/rpkg-util/v3/index.html
+# - https://docs.fedoraproject.org/en-US/packaging-guidelines/Versioning/
+
+Name:           meshtasticd
+# Version Ex:   2.5.19
+Version:        {{{ meshtastic_version }}}
+# Release Ex:   9127.daily.gitd7f5f620.fc41
+Release:        {{{ git_commits_num }}}%{?copr_projectname:.%{copr_projectname}}.git{{{ git_commit_sha }}}%{?dist}
+VCS:            {{{ git_dir_vcs }}}
+Summary:        Meshtastic daemon for communicating with Meshtastic devices
+
+License:        GPL-3.0
+URL:            https://github.com/meshtastic/firmware
+Source0:        {{{ git_dir_pack }}}
+Source1:        https://github.com/meshtastic/web/releases/latest/download/build.tar
+
+BuildRequires: systemd-rpm-macros
+BuildRequires: python3-devel
+BuildRequires: platformio
+BuildRequires: python3dist(protobuf)
+BuildRequires: python3dist(grpcio[protobuf])
+BuildRequires: python3dist(grpcio-tools)
+BuildRequires: git-core
+BuildRequires: gcc-c++
+BuildRequires: pkgconfig(yaml-cpp)
+BuildRequires: pkgconfig(libgpiod)
+BuildRequires: pkgconfig(bluez)
+BuildRequires: pkgconfig(libusb-1.0)
+BuildRequires: libi2c-devel
+# Web components:
+BuildRequires: pkgconfig(openssl)
+BuildRequires: pkgconfig(liborcania)
+BuildRequires: pkgconfig(libyder)
+BuildRequires: pkgconfig(libulfius)
+
+%description
+Meshtastic daemon for controlling Meshtastic devices. Meshtastic is an off-grid
+text communication platform that uses inexpensive LoRa radios.
+
+%prep
+{{{ git_dir_setup_macro }}}
+# Unpack the web files
+mkdir -p web
+tar -xf %{SOURCE1} -C web
+gzip -dr web
+
+%build
+# Use the “native” environment from platformio to build a Linux binary
+platformio run -e native
+
+%install
+mkdir -p %{buildroot}%{_sbindir}
+install -m 0755 .pio/build/native/program %{buildroot}%{_sbindir}/meshtasticd
+
+mkdir -p %{buildroot}%{_sysconfdir}/meshtasticd
+install -m 0644 bin/config-dist.yaml %{buildroot}%{_sysconfdir}/meshtasticd/config.yaml
+mkdir -p %{buildroot}%{_sysconfdir}/meshtasticd/config.d
+mkdir -p %{buildroot}%{_sysconfdir}/meshtasticd/available.d
+cp -r bin/config.d/* %{buildroot}%{_sysconfdir}/meshtasticd/available.d
+
+install -D -m 0644 bin/meshtasticd.service %{buildroot}%{_unitdir}/meshtasticd.service
+
+# Install the web files under /usr/share/meshtasticd/web
+mkdir -p %{buildroot}%{_datadir}/meshtasticd/web
+cp -r web/* %{buildroot}%{_datadir}/meshtasticd/web
+# Install default SSL storage directory (for web)
+mkdir -p %{buildroot}%{_sysconfdir}/meshtasticd/ssl
+
+%files
+%license LICENSE
+%doc README.md
+%{_sbindir}/meshtasticd
+%dir %{_sysconfdir}/meshtasticd
+%dir %{_sysconfdir}/meshtasticd/config.d
+%dir %{_sysconfdir}/meshtasticd/available.d
+%config(noreplace) %{_sysconfdir}/meshtasticd/config.yaml
+%config %{_sysconfdir}/meshtasticd/available.d/*
+%{_unitdir}/meshtasticd.service
+%dir %{_datadir}/meshtasticd
+%dir %{_datadir}/meshtasticd/web
+%{_datadir}/meshtasticd/web/*
+%dir %{_sysconfdir}/meshtasticd/ssl
+
+%changelog
+%autochangelog
@@ -20,7 +20,7 @@ extra_scripts = bin/platformio-custom.py
 build_flags = -Wno-missing-field-initializers

 	-Wno-format
-	-Isrc -Isrc/mesh -Isrc/mesh/generated -Isrc/gps -Isrc/buzz -Wl,-Map,.pio/build/output.map
+	-Isrc -Isrc/mesh -Isrc/mesh/generated -Isrc/gps -Isrc/buzz -Wl,-Map,"${platformio.build_dir}"/output.map
 	-DUSE_THREAD_NAMES
 	-DTINYGPS_OPTION_NO_CUSTOM_FIELDS
 	-DPB_ENABLE_MALLOC=1
@@ -49,7 +49,7 @@ build_flags = -Wno-missing-field-initializers
 	-DMESHTASTIC_EXCLUDE_HEALTH_TELEMETRY=1
  	-DMESHTASTIC_EXCLUDE_POWERSTRESS=1 ; exclude power stress test module from main firmware
        #-DBUILD_EPOCH=$UNIX_TIME
-        ;-D OLED_PL
+        #-D OLED_PL=1

 monitor_speed = 115200
 monitor_filters = direct
@@ -126,6 +126,7 @@ lib_deps =
 	mprograms/QMC5883LCompass@1.2.3
 	dfrobot/DFRobot_RTU@1.0.3
 	https://github.com/meshtastic/DFRobot_LarkWeatherStation#4de3a9cadef0f6a5220a8a906cf9775b02b0040d
+	https://github.com/DFRobot/DFRobot_RainfallSensor#38fea5e02b40a5430be6dab39a99a6f6347d667e
 	robtillaart/INA226@0.6.0

 	; Health Sensor Libraries
@@ -0,0 +1,2 @@
+[rpkg]
+user_macros = "${git_props:root}/bin/rpkg.macros"
@@ -190,6 +190,20 @@ int32_t ButtonThread::runOnce()
            case 4:
                digitalWrite(PIN_EINK_EN, digitalRead(PIN_EINK_EN) == LOW);
                break;
+#endif
+#if defined(RAK_4631)
+            // 5 clicks: start accelerometer/magenetometer calibration for 30 seconds
+            case 5:
+                if (accelerometerThread) {
+                    accelerometerThread->calibrate(30);
+                }
+                break;
+            // 6 clicks: start accelerometer/magenetometer calibration for 60 seconds
+            case 6:
+                if (accelerometerThread) {
+                    accelerometerThread->calibrate(60);
+                }
+                break;
 #endif
            // No valid multipress action
            default:
@@ -49,24 +49,6 @@ void OSFS::writeNBytes(uint16_t address, unsigned int num, const byte *input)
 }
 #endif

-bool lfs_assert_failed =
-    false; // Note: we use this global on all platforms, though it can only be set true on nrf52 (in our modified lfs_util.h)
-
-extern "C" void lfs_assert(const char *reason)
-{
-    LOG_ERROR("LFS assert: %s", reason);
-    lfs_assert_failed = true;
-
-#ifndef ARCH_PORTDUINO
-#ifdef FSCom
-    // CORRUPTED FILESYSTEM. This causes bootloop so
-    // might as well try formatting now.
-    LOG_ERROR("Trying FSCom.format()");
-    FSCom.format();
-#endif
-#endif
-}
-
 /**
 * @brief Copies a file from one location to another.
 *
@@ -203,7 +185,7 @@ std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
                file.close();
            }
        } else {
-            meshtastic_FileInfo fileInfo = {"", file.size()};
+            meshtastic_FileInfo fileInfo = {"", static_cast<uint32_t>(file.size())};
 #ifdef ARCH_ESP32
            strcpy(fileInfo.file_name, file.path());
 #else
@@ -348,10 +330,16 @@ void rmDir(const char *dirname)
 #endif
 }

+/**
+ * Some platforms (nrf52) might need to do an extra step before FSBegin().
+ */
+__attribute__((weak, noinline)) void preFSBegin() {}
+
 void fsInit()
 {
 #ifdef FSCom
-    spiLock->lock();
+    concurrency::LockGuard g(spiLock);
+    preFSBegin();
    if (!FSBegin()) {
        LOG_ERROR("Filesystem mount failed");
        // assert(0); This auto-formats the partition, so no need to fail here.
@@ -362,7 +350,6 @@ void fsInit()
    LOG_DEBUG("Filesystem files:");
 #endif
    listDir("/", 10);
-    spiLock->unlock();
 #endif
 }

@@ -400,4 +387,4 @@ void setupSDCard()
    LOG_DEBUG("Total space: %lu MB", (uint32_t)(SD.totalBytes() / (1024 * 1024)));
    LOG_DEBUG("Used space: %lu MB", (uint32_t)(SD.usedBytes() / (1024 * 1024)));
 #endif
-}
+}
@@ -57,7 +57,4 @@ bool renameFile(const char *pathFrom, const char *pathTo);
 std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels);
 void listDir(const char *dirname, uint8_t levels, bool del = false);
 void rmDir(const char *dirname);
-void setupSDCard();
-
-extern bool lfs_assert_failed; // Note: we use this global on all platforms, though it can only be set true on nrf52 (in our
-                               // modified lfs_util.h)
+void setupSDCard();
@@ -87,7 +87,7 @@ MAX17048Sensor max17048Sensor;
 #endif
 #endif

-#if HAS_RAKPROT && !defined(ARCH_PORTDUINO)
+#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && HAS_RAKPROT && !defined(ARCH_PORTDUINO)
 RAK9154Sensor rak9154Sensor;
 #endif

@@ -243,7 +243,8 @@ class AnalogBatteryLevel : public HasBatteryLevel
    virtual uint16_t getBattVoltage() override
    {

-#if defined(HAS_RAKPROT) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU)
+#if HAS_TELEMETRY && defined(HAS_RAKPROT) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU) &&                                    \
+    !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
        if (hasRAK()) {
            return getRAKVoltage();
        }
@@ -406,7 +407,8 @@ class AnalogBatteryLevel : public HasBatteryLevel
    /// we can't be smart enough to say 'full'?
    virtual bool isCharging() override
    {
-#if defined(HAS_RAKPROT) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU)
+#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT) && !defined(ARCH_PORTDUINO) &&             \
+    !defined(HAS_PMU)
        if (hasRAK()) {
            return (rak9154Sensor.isCharging()) ? OptTrue : OptFalse;
        }
@@ -447,7 +449,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
    float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
    uint32_t last_read_time_ms = 0;

-#if defined(HAS_RAKPROT)
+#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT)

    uint16_t getRAKVoltage() { return rak9154Sensor.getBusVoltageMv(); }

@@ -79,17 +79,17 @@ size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_l
    }
    if (color && logLevel != nullptr) {
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
-            Print::write("\u001b[34m", 6);
+            Print::write("\u001b[34m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
-            Print::write("\u001b[32m", 6);
+            Print::write("\u001b[32m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
-            Print::write("\u001b[33m", 6);
+            Print::write("\u001b[33m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
-            Print::write("\u001b[31m", 6);
+            Print::write("\u001b[31m", 5);
    }
    len = Print::write(printBuf, len);
    if (color && logLevel != nullptr) {
-        Print::write("\u001b[0m", 5);
+        Print::write("\u001b[0m", 4);
    }
    return len;
 }
@@ -107,15 +107,15 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
    // include the header
    if (color) {
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
-            Print::write("\u001b[34m", 6);
+            Print::write("\u001b[34m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
-            Print::write("\u001b[32m", 6);
+            Print::write("\u001b[32m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
-            Print::write("\u001b[33m", 6);
+            Print::write("\u001b[33m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
-            Print::write("\u001b[31m", 6);
+            Print::write("\u001b[31m", 5);
        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0)
-            Print::write("\u001b[35m", 6);
+            Print::write("\u001b[35m", 5);
    }

    uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // display local time on logfile
@@ -393,4 +393,4 @@ std::string RedirectablePrint::mt_sprintf(const std::string fmt_str, ...)
            break;
    }
    return std::string(formatted.get());
-}
+}
@@ -6,6 +6,11 @@
 static File openFile(const char *filename, bool fullAtomic)
 {
    concurrency::LockGuard g(spiLock);
+    LOG_DEBUG("Opening %s, fullAtomic=%d", filename, fullAtomic);
+#ifdef ARCH_NRF52
+    FSCom.remove(filename);
+    return FSCom.open(filename, FILE_O_WRITE);
+#endif
    if (!fullAtomic)
        FSCom.remove(filename); // Nuke the old file to make space (ignore if it !exists)

@@ -13,8 +18,6 @@ static File openFile(const char *filename, bool fullAtomic)
    filenameTmp += ".tmp";

    // clear any previous LFS errors
-    lfs_assert_failed = false;
-
    return FSCom.open(filenameTmp.c_str(), FILE_O_WRITE);
 }

@@ -57,6 +60,10 @@ bool SafeFile::close()
    spiLock->lock();
    f.close();
    spiLock->unlock();
+
+#ifdef ARCH_NRF52
+    return true;
+#endif
    if (!testReadback())
        return false;

@@ -83,8 +90,6 @@ bool SafeFile::close()
 bool SafeFile::testReadback()
 {
    concurrency::LockGuard g(spiLock);
-    bool lfs_failed = lfs_assert_failed;
-    lfs_assert_failed = false;

    String filenameTmp = filename;
    filenameTmp += ".tmp";
@@ -106,7 +111,7 @@ bool SafeFile::testReadback()
        return false;
    }

-    return !lfs_failed;
+    return true;
 }

 #endif
@@ -145,6 +145,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define OPT3001_ADDR_ALT 0x44
 #define MLX90632_ADDR 0x3A
 #define DFROBOT_LARK_ADDR 0x42
+#define DFROBOT_RAIN_ADDR 0x1d
 #define NAU7802_ADDR 0x2A
 #define MAX30102_ADDR 0x57
 #define MLX90614_ADDR_DEF 0x5A
@@ -66,6 +66,7 @@ class ScanI2C
        CGRADSENS,
        INA226,
        NXP_SE050,
+        DFROBOT_RAIN,
    } DeviceType;

    // typedef uint8_t DeviceAddress;
@@ -84,23 +84,33 @@ ScanI2C::DeviceType ScanI2CTwoWire::probeOLED(ScanI2C::DeviceAddress addr) const
    return o_probe;
 }
 uint16_t ScanI2CTwoWire::getRegisterValue(const ScanI2CTwoWire::RegisterLocation &registerLocation,
-                                          ScanI2CTwoWire::ResponseWidth responseWidth) const
+                                          ScanI2CTwoWire::ResponseWidth responseWidth, bool zeropad = false) const
 {
    uint16_t value = 0x00;
    TwoWire *i2cBus = fetchI2CBus(registerLocation.i2cAddress);

    i2cBus->beginTransmission(registerLocation.i2cAddress.address);
    i2cBus->write(registerLocation.registerAddress);
+    if (zeropad) {
+        // Lark Commands need the argument list length in 2 bytes.
+        i2cBus->write((int)0);
+        i2cBus->write((int)0);
+    }
    i2cBus->endTransmission();
    delay(20);
    i2cBus->requestFrom(registerLocation.i2cAddress.address, responseWidth);
-    if (i2cBus->available() == 2) {
+    if (i2cBus->available() > 1) {
        // Read MSB, then LSB
        value = (uint16_t)i2cBus->read() << 8;
        value |= i2cBus->read();
    } else if (i2cBus->available()) {
        value = i2cBus->read();
    }
+    // Drain excess bytes
+    for (uint8_t i = 0; i < responseWidth - 1; i++) {
+        if (i2cBus->available())
+            i2cBus->read();
+    }
    return value;
 }

@@ -286,7 +296,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                    RESPONSE_PAYLOAD 0x01
                    RESPONSE_PAYLOAD+1 0x00
                    */
-                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x05), 2);
+                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x05), 6, true);
                    LOG_DEBUG("Register MFG_UID 05: 0x%x", registerValue);
                    if (registerValue == 0x5305) {
                        logFoundDevice("DFRobot Lark", (uint8_t)addr.address);
@@ -402,6 +412,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                SCAN_SIMPLE_CASE(MLX90632_ADDR, MLX90632, "MLX90632", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(NAU7802_ADDR, NAU7802, "NAU7802", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(MAX1704X_ADDR, MAX17048, "MAX17048", (uint8_t)addr.address);
+                SCAN_SIMPLE_CASE(DFROBOT_RAIN_ADDR, DFROBOT_RAIN, "DFRobot Rain Gauge", (uint8_t)addr.address);
 #ifdef HAS_TPS65233
                SCAN_SIMPLE_CASE(TPS65233_ADDR, TPS65233, "TPS65233", (uint8_t)addr.address);
 #endif
@@ -53,7 +53,7 @@ class ScanI2CTwoWire : public ScanI2C

    concurrency::Lock lock;

-    uint16_t getRegisterValue(const RegisterLocation &, ResponseWidth) const;
+    uint16_t getRegisterValue(const RegisterLocation &, ResponseWidth, bool) const;

    DeviceType probeOLED(ScanI2C::DeviceAddress) const;

@@ -238,7 +238,7 @@ void EInkDynamicDisplay::checkRateLimiting()

    // Skip update: too soon for BACKGROUND
    if (frameFlags == BACKGROUND) {
-        if (Throttle::isWithinTimespanMs(previousRunMs, EINK_LIMIT_RATE_BACKGROUND_SEC * 1000)) {
+        if (Throttle::isWithinTimespanMs(previousRunMs, 30000)) {
            refresh = SKIPPED;
            reason = EXCEEDED_RATELIMIT_FULL;
            return;
@@ -251,7 +251,7 @@ void EInkDynamicDisplay::checkRateLimiting()

    // Skip update: too soon for RESPONSIVE
    if (frameFlags & RESPONSIVE) {
-        if (Throttle::isWithinTimespanMs(previousRunMs, EINK_LIMIT_RATE_RESPONSIVE_SEC * 1000)) {
+        if (Throttle::isWithinTimespanMs(previousRunMs, 1000)) {
            refresh = SKIPPED;
            reason = EXCEEDED_RATELIMIT_FAST;
            LOG_DEBUG("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x", frameFlags);
@@ -123,7 +123,7 @@ static bool heartbeat = false;

 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)

-/// Check if the display can render a string (detect special chars; emoji)
+// Check if the display can render a string (detect special chars; emoji)
 static bool haveGlyphs(const char *str)
 {
 #if defined(OLED_PL) || defined(OLED_UA) || defined(OLED_RU) || defined(OLED_CS)
@@ -162,11 +162,7 @@ static void drawIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDispl

    display->setFont(FONT_MEDIUM);
    display->setTextAlignment(TEXT_ALIGN_LEFT);
-#ifdef USERPREFS_SPLASH_TITLE
-    const char *title = USERPREFS_SPLASH_TITLE;
-#else
    const char *title = "meshtastic.org";
-#endif
    display->drawString(x + getStringCenteredX(title), y + SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM, title);
    display->setFont(FONT_SMALL);

@@ -185,6 +181,56 @@ static void drawIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDispl
    display->setTextAlignment(TEXT_ALIGN_LEFT); // Restore left align, just to be kind to any other unsuspecting code
 }

+#ifdef USERPREFS_OEM_TEXT
+
+static void drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    static const uint8_t xbm[] = USERPREFS_OEM_IMAGE_DATA;
+    display->drawXbm(x + (SCREEN_WIDTH - USERPREFS_OEM_IMAGE_WIDTH) / 2,
+                     y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - USERPREFS_OEM_IMAGE_HEIGHT) / 2 + 2, USERPREFS_OEM_IMAGE_WIDTH,
+                     USERPREFS_OEM_IMAGE_HEIGHT, xbm);
+
+    switch (USERPREFS_OEM_FONT_SIZE) {
+    case 0:
+        display->setFont(FONT_SMALL);
+        break;
+    case 2:
+        display->setFont(FONT_LARGE);
+        break;
+    default:
+        display->setFont(FONT_MEDIUM);
+        break;
+    }
+
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    const char *title = USERPREFS_OEM_TEXT;
+    display->drawString(x + getStringCenteredX(title), y + SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM, title);
+    display->setFont(FONT_SMALL);
+
+    // Draw region in upper left
+    if (upperMsg)
+        display->drawString(x + 0, y + 0, upperMsg);
+
+    // Draw version and shortname in upper right
+    char buf[25];
+    snprintf(buf, sizeof(buf), "%s\n%s", xstr(APP_VERSION_SHORT), haveGlyphs(owner.short_name) ? owner.short_name : "");
+
+    display->setTextAlignment(TEXT_ALIGN_RIGHT);
+    display->drawString(x + SCREEN_WIDTH, y + 0, buf);
+    screen->forceDisplay();
+
+    display->setTextAlignment(TEXT_ALIGN_LEFT); // Restore left align, just to be kind to any other unsuspecting code
+}
+
+static void drawOEMBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    // Draw region in upper left
+    const char *region = myRegion ? myRegion->name : NULL;
+    drawOEMIconScreen(region, display, state, x, y);
+}
+
+#endif
+
 void Screen::drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *message)
 {
    uint16_t x_offset = display->width() / 2;
@@ -1400,9 +1446,9 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_

    static char distStr[20];
    if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
-        strncpy(distStr, "? mi", sizeof(distStr)); // might not have location data
+        strncpy(distStr, "? mi ?°", sizeof(distStr)); // might not have location data
    } else {
-        strncpy(distStr, "? km", sizeof(distStr));
+        strncpy(distStr, "? km ?°", sizeof(distStr));
    }
    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
    const char *fields[] = {username, lastStr, signalStr, distStr, NULL};
@@ -1435,18 +1481,6 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
            float d =
                GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));

-            if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
-                if (d < (2 * MILES_TO_FEET))
-                    snprintf(distStr, sizeof(distStr), "%.0f ft", d * METERS_TO_FEET);
-                else
-                    snprintf(distStr, sizeof(distStr), "%.1f mi", d * METERS_TO_FEET / MILES_TO_FEET);
-            } else {
-                if (d < 2000)
-                    snprintf(distStr, sizeof(distStr), "%.0f m", d);
-                else
-                    snprintf(distStr, sizeof(distStr), "%.1f km", d / 1000);
-            }
-
            float bearingToOther =
                GeoCoord::bearing(DegD(op.latitude_i), DegD(op.longitude_i), DegD(p.latitude_i), DegD(p.longitude_i));
            // If the top of the compass is a static north then bearingToOther can be drawn on the compass directly
@@ -1454,6 +1488,23 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
            if (!config.display.compass_north_top)
                bearingToOther -= myHeading;
            screen->drawNodeHeading(display, compassX, compassY, compassDiam, bearingToOther);
+
+            float bearingToOtherDegrees = (bearingToOther < 0) ? bearingToOther + 2*PI : bearingToOther;
+            bearingToOtherDegrees = bearingToOtherDegrees * 180 / PI;
+
+            if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
+                if (d < (2 * MILES_TO_FEET))
+                    snprintf(distStr, sizeof(distStr), "%.0fft   %.0f°", d * METERS_TO_FEET, bearingToOtherDegrees);
+                else
+                    snprintf(distStr, sizeof(distStr), "%.1fmi   %.0f°", d * METERS_TO_FEET / MILES_TO_FEET, bearingToOtherDegrees);
+            } else {
+                if (d < 2000)
+                    snprintf(distStr, sizeof(distStr), "%.0fm   %.0f°", d, bearingToOtherDegrees);
+                else
+                    snprintf(distStr, sizeof(distStr), "%.1fkm   %.0f°", d / 1000, bearingToOtherDegrees);
+            }
+
+
        }
    }
    if (!hasNodeHeading) {
@@ -1658,6 +1709,10 @@ void Screen::setup()
    // Set the utf8 conversion function
    dispdev->setFontTableLookupFunction(customFontTableLookup);

+#ifdef USERPREFS_OEM_TEXT
+    logo_timeout *= 2; // Double the time if we have a custom logo
+#endif
+
    // Add frames.
    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST);
    alertFrames[0] = [this](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
@@ -1803,6 +1858,22 @@ int32_t Screen::runOnce()
        showingBootScreen = false;
    }

+#ifdef USERPREFS_OEM_TEXT
+    static bool showingOEMBootScreen = true;
+    if (showingOEMBootScreen && (millis() > ((logo_timeout / 2) + serialSinceMsec))) {
+        LOG_INFO("Switch to OEM screen...");
+        // Change frames.
+        static FrameCallback bootOEMFrames[] = {drawOEMBootScreen};
+        static const int bootOEMFrameCount = sizeof(bootOEMFrames) / sizeof(bootOEMFrames[0]);
+        ui->setFrames(bootOEMFrames, bootOEMFrameCount);
+        ui->update();
+#ifndef USE_EINK
+        ui->update();
+#endif
+        showingOEMBootScreen = false;
+    }
+#endif
+
 #ifndef DISABLE_WELCOME_UNSET
    if (showingNormalScreen && config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
        setWelcomeFrames();
@@ -278,6 +278,10 @@ class Screen : public concurrency::OSThread
    bool hasHeading() { return hasCompass; }

    long getHeading() { return compassHeading; }
+
+    void setEndCalibration(uint32_t _endCalibrationAt) { endCalibrationAt = _endCalibrationAt; }
+    uint32_t getEndCalibration() { return endCalibrationAt; }
+
    // functions for display brightness
    void increaseBrightness();
    void decreaseBrightness();
@@ -673,6 +677,8 @@ class Screen : public concurrency::OSThread

    bool hasCompass = false;
    float compassHeading;
+    uint32_t endCalibrationAt;
+
    /// Holds state for debug information
    DebugInfo debugInfo;

@@ -16,49 +16,61 @@
 #include "graphics/fonts/OLEDDisplayFontsCS.h"
 #endif

+#ifdef OLED_PL
+#define FONT_SMALL_LOCAL ArialMT_Plain_10_PL
+#else
+#ifdef OLED_RU
+#define FONT_SMALL_LOCAL ArialMT_Plain_10_RU
+#else
+#ifdef OLED_UA
+#define FONT_SMALL_LOCAL ArialMT_Plain_10_UA // Height: 13
+#else
+#ifdef OLED_CS
+#define FONT_SMALL_LOCAL ArialMT_Plain_10_CS
+#else
+#define FONT_SMALL_LOCAL ArialMT_Plain_10 // Height: 13
+#endif
+#endif
+#endif
+#endif
+#ifdef OLED_PL
+#define FONT_MEDIUM_LOCAL ArialMT_Plain_16_PL // Height: 19
+#else
+#ifdef OLED_UA
+#define FONT_MEDIUM_LOCAL ArialMT_Plain_16_UA // Height: 19
+#else
+#ifdef OLED_CS
+#define FONT_MEDIUM_LOCAL ArialMT_Plain_16_CS
+#else
+#define FONT_MEDIUM_LOCAL ArialMT_Plain_16 // Height: 19
+#endif
+#endif
+#endif
+#ifdef OLED_PL
+#define FONT_LARGE_LOCAL ArialMT_Plain_24_PL // Height: 28
+#else
+#ifdef OLED_UA
+#define FONT_LARGE_LOCAL ArialMT_Plain_24_UA // Height: 28
+#else
+#ifdef OLED_CS
+#define FONT_LARGE_LOCAL ArialMT_Plain_24_CS // Height: 28
+#else
+#define FONT_LARGE_LOCAL ArialMT_Plain_24 // Height: 28
+#endif
+#endif
+#endif
+
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
     defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS)) &&                                                         \
    !defined(DISPLAY_FORCE_SMALL_FONTS)
 // The screen is bigger so use bigger fonts
-#define FONT_SMALL ArialMT_Plain_16  // Height: 19
-#define FONT_MEDIUM ArialMT_Plain_24 // Height: 28
-#define FONT_LARGE ArialMT_Plain_24  // Height: 28
+#define FONT_SMALL FONT_MEDIUM_LOCAL // Height: 19
+#define FONT_MEDIUM FONT_LARGE_LOCAL // Height: 28
+#define FONT_LARGE FONT_LARGE_LOCAL  // Height: 28
 #else
-#ifdef OLED_PL
-#define FONT_SMALL ArialMT_Plain_10_PL
-#else
-#ifdef OLED_RU
-#define FONT_SMALL ArialMT_Plain_10_RU
-#else
-#ifdef OLED_UA
-#define FONT_SMALL ArialMT_Plain_10_UA // Height: 13
-#else
-#ifdef OLED_CS
-#define FONT_SMALL ArialMT_Plain_10_CS
-#else
-#define FONT_SMALL ArialMT_Plain_10 // Height: 13
-#endif
-#endif
-#endif
-#endif
-#ifdef OLED_UA
-#define FONT_MEDIUM ArialMT_Plain_16_UA // Height: 19
-#else
-#ifdef OLED_CS
-#define FONT_MEDIUM ArialMT_Plain_16_CS
-#else
-#define FONT_MEDIUM ArialMT_Plain_16 // Height: 19
-#endif
-#endif
-#ifdef OLED_UA
-#define FONT_LARGE ArialMT_Plain_24_UA // Height: 28
-#else
-#ifdef OLED_CS
-#define FONT_LARGE ArialMT_Plain_24_CS // Height: 28
-#else
-#define FONT_LARGE ArialMT_Plain_24 // Height: 28
-#endif
-#endif
+#define FONT_SMALL FONT_SMALL_LOCAL   // Height: 13
+#define FONT_MEDIUM FONT_MEDIUM_LOCAL // Height: 19
+#define FONT_LARGE FONT_LARGE_LOCAL   // Height: 28
 #endif

 #define _fontHeight(font) ((font)[1] + 1) // height is position 1
@@ -7,7 +7,7 @@ const uint8_t ArialMT_Plain_10_CS[] PROGMEM = {
    0x20, // First char: 32
    0xE0, // Number of chars: 224
    // Jump Table:
-    0xFF, 0xFF, 0x00, 0x0A, // 32
+    0xFF, 0xFF, 0x00, 0x03, // 32
    0x00, 0x00, 0x04, 0x03, // 33
    0x00, 0x04, 0x05, 0x04, // 34
    0x00, 0x09, 0x09, 0x06, // 35
@@ -453,7 +453,7 @@ const uint8_t ArialMT_Plain_16_CS[] PROGMEM = {
    0x20, // First char: 32
    0xE0, // Number of chars: 224
    // Jump Table:
-    0xFF, 0xFF, 0x00, 0x10, // 32
+    0xFF, 0xFF, 0x00, 0x04, // 32
    0x00, 0x00, 0x08, 0x04, // 33
    0x00, 0x08, 0x0D, 0x06, // 34
    0x00, 0x15, 0x1A, 0x0A, // 35
@@ -1036,7 +1036,7 @@ const uint8_t ArialMT_Plain_24_CS[] PROGMEM = {
    0x20, // First char: 32
    0xE0, // Number of chars: 224
    // Jump Table:
-    0xFF, 0xFF, 0x00, 0x18, // 32
+    0xFF, 0xFF, 0x00, 0x06, // 32
    0x00, 0x00, 0x13, 0x06, // 33
    0x00, 0x13, 0x1A, 0x08, // 34
    0x00, 0x2D, 0x33, 0x0E, // 35
@@ -6,6 +6,7 @@
 #elif __MBED__
 #define PROGMEM
 #endif
-
 extern const uint8_t ArialMT_Plain_10_PL[] PROGMEM;
+extern const uint8_t ArialMT_Plain_16_PL[] PROGMEM;
+extern const uint8_t ArialMT_Plain_24_PL[] PROGMEM;
 #endif
@@ -7,6 +7,9 @@
 #include "ScanAndSelect.h"
 #include "modules/CannedMessageModule.h"
 #include <Throttle.h>
+#ifdef ARCH_PORTDUINO // Only to check for pin conflict with user button
+#include "platform/portduino/PortduinoGlue.h"
+#endif

 // Config
 static const char name[] = "scanAndSelect"; // should match "allow input source" string
@@ -30,7 +33,9 @@ bool ScanAndSelectInput::init()
    if (strcasecmp(moduleConfig.canned_message.allow_input_source, name) != 0)
        return false;

-    // Use any available inputbroker pin as the button
+    // Determine which pin to use for the single scan-and-select button
+    // User can specify this by setting any of the inputbroker pins
+    // If all values are zero, we'll assume the user *does* want GPIO0
    if (moduleConfig.canned_message.inputbroker_pin_press)
        pin = moduleConfig.canned_message.inputbroker_pin_press;
    else if (moduleConfig.canned_message.inputbroker_pin_a)
@@ -38,7 +43,25 @@ bool ScanAndSelectInput::init()
    else if (moduleConfig.canned_message.inputbroker_pin_b)
        pin = moduleConfig.canned_message.inputbroker_pin_b;
    else
-        return false; // Short circuit: no button found
+        pin = 0; // GPIO 0 then
+
+        // Short circuit: if selected pin conficts with the user button
+#if defined(ARCH_PORTDUINO)
+    int pinUserButton = 0;
+    if (settingsMap.count(user) != 0) {
+        pinUserButton = settingsMap[user];
+    }
+#elif defined(USERPREFS_BUTTON_PIN)
+    int pinUserButton = config.device.button_gpio ? config.device.button_gpio : USERPREFS_BUTTON_PIN;
+#elif defined(BUTTON_PIN)
+    int pinUserButton = config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN;
+#else
+    int pinUserButton = config.device.button_gpio;
+#endif
+    if (pin == pinUserButton) {
+        LOG_ERROR("ScanAndSelect conflict with user button");
+        return false;
+    }

    // Set-up the button
    pinMode(pin, INPUT_PULLUP);
@@ -92,6 +92,7 @@ NRF52Bluetooth *nrf52Bluetooth = nullptr;
 #include "mesh/raspihttp/PiWebServer.h"
 #include "platform/portduino/PortduinoGlue.h"
 #include "platform/portduino/USBHal.h"
+#include <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <string>
@@ -614,6 +615,7 @@ void setup()
    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::ICM20948, meshtastic_TelemetrySensorType_ICM20948);
    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MAX30102, meshtastic_TelemetrySensorType_MAX30102);
    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::CGRADSENS, meshtastic_TelemetrySensorType_RADSENS);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DFROBOT_RAIN, meshtastic_TelemetrySensorType_DFROBOT_RAIN);

    i2cScanner.reset();
 #endif
@@ -835,116 +837,56 @@ void setup()
 #endif

 #ifdef ARCH_PORTDUINO
-    if (settingsMap[use_sx1262]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate sx1262 radio on SPI port %s", settingsStrings[spidev].c_str());
+    const struct {
+        configNames cfgName;
+        std::string strName;
+    } loraModules[] = {{use_rf95, "RF95"},     {use_sx1262, "sx1262"}, {use_sx1268, "sx1268"}, {use_sx1280, "sx1280"},
+                       {use_lr1110, "lr1110"}, {use_lr1120, "lr1120"}, {use_lr1121, "lr1121"}, {use_llcc68, "LLCC68"}};
+    // as one can't use a function pointer to the class constructor:
+    auto loraModuleInterface = [](configNames cfgName, LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq,
+                                  RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy) {
+        switch (cfgName) {
+        case use_rf95:
+            return (RadioInterface *)new RF95Interface(hal, cs, irq, rst, busy);
+        case use_sx1262:
+            return (RadioInterface *)new SX1262Interface(hal, cs, irq, rst, busy);
+        case use_sx1268:
+            return (RadioInterface *)new SX1268Interface(hal, cs, irq, rst, busy);
+        case use_sx1280:
+            return (RadioInterface *)new SX1280Interface(hal, cs, irq, rst, busy);
+        case use_lr1110:
+            return (RadioInterface *)new LR1110Interface(hal, cs, irq, rst, busy);
+        case use_lr1120:
+            return (RadioInterface *)new LR1120Interface(hal, cs, irq, rst, busy);
+        case use_lr1121:
+            return (RadioInterface *)new LR1121Interface(hal, cs, irq, rst, busy);
+        case use_llcc68:
+            return (RadioInterface *)new LLCC68Interface(hal, cs, irq, rst, busy);
+        default:
+            assert(0); // shouldn't happen
+            return (RadioInterface *)nullptr;
+        }
+    };
+    for (auto &loraModule : loraModules) {
+        if (settingsMap[loraModule.cfgName] && !rIf) {
+            LOG_DEBUG("Activate %s radio on SPI port %s", loraModule.strName.c_str(), settingsStrings[spidev].c_str());
            if (settingsStrings[spidev] == "ch341") {
                RadioLibHAL = ch341Hal;
            } else {
                RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
            }
-            rIf = new SX1262Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                      settingsMap[busy]);
+            rIf = loraModuleInterface(loraModule.cfgName, (LockingArduinoHal *)RadioLibHAL, settingsMap[cs_pin],
+                                      settingsMap[irq_pin], settingsMap[reset_pin], settingsMap[busy_pin]);
            if (!rIf->init()) {
-                LOG_WARN("No SX1262 radio");
-                delete rIf;
-                exit(EXIT_FAILURE);
-            } else {
-                LOG_INFO("SX1262 init success");
-            }
-        }
-    } else if (settingsMap[use_rf95]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate rf95 radio on SPI port %s", settingsStrings[spidev].c_str());
-            RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-            rIf = new RF95Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                    settingsMap[busy]);
-            if (!rIf->init()) {
-                LOG_WARN("No RF95 radio");
+                LOG_WARN("No %s radio", loraModule.strName.c_str());
                delete rIf;
                rIf = NULL;
                exit(EXIT_FAILURE);
            } else {
-                LOG_INFO("RF95 init success");
-            }
-        }
-    } else if (settingsMap[use_sx1280]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate sx1280 radio on SPI port %s", settingsStrings[spidev].c_str());
-            RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-            rIf = new SX1280Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                      settingsMap[busy]);
-            if (!rIf->init()) {
-                LOG_WARN("No SX1280 radio");
-                delete rIf;
-                rIf = NULL;
-                exit(EXIT_FAILURE);
-            } else {
-                LOG_INFO("SX1280 init success");
-            }
-        }
-    } else if (settingsMap[use_lr1110]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate lr1110 radio on SPI port %s", settingsStrings[spidev].c_str());
-            LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-            rIf = new LR1110Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                      settingsMap[busy]);
-            if (!rIf->init()) {
-                LOG_WARN("No LR1110 radio");
-                delete rIf;
-                rIf = NULL;
-                exit(EXIT_FAILURE);
-            } else {
-                LOG_INFO("LR1110 init success");
-            }
-        }
-    } else if (settingsMap[use_lr1120]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate lr1120 radio on SPI port %s", settingsStrings[spidev].c_str());
-            LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-            rIf = new LR1120Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                      settingsMap[busy]);
-            if (!rIf->init()) {
-                LOG_WARN("No LR1120 radio");
-                delete rIf;
-                rIf = NULL;
-                exit(EXIT_FAILURE);
-            } else {
-                LOG_INFO("LR1120 init success");
-            }
-        }
-    } else if (settingsMap[use_lr1121]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate lr1121 radio on SPI port %s", settingsStrings[spidev].c_str());
-            LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-            rIf = new LR1121Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                      settingsMap[busy]);
-            if (!rIf->init()) {
-                LOG_WARN("No LR1121 radio");
-                delete rIf;
-                rIf = NULL;
-                exit(EXIT_FAILURE);
-            } else {
-                LOG_INFO("LR1121 init success");
-            }
-        }
-    } else if (settingsMap[use_sx1268]) {
-        if (!rIf) {
-            LOG_DEBUG("Activate sx1268 radio on SPI port %s", settingsStrings[spidev].c_str());
-            RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-            rIf = new SX1268Interface((LockingArduinoHal *)RadioLibHAL, settingsMap[cs], settingsMap[irq], settingsMap[reset],
-                                      settingsMap[busy]);
-            if (!rIf->init()) {
-                LOG_WARN("No SX1268 radio");
-                delete rIf;
-                rIf = NULL;
-                exit(EXIT_FAILURE);
-            } else {
-                LOG_INFO("SX1268 init success");
+                LOG_INFO("%s init success", loraModule.strName.c_str());
            }
        }
    }
-
 #elif defined(HW_SPI1_DEVICE)
    LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI1, spiSettings);
 #else // HW_SPI1_DEVICE
@@ -996,13 +938,16 @@ void setup()

 #if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && !defined(TCXO_OPTIONAL) && RADIOLIB_EXCLUDE_SX126X != 1
    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        if (!rIf->init()) {
+        auto *sxIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
+#endif
+        if (!sxIf->init()) {
            LOG_WARN("No SX1262 radio");
-            delete rIf;
-            rIf = NULL;
+            delete sxIf;
        } else {
            LOG_INFO("SX1262 init success");
+            rIf = sxIf;
            radioType = SX1262_RADIO;
        }
    }
@@ -1010,29 +955,28 @@ void setup()

 #if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && defined(TCXO_OPTIONAL)
    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        // Try using the specified TCXO voltage
-        rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        if (!rIf->init()) {
-            LOG_WARN("No SX1262 radio with TCXO, Vref %f V", tcxoVoltage);
-            delete rIf;
-            rIf = NULL;
-            tcxoVoltage = 0; // if it fails, set the TCXO voltage to zero for the next attempt
+        // try using the specified TCXO voltage
+        auto *sxIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
+        if (!sxIf->init()) {
+            LOG_WARN("No SX1262 radio with TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
+            delete sxIf;
        } else {
-            LOG_WARN("SX1262 init success, TCXO, Vref %f V", tcxoVoltage);
+            LOG_INFO("SX1262 init success, TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
+            rIf = sxIf;
            radioType = SX1262_RADIO;
        }
    }

    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        // If specified TCXO voltage fails, attempt to use DIO3 as a reference instea
+        // If specified TCXO voltage fails, attempt to use DIO3 as a reference instead
        rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
        if (!rIf->init()) {
-            LOG_WARN("No SX1262 radio with XTAL, Vref %f V", tcxoVoltage);
+            LOG_WARN("No SX1262 radio with XTAL, Vref 0.0V");
            delete rIf;
            rIf = NULL;
-            tcxoVoltage = SX126X_DIO3_TCXO_VOLTAGE; // if it fails, set the TCXO voltage back for the next radio search
        } else {
-            LOG_INFO("SX1262 init success, XTAL, Vref %f V", tcxoVoltage);
+            LOG_INFO("SX1262 init success, XTAL, Vref 0.0V");
            radioType = SX1262_RADIO;
        }
    }
@@ -1169,6 +1113,7 @@ void setup()
 #if __has_include(<ulfius.h>)
    if (settingsMap[webserverport] != -1) {
        piwebServerThread = new PiWebServerThread();
+        std::atexit([] { delete piwebServerThread; });
    }
 #endif
    initApiServer(TCPPort);
@@ -20,12 +20,18 @@ static const Module::RfSwitchMode_t rfswitch_table[] = {

 // Particular boards might define a different max power based on what their hardware can do, default to max power output if not
 // specified (may be dangerous if using external PA and LR11x0 power config forgotten)
+#if ARCH_PORTDUINO
+#define LR1110_MAX_POWER settingsMap[lr1110_max_power]
+#endif
 #ifndef LR1110_MAX_POWER
 #define LR1110_MAX_POWER 22
 #endif

 // the 2.4G part maxes at 13dBm

+#if ARCH_PORTDUINO
+#define LR1120_MAX_POWER settingsMap[lr1120_max_power]
+#endif
 #ifndef LR1120_MAX_POWER
 #define LR1120_MAX_POWER 13
 #endif
@@ -10,6 +10,7 @@
 std::vector<MeshModule *> *MeshModule::modules;

 const meshtastic_MeshPacket *MeshModule::currentRequest;
+uint8_t MeshModule::numPeriodicModules = 0;

 /**
 * If any of the current chain of modules has already sent a reply, it will be here.  This is useful to allow
@@ -35,6 +36,15 @@ MeshModule::~MeshModule()
    modules->erase(it);
 }

+// ⚠️ **Only call once** to set the initial delay before a module starts broadcasting periodically
+int32_t MeshModule::setStartDelay()
+{
+    int32_t startDelay = MESHMODULE_MIN_BROADCAST_DELAY_MS + numPeriodicModules * MESHMODULE_BROADCAST_SPACING_MS;
+    numPeriodicModules++;
+
+    return startDelay;
+}
+
 meshtastic_MeshPacket *MeshModule::allocAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex,
                                               uint8_t hopLimit)
 {
@@ -9,6 +9,9 @@
 #include <OLEDDisplayUi.h>
 #endif

+#define MESHMODULE_MIN_BROADCAST_DELAY_MS 30 * 1000 // Min. delay after boot before sending first broadcast by any module
+#define MESHMODULE_BROADCAST_SPACING_MS 15 * 1000   // Initial spacing between broadcasts of different modules
+
 /** handleReceived return enumeration
 *
 * Use ProcessMessage::CONTINUE to allows other modules to process a message.
@@ -119,6 +122,12 @@ class MeshModule
     */
    static const meshtastic_MeshPacket *currentRequest;

+    // We keep track of the number of modules that send a periodic broadcast to schedule them spaced out over time
+    static uint8_t numPeriodicModules;
+
+    // Set the start delay for module that broadcasts periodically
+    int32_t setStartDelay();
+
    /**
     * If your handler wants to send a response, simply set currentReply and it will be sent at the end of response handling.
     */
@@ -69,7 +69,11 @@ bool MeshPacketQueue::enqueue(meshtastic_MeshPacket *p)
 {
    // no space - try to replace a lower priority packet in the queue
    if (queue.size() >= maxLen) {
-        return replaceLowerPriorityPacket(p);
+        bool replaced = replaceLowerPriorityPacket(p);
+        if (!replaced) {
+            LOG_WARN("TX queue is full, and there is no lower-priority packet available to evict in favour of 0x%08x", p->id);
+        }
+        return replaced;
    }

    // Find the correct position using upper_bound to maintain a stable order
@@ -113,7 +117,10 @@ meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id, bool t
    return NULL;
 }

-/** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
+/**
+ * Attempt to find a lower-priority packet in the queue and replace it with the provided one.
+ * @return True if the replacement succeeded, false otherwise
+ */
 bool MeshPacketQueue::replaceLowerPriorityPacket(meshtastic_MeshPacket *p)
 {

@@ -122,11 +129,12 @@ bool MeshPacketQueue::replaceLowerPriorityPacket(meshtastic_MeshPacket *p)
    }

    // Check if the packet at the back has a lower priority than the new packet
-    auto &backPacket = queue.back();
+    auto *backPacket = queue.back();
    if (!backPacket->tx_after && backPacket->priority < p->priority) {
+        LOG_WARN("Dropping packet 0x%08x to make room in the TX queue for higher-priority packet 0x%08x", backPacket->id, p->id);
        // Remove the back packet
-        packetPool.release(backPacket);
        queue.pop_back();
+        packetPool.release(backPacket);
        // Insert the new packet in the correct order
        enqueue(p);
        return true;
@@ -139,8 +147,12 @@ bool MeshPacketQueue::replaceLowerPriorityPacket(meshtastic_MeshPacket *p)
        for (; refPacket->tx_after && it != queue.begin(); refPacket = *--it)
            ;
        if (!refPacket->tx_after && refPacket->priority < p->priority) {
+            LOG_WARN("Dropping non-late packet 0x%08x to make room in the TX queue for higher-priority packet 0x%08x",
+                     refPacket->id, p->id);
+            queue.erase(it);
            packetPool.release(refPacket);
-            enqueue(refPacket);
+            // Insert the new packet in the correct order
+            enqueue(p);
            return true;
        }
    }
@@ -64,7 +64,8 @@ class MeshService
            return true;
        }
        return p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP ||
-               p->decoded.portnum == meshtastic_PortNum_DETECTION_SENSOR_APP;
+               p->decoded.portnum == meshtastic_PortNum_DETECTION_SENSOR_APP ||
+               p->decoded.portnum == meshtastic_PortNum_ALERT_APP;
    }
    /// Called when some new packets have arrived from one of the radios
    Observable<uint32_t> fromNumChanged;
@@ -23,7 +23,6 @@
 #include "modules/NeighborInfoModule.h"
 #include <ErriezCRC32.h>
 #include <algorithm>
-#include <iostream>
 #include <pb_decode.h>
 #include <pb_encode.h>
 #include <vector>
@@ -199,9 +198,8 @@ NodeDB::NodeDB()
    uint32_t channelFileCRC = crc32Buffer(&channelFile, sizeof(channelFile));

    int saveWhat = 0;
-    // bool hasUniqueId = false;
    // Get device unique id
-#if defined(ARCH_ESP32) && defined(ESP_EFUSE_OPTIONAL_UNIQUE_ID)
+#if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
    uint32_t unique_id[4];
    // ESP32 factory burns a unique id in efuse for S2+ series and evidently C3+ series
    // This is used for HMACs in the esp-rainmaker AIOT platform and seems to be a good choice for us
@@ -209,7 +207,6 @@ NodeDB::NodeDB()
    if (err == ESP_OK) {
        memcpy(myNodeInfo.device_id.bytes, unique_id, sizeof(unique_id));
        myNodeInfo.device_id.size = 16;
-        hasUniqueId = true;
    } else {
        LOG_WARN("Failed to read unique id from efuse");
    }
@@ -223,12 +220,12 @@ NodeDB::NodeDB()
    memcpy(myNodeInfo.device_id.bytes + sizeof(device_id_start), &device_id_end, sizeof(device_id_end));
    myNodeInfo.device_id.size = 16;
    // Uncomment below to print the device id
-    // hasUniqueId = true;
+
 #else
    // FIXME - implement for other platforms
 #endif

-    // if (hasUniqueId) {
+    // if (myNodeInfo.device_id.size == 16) {
    //     std::string deviceIdHex;
    //     for (size_t i = 0; i < myNodeInfo.device_id.size; ++i) {
    //         char buf[3];
@@ -425,7 +422,7 @@ bool NodeDB::resetRadioConfig(bool factory_reset)
        rebootAtMsec = millis() + (5 * 1000);
    }

-#if (defined(T_DECK) || defined(T_WATCH_S3) || defined(UNPHONE) || defined(PICOMPUTER_S3)) && defined(HAS_TFT)
+#if (defined(T_DECK) || defined(T_WATCH_S3) || defined(UNPHONE) || defined(PICOMPUTER_S3)) && HAS_TFT
    // as long as PhoneAPI shares BT and TFT app switch BT off
    config.bluetooth.enabled = false;
    if (moduleConfig.external_notification.nag_timeout == 60)
@@ -4,7 +4,11 @@
 #include <unordered_set>

 /// We clear our old flood record 10 minutes after we see the last of it
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+#define FLOOD_EXPIRE_TIME (5 * 1000L) // Don't allow too many packets to accumulate when fuzzing.
+#else
 #define FLOOD_EXPIRE_TIME (10 * 60 * 1000L)
+#endif

 /**
 * A record of a recent message broadcast
@@ -9,6 +9,9 @@
 #include "PortduinoGlue.h"
 #endif

+#if ARCH_PORTDUINO
+#define RF95_MAX_POWER settingsMap[rf95_max_power]
+#endif
 #ifndef RF95_MAX_POWER
 #define RF95_MAX_POWER 20
 #endif
@@ -91,16 +94,16 @@ void RF95Interface::setTransmitEnable(bool txon)
 #ifdef RF95_TXEN
    digitalWrite(RF95_TXEN, txon ? 1 : 0);
 #elif ARCH_PORTDUINO
-    if (settingsMap[txen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[txen], txon ? 1 : 0);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], txon ? 1 : 0);
    }
 #endif

 #ifdef RF95_RXEN
    digitalWrite(RF95_RXEN, txon ? 0 : 1);
 #elif ARCH_PORTDUINO
-    if (settingsMap[rxen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[rxen], txon ? 0 : 1);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], txon ? 0 : 1);
    }
 #endif
 }
@@ -164,13 +167,13 @@ bool RF95Interface::init()
    digitalWrite(RF95_RXEN, 1);
 #endif
 #if ARCH_PORTDUINO
-    if (settingsMap[txen] != RADIOLIB_NC) {
-        pinMode(settingsMap[txen], OUTPUT);
-        digitalWrite(settingsMap[txen], 0);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[txen_pin], OUTPUT);
+        digitalWrite(settingsMap[txen_pin], 0);
    }
-    if (settingsMap[rxen] != RADIOLIB_NC) {
-        pinMode(settingsMap[rxen], OUTPUT);
-        digitalWrite(settingsMap[rxen], 0);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[rxen_pin], OUTPUT);
+        digitalWrite(settingsMap[rxen_pin], 0);
    }
 #endif
    setTransmitEnable(false);
@@ -297,7 +297,7 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(float snr)

 void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
 {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
    std::string out = DEBUG_PORT.mt_sprintf("%s (id=0x%08x fr=0x%08x to=0x%08x, WantAck=%d, HopLim=%d Ch=0x%x", prefix, p->id,
                                            p->from, p->to, p->want_ack, p->hop_limit, p->channel);
    if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
@@ -271,6 +271,7 @@ void RadioLibInterface::onNotify(uint32_t notification)
                            uint32_t xmitMsec = getPacketTime(txp);
                            airTime->logAirtime(TX_LOG, xmitMsec);
                        }
+                        LOG_DEBUG("%d packets remain in the TX queue", txQueue.getMaxLen() - txQueue.getFree());
                    }
                }
            }
@@ -297,8 +298,8 @@ void RadioLibInterface::setTransmitDelay()
    if (p->tx_after) {
        unsigned long add_delay = p->rx_rssi ? getTxDelayMsecWeighted(p->rx_snr) : getTxDelayMsec();
        unsigned long now = millis();
-        p->tx_after = max(p->tx_after + add_delay, now + add_delay);
-        notifyLater(now - p->tx_after, TRANSMIT_DELAY_COMPLETED, false);
+        p->tx_after = min(max(p->tx_after + add_delay, now + add_delay), now + 2 * getTxDelayMsecWeightedWorst(p->rx_snr));
+        notifyLater(p->tx_after - now, TRANSMIT_DELAY_COMPLETED, false);
    } else if (p->rx_snr == 0 && p->rx_rssi == 0) {
        /* We assume if rx_snr = 0 and rx_rssi = 0, the packet was generated locally.
         *   This assumption is valid because of the offset generated by the radio to account for the noise
@@ -339,8 +340,11 @@ void RadioLibInterface::clampToLateRebroadcastWindow(NodeNum from, PacketId id)
    meshtastic_MeshPacket *p = txQueue.remove(from, id, true, false);
    if (p) {
        p->tx_after = millis() + getTxDelayMsecWeightedWorst(p->rx_snr);
-        txQueue.enqueue(p);
-        LOG_DEBUG("Move existing queued packet to the late rebroadcast window %dms from now", p->tx_after - millis());
+        if (txQueue.enqueue(p)) {
+            LOG_DEBUG("Move existing queued packet to the late rebroadcast window %dms from now", p->tx_after - millis());
+        } else {
+            packetPool.release(p);
+        }
    }
 }

@@ -501,14 +505,13 @@ bool RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
            powerMon->clearState(meshtastic_PowerMon_State_Lora_TXOn); // Transmitter off now
            startReceive(); // Restart receive mode (because startTransmit failed to put us in xmit mode)
        } else {
+            // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register
+            // bits
+            enableInterrupt(isrTxLevel0);
            lastTxStart = millis();
            printPacket("Started Tx", txp);
        }

-        // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register
-        // bits
-        enableInterrupt(isrTxLevel0);
-
        return res == RADIOLIB_ERR_NONE;
    }
 }
@@ -11,6 +11,9 @@

 // Particular boards might define a different max power based on what their hardware can do, default to max power output if not
 // specified (may be dangerous if using external PA and SX126x power config forgotten)
+#if ARCH_PORTDUINO
+#define SX126X_MAX_POWER settingsMap[sx126x_max_power]
+#endif
 #ifndef SX126X_MAX_POWER
 #define SX126X_MAX_POWER 22
 #endif
@@ -50,22 +53,13 @@ template <typename T> bool SX126xInterface<T>::init()
 #endif

 #if ARCH_PORTDUINO
-    float tcxoVoltage = (float)settingsMap[dio3_tcxo_voltage] / 1000;
-    if (settingsMap[sx126x_ant_sw] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[sx126x_ant_sw], HIGH);
-        pinMode(settingsMap[sx126x_ant_sw], OUTPUT);
+    tcxoVoltage = (float)settingsMap[dio3_tcxo_voltage] / 1000;
+    if (settingsMap[sx126x_ant_sw_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[sx126x_ant_sw_pin], HIGH);
+        pinMode(settingsMap[sx126x_ant_sw_pin], OUTPUT);
    }
-// FIXME: correct logic to default to not using TCXO if no voltage is specified for SX126X_DIO3_TCXO_VOLTAGE
-#elif !defined(SX126X_DIO3_TCXO_VOLTAGE)
-    float tcxoVoltage =
-        0; // "TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip." per
-           // https://github.com/jgromes/RadioLib/blob/690a050ebb46e6097c5d00c371e961c1caa3b52e/src/modules/SX126x/SX126x.h#L471C26-L471C104
-    // (DIO3 is free to be used as an IRQ)
-#elif !defined(TCXO_OPTIONAL)
-    float tcxoVoltage = SX126X_DIO3_TCXO_VOLTAGE;
-    // (DIO3 is not free to be used as an IRQ)
 #endif
-    if (tcxoVoltage == 0)
+    if (tcxoVoltage == 0.0)
        LOG_DEBUG("SX126X_DIO3_TCXO_VOLTAGE not defined, not using DIO3 as TCXO reference voltage");
    else
        LOG_DEBUG("SX126X_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V", tcxoVoltage);
@@ -83,7 +77,7 @@ template <typename T> bool SX126xInterface<T>::init()
    int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage, useRegulatorLDO);
    // \todo Display actual typename of the adapter, not just `SX126x`
    LOG_INFO("SX126x init result %d", res);
-    if (res == RADIOLIB_ERR_CHIP_NOT_FOUND)
+    if (res == RADIOLIB_ERR_CHIP_NOT_FOUND || res == RADIOLIB_ERR_SPI_CMD_FAILED)
        return false;

    LOG_INFO("Frequency set to %f", getFreq());
@@ -121,8 +115,9 @@ template <typename T> bool SX126xInterface<T>::init()
    // no effect
 #if ARCH_PORTDUINO
    if (res == RADIOLIB_ERR_NONE) {
-        LOG_DEBUG("Use MCU pin %i as RXEN and pin %i as TXEN to control RF switching", settingsMap[rxen], settingsMap[txen]);
-        lora.setRfSwitchPins(settingsMap[rxen], settingsMap[txen]);
+        LOG_DEBUG("Use MCU pin %i as RXEN and pin %i as TXEN to control RF switching", settingsMap[rxen_pin],
+                  settingsMap[txen_pin]);
+        lora.setRfSwitchPins(settingsMap[rxen_pin], settingsMap[txen_pin]);
    }
 #else
 #ifndef SX126X_RXEN
@@ -28,8 +28,11 @@ template <class T> class SX126xInterface : public RadioLibInterface

    bool isIRQPending() override { return lora.getIrqFlags() != 0; }

+    void setTCXOVoltage(float voltage) { tcxoVoltage = voltage; }
+
  protected:
    float currentLimit = 140; // Higher OCP limit for SX126x PA
+    float tcxoVoltage = 0.0;

    /**
     * Specific module instance
@@ -10,6 +10,9 @@
 #endif

 // Particular boards might define a different max power based on what their hardware can do
+#if ARCH_PORTDUINO
+#define SX128X_MAX_POWER settingsMap[sx128x_max_power]
+#endif
 #ifndef SX128X_MAX_POWER
 #define SX128X_MAX_POWER 13
 #endif
@@ -38,13 +41,13 @@ template <typename T> bool SX128xInterface<T>::init()
 #endif

 #if ARCH_PORTDUINO
-    if (settingsMap[rxen] != RADIOLIB_NC) {
-        pinMode(settingsMap[rxen], OUTPUT);
-        digitalWrite(settingsMap[rxen], LOW); // Set low before becoming an output
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[rxen_pin], OUTPUT);
+        digitalWrite(settingsMap[rxen_pin], LOW); // Set low before becoming an output
    }
-    if (settingsMap[txen] != RADIOLIB_NC) {
-        pinMode(settingsMap[txen], OUTPUT);
-        digitalWrite(settingsMap[txen], LOW); // Set low before becoming an output
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[txen_pin], OUTPUT);
+        digitalWrite(settingsMap[txen_pin], LOW); // Set low before becoming an output
    }
 #else
 #if defined(SX128X_RXEN) && (SX128X_RXEN != RADIOLIB_NC) // set not rx or tx mode
@@ -93,8 +96,8 @@ template <typename T> bool SX128xInterface<T>::init()
        lora.setRfSwitchPins(SX128X_RXEN, SX128X_TXEN);
    }
 #elif ARCH_PORTDUINO
-    if (res == RADIOLIB_ERR_NONE && settingsMap[rxen] != RADIOLIB_NC && settingsMap[txen] != RADIOLIB_NC) {
-        lora.setRfSwitchPins(settingsMap[rxen], settingsMap[txen]);
+    if (res == RADIOLIB_ERR_NONE && settingsMap[rxen_pin] != RADIOLIB_NC && settingsMap[txen_pin] != RADIOLIB_NC) {
+        lora.setRfSwitchPins(settingsMap[rxen_pin], settingsMap[txen_pin]);
    }
 #endif

@@ -174,11 +177,11 @@ template <typename T> void SX128xInterface<T>::setStandby()
        LOG_ERROR("SX128x standby %s%d", radioLibErr, err);
    assert(err == RADIOLIB_ERR_NONE);
 #if ARCH_PORTDUINO
-    if (settingsMap[rxen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[rxen], LOW);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], LOW);
    }
-    if (settingsMap[txen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[txen], LOW);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], LOW);
    }
 #else
 #if defined(SX128X_RXEN) && (SX128X_RXEN != RADIOLIB_NC) // we have RXEN/TXEN control - turn off RX and TX power
@@ -210,11 +213,11 @@ template <typename T> void SX128xInterface<T>::addReceiveMetadata(meshtastic_Mes
 template <typename T> void SX128xInterface<T>::configHardwareForSend()
 {
 #if ARCH_PORTDUINO
-    if (settingsMap[txen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[txen], HIGH);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], HIGH);
    }
-    if (settingsMap[rxen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[rxen], LOW);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], LOW);
    }

 #else
@@ -241,11 +244,11 @@ template <typename T> void SX128xInterface<T>::startReceive()
    setStandby();

 #if ARCH_PORTDUINO
-    if (settingsMap[rxen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[rxen], HIGH);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], HIGH);
    }
-    if (settingsMap[txen] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[txen], LOW);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], LOW);
    }

 #else
@@ -74,11 +74,17 @@ template <class T> class TypedQueue
 {
    std::queue<T> q;
    concurrency::OSThread *reader = NULL;
+    int maxElements;

  public:
-    explicit TypedQueue(int maxElements) {}
+    explicit TypedQueue(int _maxElements) : maxElements(_maxElements) {}

-    int numFree() { return 1; } // Always claim 1 free, because we can grow to any size
+    int numFree()
+    {
+        if (maxElements <= 0)
+            return 1; // Always claim 1 free, because we can grow to any size
+        return maxElements - numUsed();
+    }

    bool isEmpty() { return q.empty(); }

@@ -86,6 +92,9 @@ template <class T> class TypedQueue

    bool enqueue(T x, TickType_t maxWait = portMAX_DELAY)
    {
+        if (numFree() <= 0)
+            return false;
+
        if (reader) {
            reader->setInterval(0);
            concurrency::mainDelay.interrupt();
@@ -112,4 +121,4 @@ template <class T> class TypedQueue

    void setReader(concurrency::OSThread *t) { reader = t; }
 };
-#endif
+#endif
@@ -468,6 +468,9 @@ typedef struct _meshtastic_Config_DisplayConfig {
    bool wake_on_tap_or_motion;
    /* Indicates how to rotate or invert the compass output to accurate display on the display. */
    meshtastic_Config_DisplayConfig_CompassOrientation compass_orientation;
+    /* If false (default), the device will display the time in 24-hour format on screen.
+ If true, the device will display the time in 12-hour format on screen. */
+    bool use_12h_clock;
 } meshtastic_Config_DisplayConfig;

 /* Lora Config */
@@ -690,7 +693,7 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, "", 0}
 #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_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, 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, 0}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_default {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
@@ -701,7 +704,7 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, "", 0}
 #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_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, 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, 0}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_zero {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
@@ -765,6 +768,7 @@ extern "C" {
 #define meshtastic_Config_DisplayConfig_heading_bold_tag 9
 #define meshtastic_Config_DisplayConfig_wake_on_tap_or_motion_tag 10
 #define meshtastic_Config_DisplayConfig_compass_orientation_tag 11
+#define meshtastic_Config_DisplayConfig_use_12h_clock_tag 12
 #define meshtastic_Config_LoRaConfig_use_preset_tag 1
 #define meshtastic_Config_LoRaConfig_modem_preset_tag 2
 #define meshtastic_Config_LoRaConfig_bandwidth_tag 3
@@ -907,7 +911,8 @@ X(a, STATIC,   SINGULAR, UENUM,    oled,              7) \
 X(a, STATIC,   SINGULAR, UENUM,    displaymode,       8) \
 X(a, STATIC,   SINGULAR, BOOL,     heading_bold,      9) \
 X(a, STATIC,   SINGULAR, BOOL,     wake_on_tap_or_motion,  10) \
-X(a, STATIC,   SINGULAR, UENUM,    compass_orientation,  11)
+X(a, STATIC,   SINGULAR, UENUM,    compass_orientation,  11) \
+X(a, STATIC,   SINGULAR, BOOL,     use_12h_clock,    12)
 #define meshtastic_Config_DisplayConfig_CALLBACK NULL
 #define meshtastic_Config_DisplayConfig_DEFAULT NULL

@@ -985,7 +990,7 @@ extern const pb_msgdesc_t meshtastic_Config_SessionkeyConfig_msg;
 #define MESHTASTIC_MESHTASTIC_CONFIG_PB_H_MAX_SIZE meshtastic_Config_size
 #define meshtastic_Config_BluetoothConfig_size   10
 #define meshtastic_Config_DeviceConfig_size      98
-#define meshtastic_Config_DisplayConfig_size     30
+#define meshtastic_Config_DisplayConfig_size     32
 #define meshtastic_Config_LoRaConfig_size        85
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     202
@@ -187,7 +187,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalConfig_size
-#define meshtastic_LocalConfig_size              741
+#define meshtastic_LocalConfig_size              743
 #define meshtastic_LocalModuleConfig_size        699

 #ifdef __cplusplus
@@ -223,6 +223,9 @@ typedef enum _meshtastic_HardwareModel {
    /* Mesh-Tab, esp32 based
 https://github.com/valzzu/Mesh-Tab */
    meshtastic_HardwareModel_MESH_TAB = 86,
+    /* MeshLink board developed by LoraItalia. NRF52840, eByte E22900M22S (Will also come with other frequencies), 25w MPPT solar charger (5v,12v,18v selectable), support for gps, buzzer, oled or e-ink display, 10 gpios, hardware watchdog
+ https://www.loraitalia.it */
+    meshtastic_HardwareModel_MESHLINK = 87,
    /* ------------------------------------------------------------------------------------------------------------------------------------------
 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.
 ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -81,7 +81,9 @@ typedef enum _meshtastic_TelemetrySensorType {
    /* ClimateGuard RadSens, radiation, Geiger-Muller Tube */
    meshtastic_TelemetrySensorType_RADSENS = 33,
    /* High accuracy current and voltage */
-    meshtastic_TelemetrySensorType_INA226 = 34
+    meshtastic_TelemetrySensorType_INA226 = 34,
+    /* DFRobot Gravity tipping bucket rain gauge */
+    meshtastic_TelemetrySensorType_DFROBOT_RAIN = 35
 } meshtastic_TelemetrySensorType;

 /* Struct definitions */
@@ -162,6 +164,12 @@ typedef struct _meshtastic_EnvironmentMetrics {
    /* Radiation in µR/h */
    bool has_radiation;
    float radiation;
+    /* Rainfall in the last hour in mm */
+    bool has_rainfall_1h;
+    float rainfall_1h;
+    /* Rainfall in the last 24 hours in mm */
+    bool has_rainfall_24h;
+    float rainfall_24h;
 } meshtastic_EnvironmentMetrics;

 /* Power Metrics (voltage / current / etc) */
@@ -306,8 +314,8 @@ extern "C" {

 /* Helper constants for enums */
 #define _meshtastic_TelemetrySensorType_MIN meshtastic_TelemetrySensorType_SENSOR_UNSET
-#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_INA226
-#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_INA226+1))
+#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_DFROBOT_RAIN
+#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_DFROBOT_RAIN+1))



@@ -320,7 +328,7 @@ extern "C" {

 /* Initializer values for message structs */
 #define meshtastic_DeviceMetrics_init_default    {false, 0, false, 0, false, 0, false, 0, false, 0}
-#define meshtastic_EnvironmentMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
+#define meshtastic_EnvironmentMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_PowerMetrics_init_default     {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_AirQualityMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_LocalStats_init_default       {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -328,7 +336,7 @@ extern "C" {
 #define meshtastic_Telemetry_init_default        {0, 0, {meshtastic_DeviceMetrics_init_default}}
 #define meshtastic_Nau7802Config_init_default    {0, 0}
 #define meshtastic_DeviceMetrics_init_zero       {false, 0, false, 0, false, 0, false, 0, false, 0}
-#define meshtastic_EnvironmentMetrics_init_zero  {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
+#define meshtastic_EnvironmentMetrics_init_zero  {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_PowerMetrics_init_zero        {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_AirQualityMetrics_init_zero   {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_LocalStats_init_zero          {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -360,6 +368,8 @@ extern "C" {
 #define meshtastic_EnvironmentMetrics_wind_gust_tag 16
 #define meshtastic_EnvironmentMetrics_wind_lull_tag 17
 #define meshtastic_EnvironmentMetrics_radiation_tag 18
+#define meshtastic_EnvironmentMetrics_rainfall_1h_tag 19
+#define meshtastic_EnvironmentMetrics_rainfall_24h_tag 20
 #define meshtastic_PowerMetrics_ch1_voltage_tag  1
 #define meshtastic_PowerMetrics_ch1_current_tag  2
 #define meshtastic_PowerMetrics_ch2_voltage_tag  3
@@ -431,7 +441,9 @@ X(a, STATIC,   OPTIONAL, FLOAT,    wind_speed,       14) \
 X(a, STATIC,   OPTIONAL, FLOAT,    weight,           15) \
 X(a, STATIC,   OPTIONAL, FLOAT,    wind_gust,        16) \
 X(a, STATIC,   OPTIONAL, FLOAT,    wind_lull,        17) \
-X(a, STATIC,   OPTIONAL, FLOAT,    radiation,        18)
+X(a, STATIC,   OPTIONAL, FLOAT,    radiation,        18) \
+X(a, STATIC,   OPTIONAL, FLOAT,    rainfall_1h,      19) \
+X(a, STATIC,   OPTIONAL, FLOAT,    rainfall_24h,     20)
 #define meshtastic_EnvironmentMetrics_CALLBACK NULL
 #define meshtastic_EnvironmentMetrics_DEFAULT NULL

@@ -530,12 +542,12 @@ extern const pb_msgdesc_t meshtastic_Nau7802Config_msg;
 #define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size
 #define meshtastic_AirQualityMetrics_size        78
 #define meshtastic_DeviceMetrics_size            27
-#define meshtastic_EnvironmentMetrics_size       91
+#define meshtastic_EnvironmentMetrics_size       103
 #define meshtastic_HealthMetrics_size            11
 #define meshtastic_LocalStats_size               60
 #define meshtastic_Nau7802Config_size            16
 #define meshtastic_PowerMetrics_size             30
-#define meshtastic_Telemetry_size                98
+#define meshtastic_Telemetry_size                110

 #ifdef __cplusplus
 } /* extern "C" */
@@ -65,6 +65,9 @@ mail:   marchammermann@googlemail.com
 #define DEFAULT_REALM "default_realm"
 #define PREFIX ""

+#define KEY_PATH settingsStrings[websslkeypath].c_str()
+#define CERT_PATH settingsStrings[websslcertpath].c_str()
+
 struct _file_config configWeb;

 // We need to specify some content-type mapping, so the resources get delivered with the
@@ -82,8 +85,6 @@ char contentTypes[][2][32] = {{".txt", "text/plain"},      {".html", "text/html"
 volatile bool isWebServerReady;
 volatile bool isCertReady;

-HttpAPI webAPI;
-
 PiWebServerThread *piwebServerThread;

 /**
@@ -247,7 +248,7 @@ int handleAPIv1ToRadio(const struct _u_request *req, struct _u_response *res, vo
    portduinoVFS->mountpoint(configWeb.rootPath);

    LOG_DEBUG("Received %d bytes from PUT request", s);
-    webAPI.handleToRadio(buffer, s);
+    static_cast<HttpAPI *>(user_data)->handleToRadio(buffer, s);
    LOG_DEBUG("end web->radio  ");
    return U_CALLBACK_COMPLETE;
 }
@@ -279,7 +280,7 @@ int handleAPIv1FromRadio(const struct _u_request *req, struct _u_response *res,

    if (valueAll == "true") {
        while (len) {
-            len = webAPI.getFromRadio(txBuf);
+            len = static_cast<HttpAPI *>(user_data)->getFromRadio(txBuf);
            ulfius_set_response_properties(res, U_OPT_STATUS, 200, U_OPT_BINARY_BODY, txBuf, len);
            const char *tmpa = (const char *)txBuf;
            ulfius_set_string_body_response(res, 200, tmpa);
@@ -289,7 +290,7 @@ int handleAPIv1FromRadio(const struct _u_request *req, struct _u_response *res,
        }
        // Otherwise, just return one protobuf
    } else {
-        len = webAPI.getFromRadio(txBuf);
+        len = static_cast<HttpAPI *>(user_data)->getFromRadio(txBuf);
        const char *tmpa = (const char *)txBuf;
        ulfius_set_binary_body_response(res, 200, tmpa, len);
        // LOG_DEBUG("\n----webAPI response:");
@@ -386,13 +387,13 @@ char *read_file_into_string(const char *filename)
 int PiWebServerThread::CheckSSLandLoad()
 {
    // read certificate
-    cert_pem = read_file_into_string("certificate.pem");
+    cert_pem = read_file_into_string(CERT_PATH);
    if (cert_pem == NULL) {
        LOG_ERROR("ERROR SSL Certificate File can't be loaded or is missing");
        return 1;
    }
    // read private key
-    key_pem = read_file_into_string("private_key.pem");
+    key_pem = read_file_into_string(KEY_PATH);
    if (key_pem == NULL) {
        LOG_ERROR("ERROR file private_key can't be loaded or is missing");
        return 2;
@@ -417,8 +418,8 @@ int PiWebServerThread::CreateSSLCertificate()
        return 2;
    }

-    // Ope file to write private key file
-    FILE *pkey_file = fopen("private_key.pem", "wb");
+    // Open file to write private key file
+    FILE *pkey_file = fopen(KEY_PATH, "wb");
    if (!pkey_file) {
        LOG_ERROR("Error opening private key file");
        return 3;
@@ -428,18 +429,19 @@ int PiWebServerThread::CreateSSLCertificate()
    fclose(pkey_file);

    // open Certificate file
-    FILE *x509_file = fopen("certificate.pem", "wb");
+    FILE *x509_file = fopen(CERT_PATH, "wb");
    if (!x509_file) {
        LOG_ERROR("Error opening cert");
        return 4;
    }
-    // write cirtificate
+    // write certificate
    PEM_write_X509(x509_file, x509);
    fclose(x509_file);

    EVP_PKEY_free(pkey);
+    LOG_INFO("Create SSL Key %s successful", KEY_PATH);
    X509_free(x509);
-    LOG_INFO("Create SSL Cert -certificate.pem- succesfull ");
+    LOG_INFO("Create SSL Cert %s successful", CERT_PATH);
    return 0;
 }

@@ -497,10 +499,10 @@ PiWebServerThread::PiWebServerThread()
        u_map_put(instanceWeb.default_headers, "Access-Control-Allow-Origin", "*");
        // Maximum body size sent by the client is 1 Kb
        instanceWeb.max_post_body_size = 1024;
-        ulfius_add_endpoint_by_val(&instanceWeb, "GET", PREFIX, "/api/v1/fromradio/*", 1, &handleAPIv1FromRadio, NULL);
-        ulfius_add_endpoint_by_val(&instanceWeb, "OPTIONS", PREFIX, "/api/v1/fromradio/*", 1, &handleAPIv1FromRadio, NULL);
-        ulfius_add_endpoint_by_val(&instanceWeb, "PUT", PREFIX, "/api/v1/toradio/*", 1, &handleAPIv1ToRadio, configWeb.rootPath);
-        ulfius_add_endpoint_by_val(&instanceWeb, "OPTIONS", PREFIX, "/api/v1/toradio/*", 1, &handleAPIv1ToRadio, NULL);
+        ulfius_add_endpoint_by_val(&instanceWeb, "GET", PREFIX, "/api/v1/fromradio/*", 1, &handleAPIv1FromRadio, &webAPI);
+        ulfius_add_endpoint_by_val(&instanceWeb, "OPTIONS", PREFIX, "/api/v1/fromradio/*", 1, &handleAPIv1FromRadio, &webAPI);
+        ulfius_add_endpoint_by_val(&instanceWeb, "PUT", PREFIX, "/api/v1/toradio/*", 1, &handleAPIv1ToRadio, &webAPI);
+        ulfius_add_endpoint_by_val(&instanceWeb, "OPTIONS", PREFIX, "/api/v1/toradio/*", 1, &handleAPIv1ToRadio, &webAPI);

        // Add callback function to all endpoints for the Web Server
        ulfius_add_endpoint_by_val(&instanceWeb, "GET", NULL, "/*", 2, &callback_static_file, &configWeb);
@@ -525,13 +527,12 @@ PiWebServerThread::~PiWebServerThread()
    u_map_clean(&configWeb.mime_types);

    ulfius_stop_framework(&instanceWeb);
-    ulfius_stop_framework(&instanceWeb);
+    ulfius_clean_instance(&instanceWeb);
    free(configWeb.rootPath);
-    ulfius_clean_instance(&instanceService);
-    ulfius_clean_instance(&instanceService);
+    free(key_pem);
    free(cert_pem);
    LOG_INFO("End framework");
 }

 #endif
-#endif
+#endif
@@ -23,24 +23,6 @@ struct _file_config {
    char *rootPath;
 };

-class PiWebServerThread
-{
-  private:
-    char *key_pem = NULL;
-    char *cert_pem = NULL;
-    // struct _u_map mime_types;
-    std::string webrootpath;
-
-  public:
-    PiWebServerThread();
-    ~PiWebServerThread();
-    int CreateSSLCertificate();
-    int CheckSSLandLoad();
-    uint32_t requestRestart = 0;
-    struct _u_instance instanceWeb;
-    struct _u_instance instanceService;
-};
-
 class HttpAPI : public PhoneAPI
 {

@@ -55,6 +37,24 @@ class HttpAPI : public PhoneAPI
    virtual bool checkIsConnected() override { return true; } // FIXME, be smarter about this
 };

+class PiWebServerThread
+{
+  private:
+    char *key_pem = NULL;
+    char *cert_pem = NULL;
+    // struct _u_map mime_types;
+    std::string webrootpath;
+    HttpAPI webAPI;
+
+  public:
+    PiWebServerThread();
+    ~PiWebServerThread();
+    int CreateSSLCertificate();
+    int CheckSSLandLoad();
+    uint32_t requestRestart = 0;
+    struct _u_instance instanceWeb;
+};
+
 extern PiWebServerThread *piwebServerThread;

 #endif
@@ -231,7 +231,7 @@ bool initWifi()
 #if !MESHTASTIC_EXCLUDE_WEBSERVER
        createSSLCert(); // For WebServer
 #endif
-        esp_wifi_set_storage(WIFI_STORAGE_RAM); // Disable flash storage for WiFi credentials
+        WiFi.persistent(false); // Disable flash storage for WiFi credentials
 #endif
        if (!*wifiPsw) // Treat empty password as no password
            wifiPsw = NULL;
@@ -81,7 +81,7 @@ int32_t DetectionSensorModule::runOnce()
        }
        LOG_INFO("Detection Sensor Module: init");

-        return DELAYED_INTERVAL;
+        return setStartDelay();
    }

    // LOG_DEBUG("Detection Sensor Module: Current pin state: %i", digitalRead(moduleConfig.detection_sensor.monitor_pin));
@@ -161,4 +161,4 @@ bool DetectionSensorModule::hasDetectionEvent()
    bool currentState = digitalRead(moduleConfig.detection_sensor.monitor_pin);
    // LOG_DEBUG("Detection Sensor Module: Current state: %i", currentState);
    return (moduleConfig.detection_sensor.detection_trigger_type & 1) ? currentState : !currentState;
-}
+}
@@ -97,8 +97,9 @@ NodeInfoModule::NodeInfoModule()
    : ProtobufModule("nodeinfo", meshtastic_PortNum_NODEINFO_APP, &meshtastic_User_msg), concurrency::OSThread("NodeInfo")
 {
    isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
-    setIntervalFromNow(30 *
-                       1000); // Send our initial owner announcement 30 seconds after we start (to give network time to setup)
+
+    setIntervalFromNow(setStartDelay()); // Send our initial owner announcement 30 seconds
+                                         // after we start (to give network time to setup)
 }

 int32_t NodeInfoModule::runOnce()
@@ -112,4 +113,4 @@ int32_t NodeInfoModule::runOnce()
        sendOurNodeInfo(NODENUM_BROADCAST, requestReplies); // Send our info (don't request replies)
    }
    return Default::getConfiguredOrDefaultMs(config.device.node_info_broadcast_secs, default_node_info_broadcast_secs);
-}
+}
@@ -28,8 +28,9 @@ PositionModule::PositionModule()
    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);
+        config.device.role != meshtastic_Config_DeviceConfig_Role_TAK_TRACKER) {
+        setIntervalFromNow(setStartDelay());
+    }

    // Power saving trackers should clear their position on startup to avoid waking up and sending a stale position
    if ((config.device.role == meshtastic_Config_DeviceConfig_Role_TRACKER ||
@@ -160,7 +161,8 @@ bool PositionModule::hasGPS()
 #endif
 }

-meshtastic_MeshPacket *PositionModule::allocReply()
+// Allocate a packet with our position data if we have one
+meshtastic_MeshPacket *PositionModule::allocPositionPacket()
 {
    if (precision == 0) {
        LOG_DEBUG("Skip location send because precision is set to 0!");
@@ -262,7 +264,8 @@ meshtastic_MeshPacket *PositionModule::allocReply()
        p.has_ground_speed = true;
    }

-    LOG_INFO("Position reply: time=%i lat=%i lon=%i", p.time, p.latitude_i, p.longitude_i);
+    LOG_INFO("Position packet: time=%i lat=%i lon=%i", p.time, p.latitude_i, p.longitude_i);
+    lastSentToMesh = millis();

    // TAK Tracker devices should send their position in a TAK packet over the ATAK port
    if (config.device.role == meshtastic_Config_DeviceConfig_Role_TAK_TRACKER)
@@ -271,6 +274,17 @@ meshtastic_MeshPacket *PositionModule::allocReply()
    return allocDataProtobuf(p);
 }

+meshtastic_MeshPacket *PositionModule::allocReply()
+{
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND && lastSentToMesh &&
+        Throttle::isWithinTimespanMs(lastSentToMesh, 3 * 60 * 1000)) {
+        LOG_DEBUG("Skip Position reply since we sent it <3min ago");
+        ignoreRequest = true; // Mark it as ignored for MeshModule
+        return nullptr;
+    }
+    return allocPositionPacket();
+}
+
 meshtastic_MeshPacket *PositionModule::allocAtakPli()
 {
    LOG_INFO("Send TAK PLI packet");
@@ -333,9 +347,9 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha
        precision = 0;
    }

-    meshtastic_MeshPacket *p = allocReply();
+    meshtastic_MeshPacket *p = allocPositionPacket();
    if (p == nullptr) {
-        LOG_DEBUG("allocReply returned a nullptr");
+        LOG_DEBUG("allocPositionPacket returned a nullptr");
        return;
    }

@@ -55,6 +55,7 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
    virtual int32_t runOnce() override;

  private:
+    meshtastic_MeshPacket *allocPositionPacket();
    struct SmartPosition getDistanceTraveledSinceLastSend(meshtastic_PositionLite currentPosition);
    meshtastic_MeshPacket *allocAtakPli();
    void trySetRtc(meshtastic_Position p, bool isLocal, bool forceUpdate = false);
@@ -62,6 +63,7 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
    void sendLostAndFoundText();
    bool hasQualityTimesource();
    bool hasGPS();
+    uint32_t lastSentToMesh = 0; // Last time we sent our position to the mesh

    const uint32_t minimumTimeThreshold =
        Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);
@@ -50,12 +50,12 @@ int32_t AirQualityTelemetryModule::runOnce()
                    nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I].first = found.address.address;
                    nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I].second =
                        i2cScanner->fetchI2CBus(found.address);
-                    return 1000;
+                    return setStartDelay();
                }
 #endif
                return disable();
            }
-            return 1000;
+            return setStartDelay();
        }
        return disable();
    } else {
@@ -18,7 +18,7 @@ class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModu
        uptimeWrapCount = 0;
        uptimeLastMs = millis();
        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
-        setIntervalFromNow(45 * 1000); // Wait until NodeInfo is sent
+        setIntervalFromNow(setStartDelay()); // Wait until NodeInfo is sent
    }
    virtual bool wantUIFrame() { return false; }

@@ -62,4 +62,4 @@ class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModu

    uint32_t uptimeWrapCount;
    uint32_t uptimeLastMs;
-};
+};
@@ -27,6 +27,7 @@
 #include "Sensor/BMP280Sensor.h"
 #include "Sensor/BMP3XXSensor.h"
 #include "Sensor/CGRadSensSensor.h"
+#include "Sensor/DFRobotGravitySensor.h"
 #include "Sensor/DFRobotLarkSensor.h"
 #include "Sensor/LPS22HBSensor.h"
 #include "Sensor/MCP9808Sensor.h"
@@ -56,6 +57,7 @@ RCWL9620Sensor rcwl9620Sensor;
 AHT10Sensor aht10Sensor;
 MLX90632Sensor mlx90632Sensor;
 DFRobotLarkSensor dfRobotLarkSensor;
+DFRobotGravitySensor dfRobotGravitySensor;
 NAU7802Sensor nau7802Sensor;
 BMP3XXSensor bmp3xxSensor;
 CGRadSensSensor cgRadSens;
@@ -105,8 +107,6 @@ int32_t EnvironmentTelemetryModule::runOnce()

        if (moduleConfig.telemetry.environment_measurement_enabled) {
            LOG_INFO("Environment Telemetry: init");
-            // 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 SENSECAP_INDICATOR
            result = indicatorSensor.runOnce();
 #endif
@@ -115,6 +115,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
 #elif !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL
            if (dfRobotLarkSensor.hasSensor())
                result = dfRobotLarkSensor.runOnce();
+            if (dfRobotGravitySensor.hasSensor())
+                result = dfRobotGravitySensor.runOnce();
            if (bmp085Sensor.hasSensor())
                result = bmp085Sensor.runOnce();
            if (bmp280Sensor.hasSensor())
@@ -159,9 +161,17 @@ int32_t EnvironmentTelemetryModule::runOnce()
                result = max17048Sensor.runOnce();
            if (cgRadSens.hasSensor())
                result = cgRadSens.runOnce();
+                // this only works on the wismesh hub with the solar option. This is not an I2C sensor, so we don't need the
+                // sensormap here.
+#ifdef HAS_RAKPROT
+
+            result = rak9154Sensor.runOnce();
+#endif
 #endif
        }
-        return result;
+        // 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
+        return result == UINT32_MAX ? disable() : setStartDelay();
    } else {
        // if we somehow got to a second run of this module with measurement disabled, then just wait forever
        if (!moduleConfig.telemetry.environment_measurement_enabled) {
@@ -222,7 +232,11 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
    }

    // Display "Env. From: ..." on its own
-    display->drawString(x, y, "Env. From: " + String(lastSender) + "(" + String(agoSecs) + "s)");
+    display->drawString(x, y, "Env. From: " + String(lastSender) + " (" + String(agoSecs) + "s)");
+
+    // Prepare sensor data strings
+    String sensorData[10];
+    int sensorCount = 0;

    if (lastMeasurement.variant.environment_metrics.has_temperature ||
        lastMeasurement.variant.environment_metrics.has_relative_humidity) {
@@ -232,38 +246,83 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
                String(UnitConversions::CelsiusToFahrenheit(lastMeasurement.variant.environment_metrics.temperature), 0) + "°F";
        }

-        // Continue with the remaining details
-        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Temp/Hum: " + last_temp + " / " +
-                                String(lastMeasurement.variant.environment_metrics.relative_humidity, 0) + "%");
+        sensorData[sensorCount++] =
+            "Temp/Hum: " + last_temp + " / " + String(lastMeasurement.variant.environment_metrics.relative_humidity, 0) + "%";
    }

    if (lastMeasurement.variant.environment_metrics.barometric_pressure != 0) {
-        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Press: " + String(lastMeasurement.variant.environment_metrics.barometric_pressure, 0) + "hPA");
+        sensorData[sensorCount++] =
+            "Press: " + String(lastMeasurement.variant.environment_metrics.barometric_pressure, 0) + "hPA";
    }

    if (lastMeasurement.variant.environment_metrics.voltage != 0) {
-        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Volt/Cur: " + String(lastMeasurement.variant.environment_metrics.voltage, 0) + "V / " +
-                                String(lastMeasurement.variant.environment_metrics.current, 0) + "mA");
+        sensorData[sensorCount++] = "Volt/Cur: " + String(lastMeasurement.variant.environment_metrics.voltage, 0) + "V / " +
+                                    String(lastMeasurement.variant.environment_metrics.current, 0) + "mA";
    }

    if (lastMeasurement.variant.environment_metrics.iaq != 0) {
-        display->drawString(x, y += _fontHeight(FONT_SMALL), "IAQ: " + String(lastMeasurement.variant.environment_metrics.iaq));
+        sensorData[sensorCount++] = "IAQ: " + String(lastMeasurement.variant.environment_metrics.iaq);
    }

-    if (lastMeasurement.variant.environment_metrics.distance != 0)
-        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Water Level: " + String(lastMeasurement.variant.environment_metrics.distance, 0) + "mm");
+    if (lastMeasurement.variant.environment_metrics.distance != 0) {
+        sensorData[sensorCount++] = "Water Level: " + String(lastMeasurement.variant.environment_metrics.distance, 0) + "mm";
+    }

-    if (lastMeasurement.variant.environment_metrics.weight != 0)
-        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Weight: " + String(lastMeasurement.variant.environment_metrics.weight, 0) + "kg");
+    if (lastMeasurement.variant.environment_metrics.weight != 0) {
+        sensorData[sensorCount++] = "Weight: " + String(lastMeasurement.variant.environment_metrics.weight, 0) + "kg";
+    }

-    if (lastMeasurement.variant.environment_metrics.radiation != 0)
-        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Rad: " + String(lastMeasurement.variant.environment_metrics.radiation, 2) + "µR/h");
+    if (lastMeasurement.variant.environment_metrics.radiation != 0) {
+        sensorData[sensorCount++] = "Rad: " + String(lastMeasurement.variant.environment_metrics.radiation, 2) + "µR/h";
+    }
+
+    if (lastMeasurement.variant.environment_metrics.lux != 0) {
+        sensorData[sensorCount++] = "Illuminance: " + String(lastMeasurement.variant.environment_metrics.lux, 2) + "lx";
+    }
+
+    if (lastMeasurement.variant.environment_metrics.white_lux != 0) {
+        sensorData[sensorCount++] = "W_Lux: " + String(lastMeasurement.variant.environment_metrics.white_lux, 2) + "lx";
+    }
+
+    static int scrollOffset = 0;
+    static bool scrollingDown = true;
+    static uint32_t lastScrollTime = millis();
+
+    // Determine how many lines we can fit on display
+    // Calculated once only: display dimensions don't change during runtime.
+    static int maxLines = 0;
+    if (!maxLines) {
+        const int16_t paddingTop = _fontHeight(FONT_SMALL); // Heading text
+        const int16_t paddingBottom = 8;                    // Indicator dots
+        maxLines = (display->getHeight() - paddingTop - paddingBottom) / _fontHeight(FONT_SMALL);
+        assert(maxLines > 0);
+    }
+
+    // Draw as many lines of data as we can fit
+    int linesToShow = min(maxLines, sensorCount);
+    for (int i = 0; i < linesToShow; i++) {
+        int index = (scrollOffset + i) % sensorCount;
+        display->drawString(x, y += _fontHeight(FONT_SMALL), sensorData[index]);
+    }
+
+    // Only scroll if there are more than 3 sensor data lines
+    if (sensorCount > 3) {
+        // Update scroll offset every 5 seconds
+        if (millis() - lastScrollTime > 5000) {
+            if (scrollingDown) {
+                scrollOffset++;
+                if (scrollOffset + linesToShow >= sensorCount) {
+                    scrollingDown = false;
+                }
+            } else {
+                scrollOffset--;
+                if (scrollOffset <= 0) {
+                    scrollingDown = true;
+                }
+            }
+            lastScrollTime = millis();
+        }
+    }
 }

 bool EnvironmentTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
@@ -277,8 +336,10 @@ bool EnvironmentTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPac
                 sender, t->variant.environment_metrics.barometric_pressure, t->variant.environment_metrics.current,
                 t->variant.environment_metrics.gas_resistance, t->variant.environment_metrics.relative_humidity,
                 t->variant.environment_metrics.temperature);
-        LOG_INFO("(Received from %s): voltage=%f, IAQ=%d, distance=%f, lux=%f", sender, t->variant.environment_metrics.voltage,
-                 t->variant.environment_metrics.iaq, t->variant.environment_metrics.distance, t->variant.environment_metrics.lux);
+        LOG_INFO("(Received from %s): voltage=%f, IAQ=%d, distance=%f, lux=%f, white_lux=%f", sender,
+                 t->variant.environment_metrics.voltage, t->variant.environment_metrics.iaq,
+                 t->variant.environment_metrics.distance, t->variant.environment_metrics.lux,
+                 t->variant.environment_metrics.white_lux);

        LOG_INFO("(Received from %s): wind speed=%fm/s, direction=%d degrees, weight=%fkg", sender,
                 t->variant.environment_metrics.wind_speed, t->variant.environment_metrics.wind_direction,
@@ -317,6 +378,10 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
        valid = valid && dfRobotLarkSensor.getMetrics(m);
        hasSensor = true;
    }
+    if (dfRobotGravitySensor.hasSensor()) {
+        valid = valid && dfRobotGravitySensor.getMetrics(m);
+        hasSensor = true;
+    }
    if (sht31Sensor.hasSensor()) {
        valid = valid && sht31Sensor.getMetrics(m);
        hasSensor = true;
@@ -421,6 +486,10 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
        valid = valid && cgRadSens.getMetrics(m);
        hasSensor = true;
    }
+#ifdef HAS_RAKPROT
+    valid = valid && rak9154Sensor.getMetrics(m);
+    hasSensor = true;
+#endif
 #endif
    return valid && hasSensor;
 }
@@ -518,6 +587,11 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
        if (result != AdminMessageHandleResult::NOT_HANDLED)
            return result;
    }
+    if (dfRobotGravitySensor.hasSensor()) {
+        result = dfRobotGravitySensor.handleAdminMessage(mp, request, response);
+        if (result != AdminMessageHandleResult::NOT_HANDLED)
+            return result;
+    }
    if (sht31Sensor.hasSensor()) {
        result = sht31Sensor.handleAdminMessage(mp, request, response);
        if (result != AdminMessageHandleResult::NOT_HANDLED)
@@ -62,7 +62,7 @@ int32_t HealthTelemetryModule::runOnce()
            if (max30102Sensor.hasSensor())
                result = max30102Sensor.runOnce();
        }
-        return result;
+        return result == UINT32_MAX ? disable() : setStartDelay();
    } else {
        // if we somehow got to a second run of this module with measurement disabled, then just wait forever
        if (!moduleConfig.telemetry.health_measurement_enabled) {
@@ -65,7 +65,7 @@ int32_t PowerTelemetryModule::runOnce()
            if (max17048Sensor.hasSensor() && !max17048Sensor.isInitialized())
                result = max17048Sensor.runOnce();
        }
-        return result;
+        return result == UINT32_MAX ? disable() : setStartDelay();
 #else
        return disable();
 #endif
@@ -100,7 +100,7 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
 {
    display->setTextAlignment(TEXT_ALIGN_LEFT);
    display->setFont(FONT_SMALL);
-    
+
    if (lastMeasurementPacket == nullptr) {
        // In case of  no valid packet, display "Power Telemetry", "No measurement"
        display->drawString(x, y, "Power Telemetry");
@@ -121,23 +121,23 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
    }

    // Display "Pow. From: ..."
-    display->drawString(x, y, "Pow. From: " + String(lastSender) + "(" + String(agoSecs) + "s)");    
+    display->drawString(x, y, "Pow. From: " + String(lastSender) + "(" + String(agoSecs) + "s)");

    // Display current and voltage based on ...power_metrics.has_[channel/voltage/current]... flags
    if (lastMeasurement.variant.power_metrics.has_ch1_voltage || lastMeasurement.variant.power_metrics.has_ch1_current) {
        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Ch1: " + String(lastMeasurement.variant.power_metrics.ch1_voltage, 2) +
-                                "V " + String(lastMeasurement.variant.power_metrics.ch1_current, 0) + "mA");
+                            "Ch1: " + String(lastMeasurement.variant.power_metrics.ch1_voltage, 2) + "V " +
+                                String(lastMeasurement.variant.power_metrics.ch1_current, 0) + "mA");
    }
    if (lastMeasurement.variant.power_metrics.has_ch2_voltage || lastMeasurement.variant.power_metrics.has_ch2_current) {
        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Ch2: " + String(lastMeasurement.variant.power_metrics.ch2_voltage, 2) +
-                                "V " + String(lastMeasurement.variant.power_metrics.ch2_current, 0) + "mA");
+                            "Ch2: " + String(lastMeasurement.variant.power_metrics.ch2_voltage, 2) + "V " +
+                                String(lastMeasurement.variant.power_metrics.ch2_current, 0) + "mA");
    }
    if (lastMeasurement.variant.power_metrics.has_ch3_voltage || lastMeasurement.variant.power_metrics.has_ch3_current) {
        display->drawString(x, y += _fontHeight(FONT_SMALL),
-                            "Ch3: " + String(lastMeasurement.variant.power_metrics.ch3_voltage, 2) +
-                                "V " + String(lastMeasurement.variant.power_metrics.ch3_current, 0) + "mA");
+                            "Ch3: " + String(lastMeasurement.variant.power_metrics.ch3_voltage, 2) + "V " +
+                                String(lastMeasurement.variant.power_metrics.ch3_current, 0) + "mA");
    }
 }

@@ -0,0 +1,44 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "DFRobotGravitySensor.h"
+#include "TelemetrySensor.h"
+#include <DFRobot_RainfallSensor.h>
+#include <string>
+
+DFRobotGravitySensor::DFRobotGravitySensor() : TelemetrySensor(meshtastic_TelemetrySensorType_DFROBOT_RAIN, "DFROBOT_RAIN") {}
+
+int32_t DFRobotGravitySensor::runOnce()
+{
+    LOG_INFO("Init sensor: %s", sensorName);
+    if (!hasSensor()) {
+        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    }
+
+    gravity = DFRobot_RainfallSensor_I2C(nodeTelemetrySensorsMap[sensorType].second);
+    status = gravity.begin();
+
+    return initI2CSensor();
+}
+
+void DFRobotGravitySensor::setup()
+{
+    LOG_DEBUG("%s VID: %x, PID: %x, Version: %s", sensorName, gravity.vid, gravity.pid, gravity.getFirmwareVersion().c_str());
+}
+
+bool DFRobotGravitySensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.environment_metrics.has_rainfall_1h = true;
+    measurement->variant.environment_metrics.has_rainfall_24h = true;
+
+    measurement->variant.environment_metrics.rainfall_1h = gravity.getRainfall(1);
+    measurement->variant.environment_metrics.rainfall_24h = gravity.getRainfall(24);
+
+    LOG_INFO("Rain 1h: %f mm", measurement->variant.environment_metrics.rainfall_1h);
+    LOG_INFO("Rain 24h: %f mm", measurement->variant.environment_metrics.rainfall_24h);
+    return true;
+}
+
+#endif
@@ -0,0 +1,29 @@
+#pragma once
+
+#ifndef _MT_DFROBOTGRAVITYSENSOR_H
+#define _MT_DFROBOTGRAVITYSENSOR_H
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <DFRobot_RainfallSensor.h>
+#include <string>
+
+class DFRobotGravitySensor : public TelemetrySensor
+{
+  private:
+    DFRobot_RainfallSensor_I2C gravity = DFRobot_RainfallSensor_I2C(nodeTelemetrySensorsMap[sensorType].second);
+
+  protected:
+    virtual void setup() override;
+
+  public:
+    DFRobotGravitySensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+};
+
+#endif
+#endif
--- a/Show More
+++ b/Show More