ugh

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

.devcontainer/Dockerfile

@@ -0,0 +1,24 @@
+FROM mcr.microsoft.com/devcontainers/cpp:1-debian-12
+
+# [Optional] Uncomment this section to install additional packages.
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get -y install --no-install-recommends \
+    ca-certificates \
+    g++ \
+    git \
+    libbluetooth-dev \
+    libgpiod-dev \
+    liborcania-dev \
+    libssl-dev \
+    libulfius-dev \
+    libyaml-cpp-dev \
+    pkg-config \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-wheel \
+    wget \
+    zip \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+RUN pip3 install --no-cache-dir -U platformio==6.1.15

.devcontainer/devcontainer.json

@@ -0,0 +1,28 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
+{
+  "name": "Meshtastic Firmware Dev",
+  "build": {
+    "dockerfile": "Dockerfile"
+  },
+  "features": {
+    "ghcr.io/devcontainers/features/python:1": {
+      "installTools": true,
+      "version": "latest"
+    }
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-vscode.cpptools",
+        "platformio.platformio-ide",
+      ]
+    }
+  },
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  "forwardPorts": [ 4403 ],
+
+  // Run commands to prepare the container for use
+  "postCreateCommand": ".devcontainer/setup.sh",
+}

.devcontainer/setup.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+
+git submodule update --init

.github/ISSUE_TEMPLATE/Bug Report.yml

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

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

@@ -14,7 +14,7 @@ runs:
     - name: Install dependencies
       shell: bash
       run: |
-        sudo apt-get -y update 
+        sudo apt-get -y update --fix-missing
         sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev
 
     - name: Setup Python
@@ -22,19 +22,21 @@ runs:
       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
+    # - name: Cache python libs
+    #   uses: actions/cache@v4
+    #   id: cache-pip # needed in if test
+    #   with:
+    #     path: ~/.cache/pip
+    #     key: ${{ runner.os }}-pip
 
     - name: Upgrade python tools
       shell: bash
       run: |
         python -m pip install --upgrade pip
-        pip install -U platformio adafruit-nrfutil
-        pip install -U meshtastic --pre
+        pip install -U --no-build-isolation --no-cache-dir "setuptools<72"
+        pip install -U platformio adafruit-nrfutil --no-build-isolation
+        pip install -U poetry --no-build-isolation
+        pip install -U meshtastic --pre --no-build-isolation
 
     - name: Upgrade platformio
       shell: bash

.github/workflows/build_native.yml

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

.github/workflows/build_nrf52.yml

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

.github/workflows/build_raspbian.yml

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

.github/workflows/build_raspbian_armv7l.yml

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

.github/workflows/build_stm32.yml

@@ -0,0 +1,33 @@
+name: Build STM32
+
+on:
+  workflow_call:
+    inputs:
+      board:
+        required: true
+        type: string
+
+jobs:
+  build-stm32:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
+
+      - name: Build STM32
+        run: bin/build-stm32.sh ${{ inputs.board }}
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
+            release/*.hex
+            release/*.bin

.github/workflows/main_matrix.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: [esp32, esp32s3, esp32c3, nrf52840, rp2040, check]
+        arch: [esp32, esp32s3, esp32c3, nrf52840, rp2040, stm32, check]
     runs-on: ubuntu-latest
     steps:
       - id: checkout
@@ -41,6 +41,7 @@ jobs:
       esp32c3: ${{ steps.jsonStep.outputs.esp32c3 }}
       nrf52840: ${{ steps.jsonStep.outputs.nrf52840 }}
       rp2040: ${{ steps.jsonStep.outputs.rp2040 }}
+      stm32: ${{ steps.jsonStep.outputs.stm32 }}
       check: ${{ steps.jsonStep.outputs.check }}
 
   check:
@@ -103,6 +104,15 @@ jobs:
     with:
       board: ${{ matrix.board }}
 
+  build-stm32:
+    needs: setup
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.stm32) }}
+    uses: ./.github/workflows/build_stm32.yml
+    with:
+      board: ${{ matrix.board }}
+
   package-raspbian:
     uses: ./.github/workflows/package_raspbian.yml
 
@@ -134,9 +144,10 @@ jobs:
         build-esp32-c3,
         build-nrf52,
         build-rpi2040,
+        build-stm32,
         package-raspbian,
         package-raspbian-armv7l,
-        package-native
+        package-native,
       ]
     steps:
       - name: Checkout code
@@ -168,6 +179,7 @@ jobs:
           path: |
             ./firmware-*.bin
             ./firmware-*.uf2
+            ./firmware-*.hex
             ./firmware-*-ota.zip
             ./device-*.sh
             ./device-*.bat
@@ -254,7 +266,7 @@ jobs:
           chmod +x ./output/device-update.sh
 
       - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{ steps.version.outputs.version }}.zip ./output
+        run: zip -j -9 -r ./firmware-${{ steps.version.outputs.version }}.zip ./output -x *.deb
 
       - uses: actions/download-artifact@v4
         with:

.github/workflows/test_simulator.yml

@@ -0,0 +1,57 @@
+name: Test Simulator
+
+on:
+  schedule:
+    - cron: "0 0 * * *" # Run every day at midnight
+  workflow_dispatch: {}
+
+jobs:
+  test-simulator:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install libbluetooth
+        shell: bash
+        run: |
+          sudo apt-get update --fix-missing
+          sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - 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 Native
+        run: bin/build-native.sh
+
+      # We now run integration test before other build steps (to quickly see runtime failures)
+      - name: Build for native
+        run: platformio run -e native
+
+      - name: Integration test
+        run: |
+          .pio/build/native/program & sleep 10 # 5 seconds was not enough
+          echo "Simulator started, launching python test..."
+          python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
+
+      - name: PlatformIO Tests
+        run: platformio test -e native --junit-output-path testreport.xml
+
+      - name: Test Report
+        uses: dorny/test-reporter@v1.9.1
+        if: success() || failure() # run this step even if previous step failed
+        with:
+          name: PlatformIO Tests
+          path: testreport.xml
+          reporter: java-junit

.gitpod.yml

@@ -0,0 +1,2 @@
+tasks:
+  - init: pip install platformio && pip install --upgrade pip

.semgrepignore

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

.trunk/configs/.bandit

@@ -0,0 +1,2 @@
+[bandit]
+skips = B101

.trunk/trunk.yaml

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

.vscode/settings.json

@@ -3,5 +3,9 @@
   "editor.defaultFormatter": "trunk.io",
   "trunk.enableWindows": true,
   "files.insertFinalNewline": false,
-  "files.trimFinalNewlines": false
+  "files.trimFinalNewlines": false,
+  "cmake.configureOnOpen": false,
+  "[cpp]": {
+    "editor.defaultFormatter": "trunk.io"
+  }
 }

Dockerfile

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

arch/esp32/esp32.ini

@@ -44,10 +44,11 @@ lib_deps =
   ${networking_base.lib_deps}
   ${environmental_base.lib_deps}
   https://github.com/meshtastic/esp32_https_server.git#23665b3adc080a311dcbb586ed5941b5f94d6ea2
-  h2zero/NimBLE-Arduino@^1.4.1
+  h2zero/NimBLE-Arduino@^1.4.2
   https://github.com/dbSuS/libpax.git#7bcd3fcab75037505be9b122ab2b24cc5176b587
   https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
   https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f
+  rweather/Crypto@^0.4.0
 
 lib_ignore = 
   segger_rtt

arch/nrf52/cpp_overrides/lfs_util.h

@@ -0,0 +1,208 @@
+/*
+ * lfs utility functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// MESHTASTIC/@geeksville note: This file is copied from the Adafruit nrf52 arduino lib.  And we use a special -include in
+// nrf52.ini to load it before EVERY file we do this hack because the default definitions for LFS_ASSERT are quite poor and we
+// don't want to fork the adafruit lib (again) and send in a PR that they probably won't merge anyways. This file might break if
+// they ever update lfs.util on their side, in which case we'll need to update this file to match their new version. The version
+// this is a copy from is almost exactly
+// https://github.com/adafruit/Adafruit_nRF52_Arduino/blob/c25d93268a3b9c23e9a1ccfcaf9b208beca624ca/libraries/Adafruit_LittleFS/src/littlefs/lfs_util.h
+
+#ifndef LFS_UTIL_H
+#define LFS_UTIL_H
+
+// Users can override lfs_util.h with their own configuration by defining
+// LFS_CONFIG as a header file to include (-DLFS_CONFIG=lfs_config.h).
+//
+// If LFS_CONFIG is used, none of the default utils will be emitted and must be
+// provided by the config file. To start I would suggest copying lfs_util.h and
+// modifying as needed.
+#ifdef LFS_CONFIG
+#define LFS_STRINGIZE(x) LFS_STRINGIZE2(x)
+#define LFS_STRINGIZE2(x) #x
+#include LFS_STRINGIZE(LFS_CONFIG)
+#else
+
+// System includes
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef LFS_NO_MALLOC
+#include <stdlib.h>
+#endif
+#ifndef LFS_NO_ASSERT
+#include <assert.h>
+#endif
+
+#if !defined(LFS_NO_DEBUG) || !defined(LFS_NO_WARN) || !defined(LFS_NO_ERROR)
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Macros, may be replaced by system specific wrappers. Arguments to these
+// macros must not have side-effects as the macros can be removed for a smaller
+// code footprint
+
+// Logging functions
+#ifndef LFS_NO_DEBUG
+
+void logLegacy(const char *level, const char *fmt, ...);
+#define LFS_DEBUG(fmt, ...) logLegacy("DEBUG", "lfs debug:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS_DEBUG(fmt, ...)
+#endif
+
+#ifndef LFS_NO_WARN
+#define LFS_WARN(fmt, ...) logLegacy("WARN", "lfs warn:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS_WARN(fmt, ...)
+#endif
+
+#ifndef LFS_NO_ERROR
+#define LFS_ERROR(fmt, ...) logLegacy("ERROR", "lfs error:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS_ERROR(fmt, ...)
+#endif
+
+// Runtime assertions
+#ifndef LFS_NO_ASSERT
+#define LFS_ASSERT(test) assert(test)
+#else
+extern void lfs_assert(const char *reason);
+#define LFS_ASSERT(test)                                                                                                         \
+    if (!(test))                                                                                                                 \
+    lfs_assert(#test)
+#endif
+
+// Builtin functions, these may be replaced by more efficient
+// toolchain-specific implementations. LFS_NO_INTRINSICS falls back to a more
+// expensive basic C implementation for debugging purposes
+
+// Min/max functions for unsigned 32-bit numbers
+static inline uint32_t lfs_max(uint32_t a, uint32_t b)
+{
+    return (a > b) ? a : b;
+}
+
+static inline uint32_t lfs_min(uint32_t a, uint32_t b)
+{
+    return (a < b) ? a : b;
+}
+
+// Find the next smallest power of 2 less than or equal to a
+static inline uint32_t lfs_npw2(uint32_t a)
+{
+#if !defined(LFS_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return 32 - __builtin_clz(a - 1);
+#else
+    uint32_t r = 0;
+    uint32_t s;
+    a -= 1;
+    s = (a > 0xffff) << 4;
+    a >>= s;
+    r |= s;
+    s = (a > 0xff) << 3;
+    a >>= s;
+    r |= s;
+    s = (a > 0xf) << 2;
+    a >>= s;
+    r |= s;
+    s = (a > 0x3) << 1;
+    a >>= s;
+    r |= s;
+    return (r | (a >> 1)) + 1;
+#endif
+}
+
+// Count the number of trailing binary zeros in a
+// lfs_ctz(0) may be undefined
+static inline uint32_t lfs_ctz(uint32_t a)
+{
+#if !defined(LFS_NO_INTRINSICS) && defined(__GNUC__)
+    return __builtin_ctz(a);
+#else
+    return lfs_npw2((a & -a) + 1) - 1;
+#endif
+}
+
+// Count the number of binary ones in a
+static inline uint32_t lfs_popc(uint32_t a)
+{
+#if !defined(LFS_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return __builtin_popcount(a);
+#else
+    a = a - ((a >> 1) & 0x55555555);
+    a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
+    return (((a + (a >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;
+#endif
+}
+
+// Find the sequence comparison of a and b, this is the distance
+// between a and b ignoring overflow
+static inline int lfs_scmp(uint32_t a, uint32_t b)
+{
+    return (int)(unsigned)(a - b);
+}
+
+// Convert from 32-bit little-endian to native order
+static inline uint32_t lfs_fromle32(uint32_t a)
+{
+#if !defined(LFS_NO_INTRINSICS) && ((defined(BYTE_ORDER) && BYTE_ORDER == ORDER_LITTLE_ENDIAN) ||                                \
+                                    (defined(__BYTE_ORDER) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN) ||                          \
+                                    (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+    return a;
+#elif !defined(LFS_NO_INTRINSICS) &&                                                                                             \
+    ((defined(BYTE_ORDER) && BYTE_ORDER == ORDER_BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER == __ORDER_BIG_ENDIAN) || \
+     (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+    return __builtin_bswap32(a);
+#else
+    return (((uint8_t *)&a)[0] << 0) | (((uint8_t *)&a)[1] << 8) | (((uint8_t *)&a)[2] << 16) | (((uint8_t *)&a)[3] << 24);
+#endif
+}
+
+// Convert to 32-bit little-endian from native order
+static inline uint32_t lfs_tole32(uint32_t a)
+{
+    return lfs_fromle32(a);
+}
+
+// Calculate CRC-32 with polynomial = 0x04c11db7
+void lfs_crc(uint32_t *crc, const void *buffer, size_t size);
+
+// Allocate memory, only used if buffers are not provided to littlefs
+static inline void *lfs_malloc(size_t size)
+{
+#ifndef LFS_NO_MALLOC
+    extern void *pvPortMalloc(size_t xWantedSize);
+    return pvPortMalloc(size);
+#else
+    (void)size;
+    return NULL;
+#endif
+}
+
+// Deallocate memory, only used if buffers are not provided to littlefs
+static inline void lfs_free(void *p)
+{
+#ifndef LFS_NO_MALLOC
+    extern void vPortFree(void *pv);
+    vPortFree(p);
+#else
+    (void)p;
+#endif
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
+#endif

arch/nrf52/nrf52.ini

@@ -1,10 +1,14 @@
 [nrf52_base]
 ; Instead of the standard nordicnrf52 platform, we use our fork which has our added variant files
-platform = platformio/nordicnrf52@^10.4.0
+platform = platformio/nordicnrf52@^10.5.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
 
 build_type = debug
 build_flags =
+  -include arch/nrf52/cpp_overrides/lfs_util.h
   ${arduino_base.build_flags}
   -DSERIAL_BUFFER_SIZE=1024
   -Wno-unused-variable
@@ -16,6 +20,7 @@ build_src_filter =
 
 lib_deps=
   ${arduino_base.lib_deps}
+  rweather/Crypto@^0.4.0
 
 lib_ignore =
   BluetoothOTA

arch/nrf52/nrf52840.ini

@@ -7,3 +7,72 @@ lib_deps =
   ${nrf52_base.lib_deps}
   ${environmental_base.lib_deps}
   https://github.com/Kongduino/Adafruit_nRFCrypto.git#e31a8825ea3300b163a0a3c1ddd5de34e10e1371
+
+; Common NRF52 debugging settings follow.  See the Meshtastic developer docs for how to connect SWD debugging probes to your board.
+
+; We want the initial breakpoint at setup() instead of main().  Also we want to enable semihosting at that point so instead of
+debug_init_break = tbreak setup
+; we just turn off the platformio tbreak and do it in .gdbinit (where we have more flexibility for scripting)
+; also we use a permanent breakpoint so it gets reused each time we restart the debugging session?
+; debug_init_break = tbreak main
+
+; Note: add "monitor arm semihosting_redirect tcp 4444 all" if you want the stdout from the device to go to that port number instead
+; (for use by meshtastic command line)
+;  monitor arm semihosting disable
+;  monitor debug_level 3
+;
+; IMPORTANT: fileio must be disabled before using port 5555 - openocd ver 0.12 has a bug where if enabled it never properly parses the special :tt name
+; for stdio access.
+;   monitor arm semihosting_redirect tcp 5555 stdio
+
+; Also note: it is _impossible_ to do non blocking reads on the semihost console port (an oversight when ARM specified the semihost API).
+; So we'll neve be able to general purpose bi-directional communication with the device over semihosting.
+debug_extra_cmds =
+  echo Running .gdbinit script
+  ;monitor arm semihosting enable
+  ;monitor arm semihosting_fileio enable
+  ;monitor arm semihosting_redirect disable
+  commands 1
+  ; echo Breakpoint at setup() has semihosting console, connect to it with "telnet localhost 5555"
+  ; set wantSemihost = 1
+  set useSoftDevice = 0
+  end
+
+  ; Only reprogram the board if the code has changed
+debug_load_mode = modified
+;debug_load_mode = manual
+; We default to the stlink adapter because it is very cheap and works well, though others (such as jlink) are also supported.
+;debug_tool = jlink
+debug_tool = stlink
+debug_speed = 4000
+;debug_tool = custom
+; debug_server =
+;  openocd
+;  -f
+;  /usr/local/share/openocd/scripts/interface/stlink.cfg
+;  -f
+;  /usr/local/share/openocd/scripts/target/nrf52.cfg
+; $PLATFORMIO_CORE_DIR/packages/tool-openocd/openocd/scripts/interface/cmsis-dap.cfg
+
+; Allows programming and debug via the RAK NanoDAP as the default debugger tool for the RAK4631 (it is only $10!)
+; programming time is about the same as the bootloader version.
+; For information on this see the meshtastic developers documentation for "Development on the NRF52"
+; We manually pass in the elf file so that pyocd can reverse engineer FreeRTOS data (running threads, etc...)
+;debug_server =
+;  pyocd
+;  gdbserver
+;  -j
+;  ${platformio.workspace_dir}/..
+;  -t
+;  nrf52840
+;  --semihosting
+;  --elf
+;  ${platformio.build_dir}/${this.__env__}/firmware.elf
+
+; If you want to debug the semihosting support you can turn on extra logging in pyocd with
+;   -L
+;   pyocd.debug.semihost.trace=debug
+
+; The following is not needed because it automatically tries do this
+;debug_server_ready_pattern = -.*GDB server started on port \d+.*
+;debug_port = localhost:3333

arch/stm32/stm32.ini

@@ -0,0 +1,37 @@
+[stm32_base]
+extends = arduino_base
+platform = ststm32
+platform_packages = platformio/framework-arduinoststm32@https://github.com/stm32duino/Arduino_Core_STM32.git#361a7fdb67e2a7104e99b4f42a802469eef8b129
+
+build_type = release
+
+;board_build.flash_offset = 0x08000000
+
+build_flags = 
+  ${arduino_base.build_flags}
+  -flto
+  -Isrc/platform/stm32wl -g
+  -DMESHTASTIC_MINIMIZE_BUILD
+  -DMESHTASTIC_EXCLUDE_GPS
+  -DDEBUG_MUTE
+;  -DVECT_TAB_OFFSET=0x08000000
+  -DconfigUSE_CMSIS_RTOS_V2=1
+;  -DSPI_MODE_0=SPI_MODE0
+  -fmerge-all-constants
+  -ffunction-sections
+  -fdata-sections
+  
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/RemoteHardwareModule.cpp> -<platform/nrf52> -<platform/portduino> -<platform/rp2040> -<mesh/raspihttp>
+
+board_upload.offset_address = 0x08000000
+upload_protocol = stlink
+
+lib_deps =
+  ${env.lib_deps}
+  charlesbaynham/OSFS@^1.2.3
+  https://github.com/caveman99/Crypto.git#f61ae26a53f7a2d0ba5511625b8bf8eff3a35d5e
+
+lib_ignore =
+  https://github.com/mathertel/OneButton@~2.6.1
+  Wire

arch/stm32/stm32wl5e.ini

@@ -1,28 +0,0 @@
-[stm32wl5e_base]
-platform_packages = platformio/framework-arduinoststm32 @ https://github.com/stm32duino/Arduino_Core_STM32.git#6e3f9910d0122e82a6c3438507dfac3d2fd80a39
-platform = ststm32
-board = generic_wl5e
-framework = arduino
-
-build_type = debug
-
-build_flags = 
-  ${arduino_base.build_flags}
-  -Isrc/platform/stm32wl -g
-  -DconfigUSE_CMSIS_RTOS_V2=1
-  -DVECT_TAB_OFFSET=0x08000000
-  
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/Telemetry> -<platform/nrf52> -<platform/portduino> -<platform/rp2040> -<mesh/raspihttp>
-
-board_upload.offset_address = 0x08000000
-upload_protocol = stlink
-
-lib_deps =
-  ${env.lib_deps}
-  https://github.com/kokke/tiny-AES-c.git#f06ac37fc31dfdaca2e0d9bec83f90d5663c319b
-  https://github.com/littlefs-project/littlefs.git#v2.5.1
-  https://github.com/stm32duino/STM32FreeRTOS.git#10.3.1
-
-lib_ignore =
-  mathertel/OneButton

bin/build-esp32.sh

@@ -11,7 +11,7 @@ rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio pkg update 
+platformio pkg update -e $1
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f .pio/build/$1/firmware.*

bin/build-nrf52.sh

@@ -2,8 +2,8 @@
 
 set -e
 
-VERSION=`bin/buildinfo.py long`
-SHORT_VERSION=`bin/buildinfo.py short`
+VERSION=$(bin/buildinfo.py long)
+SHORT_VERSION=$(bin/buildinfo.py short)
 
 OUTDIR=release/
 
@@ -11,7 +11,7 @@ rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio pkg update 
+platformio pkg update -e $1
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f .pio/build/$1/firmware.*
@@ -23,14 +23,26 @@ basename=firmware-$1-$VERSION
 
 pio run --environment $1 # -v
 SRCELF=.pio/build/$1/firmware.elf
-DFUPKG=.pio/build/$1/firmware.zip
 cp $SRCELF $OUTDIR/$basename.elf
+
+echo "Generating NRF52 dfu file"
+DFUPKG=.pio/build/$1/firmware.zip
 cp $DFUPKG $OUTDIR/$basename-ota.zip
 
 echo "Generating NRF52 uf2 file"
 SRCHEX=.pio/build/$1/firmware.hex
-bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
 
+# if WM1110 target, merge hex with softdevice 7.3.0
+if (echo $1 | grep -q "wio-sdk-wm1110"); then
+	echo "Merging with softdevice"
+	bin/mergehex -m bin/s140_nrf52_7.3.0_softdevice.hex $SRCHEX -o .pio/build/$1/$basename.hex
+	SRCHEX=.pio/build/$1/$basename.hex
+	bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
+	cp $SRCHEX $OUTDIR
+	cp bin/*.uf2 $OUTDIR
+else
+	bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
 	cp bin/device-install.* $OUTDIR
 	cp bin/device-update.* $OUTDIR
 	cp bin/*.uf2 $OUTDIR
+fi

bin/build-rpi2040.sh

@@ -11,7 +11,7 @@ rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio pkg update 
+platformio pkg update -e $1
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f .pio/build/$1/firmware.*

bin/build-stm32.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+set -e
+
+VERSION=$(bin/buildinfo.py long)
+SHORT_VERSION=$(bin/buildinfo.py short)
+
+OUTDIR=release/
+
+rm -f $OUTDIR/firmware*
+rm -r $OUTDIR/* || true
+
+# Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
+platformio pkg update -e $1
+
+echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
+rm -f .pio/build/$1/firmware.*
+
+# The shell vars the build tool expects to find
+export APP_VERSION=$VERSION
+
+basename=firmware-$1-$VERSION
+
+pio run --environment $1 # -v
+SRCELF=.pio/build/$1/firmware.elf
+cp $SRCELF $OUTDIR/$basename.elf
+
+SRCBIN=.pio/build/$1/firmware.bin
+cp $SRCBIN $OUTDIR/$basename.bin

bin/config-dist.yaml

@@ -54,6 +54,8 @@ Lora:
 
 #  ch341_quirk: true # Uncomment this to use the chunked SPI transfer that seems to fix the ch341
 
+#  spiSpeed: 2000000
+
 ### Set gpio chip to use in /dev/. Defaults to 0.
 ### Notably the Raspberry Pi 5 puts the GPIO header on gpiochip4
 #  gpiochip: 4
@@ -111,6 +113,9 @@ Display:
 #  Height: 320
 #  Rotate: true
 
+### You can also specify the spi device for the display to use
+# spidev: spidev0.0
+
 Touchscreen:
 ### Note, at least for now, the touchscreen must have a CS pin defined, even if you let Linux manage the CS switching.
 
@@ -126,15 +131,21 @@ Touchscreen:
 #  CS: 7
 #  IRQ: 17
 
-### Configure device for direct keyboard input
+### You can also specify the spi device for the touchscreen to use
+# spidev: spidev0.0
+
 
 Input:
+### Configure device for direct keyboard input
+
 #  KeyboardDevice: /dev/input/by-id/usb-_Raspberry_Pi_Internal_Keyboard-event-kbd
 
 ###
 
 Logging:
   LogLevel: info # debug, info, warn, error
+#  TraceFile: /var/log/meshtasticd.json
+#  AsciiLogs: true     # default if not specified is !isatty() on stdout
 
 Webserver:
 #  Port: 443 # Port for Webserver & Webservices
@@ -142,3 +153,4 @@ Webserver:
 
 General:
   MaxNodes: 200
+  MaxMessageQueue: 100

bin/platformio-custom.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 # trunk-ignore-all(ruff/F821)
 # trunk-ignore-all(flake8/F821): For SConstruct imports
 import sys
@@ -78,6 +79,11 @@ if platform.name == "espressif32":
         # For newer ESP32 targets, using newlib nano works better.
         env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
 
+if platform.name == "nordicnrf52":
+    env.AddPostAction("$BUILD_DIR/${PROGNAME}.hex",
+                      env.VerboseAction(f"{sys.executable} ./bin/uf2conv.py $BUILD_DIR/firmware.hex -c -f 0xADA52840 -o $BUILD_DIR/firmware.uf2",
+                                        "Generating UF2 file"))
+
 Import("projenv")
 
 prefsLoc = projenv["PROJECT_DIR"] + "/version.properties"

bin/readprops.py

@@ -1,9 +1,5 @@
-
-
-import subprocess
 import configparser
-import traceback
-import sys
+import subprocess
 
 
 def readProps(prefsLoc):
@@ -11,27 +7,36 @@ def readProps(prefsLoc):
 
     config = configparser.RawConfigParser()
     config.read(prefsLoc)
-    version = dict(config.items('VERSION'))
-    verObj = dict(short = "{}.{}.{}".format(version["major"], version["minor"], version["build"]),
-        long = "unset")
+    version = dict(config.items("VERSION"))
+    verObj = dict(
+        short="{}.{}.{}".format(version["major"], version["minor"], version["build"]),
+        long="unset",
+    )
 
     # Try to find current build SHA if if the workspace is clean.  This could fail if git is not installed
     try:
-        sha = subprocess.check_output(
-            ['git', 'rev-parse', '--short', 'HEAD']).decode("utf-8").strip()
-        isDirty = subprocess.check_output(
-            ['git', 'diff', 'HEAD']).decode("utf-8").strip()
+        sha = (
+            subprocess.check_output(["git", "rev-parse", "--short", "HEAD"])
+            .decode("utf-8")
+            .strip()
+        )
+        isDirty = (
+            subprocess.check_output(["git", "diff", "HEAD"]).decode("utf-8").strip()
+        )
         suffix = sha
         # if isDirty:
         #     # short for 'dirty', we want to keep our verstrings source for protobuf reasons
         #     suffix = sha + "-d"
-        verObj['long'] = "{}.{}.{}.{}".format(
-            version["major"], version["minor"], version["build"], suffix)
+        verObj["long"] = "{}.{}.{}.{}".format(
+            version["major"], version["minor"], version["build"], suffix
+        )
     except:
         # print("Unexpected error:", sys.exc_info()[0])
         # traceback.print_exc()
-        verObj['long'] = verObj['short']
+        verObj["long"] = verObj["short"]
 
     # print("firmware version " + verStr)
     return verObj
+
+
 # print("path is" + ','.join(sys.path))

bin/setup-python-for-esp-debug.sh

@@ -0,0 +1,12 @@
+# shellcheck shell=bash
+# (this minor script is actually shell agnostic, and is intended to be sourced rather than run in a subshell)
+
+# This is a little script you can source if you want to make ESP debugging work on a modern (24.04) ubuntu machine
+# It assumes you have built and installed python 2.7 from source with:
+# ./configure --enable-optimizations --enable-shared --enable-unicode=ucs4
+# sudo make clean
+# make
+# sudo make altinstall
+
+export LD_LIBRARY_PATH=$HOME/packages/python-2.7.18/
+export PYTHON_HOME=/usr/local/lib/python2.7/

bin/uf2conv.py

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

bin/wio_tracker_bootloader_update.bin

@@ -0,0 +1,30 @@
+# tips from mark on how to replace the (broken) bootloader on the red wio_tracker_1110 boards.
+
+~/.platformio/penv/bin/adafruit-nrfutil --verbose dfu serial --package wio_tracker_1110_bootloader-0.9.1_s140_7.3.0.zip -p /dev/ttyACM1 -b 115200 --singlebank --touch 1200
+
+exit
+
+# Output should look like
+
+Upgrading target on /dev/ttyACM1 with DFU package /home/kevinh/development/meshtastic/WioWM1110/wio_tracker_1110_bootloader-0.9.1_s140_7.3.0.zip. Flow control is disabled, Single bank, Touch 1200
+Touched serial port /dev/ttyACM1
+Opened serial port /dev/ttyACM1
+Starting DFU upgrade of type 3, SoftDevice size: 152728, bootloader size: 39000, application size: 0
+Sending DFU start packet
+Sending DFU init packet
+Sending firmware file
+########################################
+########################################
+########################################
+########################################
+########################################
+########################################
+########################################
+########################################
+########################################
+###############
+Activating new firmware
+
+DFU upgrade took 20.242434978485107s
+Device programmed.
+

boards/heltec_mesh_node_t114.json

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

boards/heltec_vision_master_e213.json

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

boards/heltec_vision_master_e290.json

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

boards/heltec_vision_master_t190.json

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

boards/me25ls01-4y10td.json

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

boards/tracker-t1000-e.json

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

boards/wio-sdk-wm1110.json

@@ -1,19 +1,12 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
+      "ldscript": "nrf52840_s140_v7.ld"
     },
     "core": "nRF5",
     "cpu": "cortex-m4",
     "extra_flags": "-DARDUINO_WIO_WM1110 -DNRF52840_XXAA",
     "f_cpu": "64000000L",
-    "hwids": [
-      ["0x239A", "0x8029"],
-      ["0x239A", "0x0029"],
-      ["0x239A", "0x002A"],
-      ["0x239A", "0x802A"]
-    ],
-    "usb_product": "WIO-BOOT",
     "mcu": "nrf52840",
     "variant": "Seeed_WIO_WM1110",
     "bsp": {
@@ -22,8 +15,8 @@
     "softdevice": {
       "sd_flags": "-DS140",
       "sd_name": "s140",
-      "sd_version": "6.1.1",
-      "sd_fwid": "0x00B6"
+      "sd_version": "7.3.0",
+      "sd_fwid": "0x0123"
     },
     "bootloader": {
       "settings_addr": "0xFF000"
@@ -34,7 +27,7 @@
     "jlink_device": "nRF52840_xxAA",
     "svd_path": "nrf52840.svd"
   },
-  "frameworks": ["arduino"],
+  "frameworks": ["arduino", "freertos"],
   "name": "Seeed WIO WM1110",
   "upload": {
     "maximum_ram_size": 248832,

boards/wio-t1000-s.json

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

boards/wio-tracker-wm1110.json

@@ -1,7 +1,7 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
+      "ldscript": "nrf52840_s140_v7.ld"
     },
     "core": "nRF5",
     "cpu": "cortex-m4",
@@ -22,8 +22,8 @@
     "softdevice": {
       "sd_flags": "-DS140",
       "sd_name": "s140",
-      "sd_version": "6.1.1",
-      "sd_fwid": "0x00B6"
+      "sd_version": "7.3.0",
+      "sd_fwid": "0x0123"
     },
     "bootloader": {
       "settings_addr": "0xFF000"
@@ -53,6 +53,6 @@
     "require_upload_port": true,
     "wait_for_upload_port": true
   },
-  "url": "https://www.seeedstudio.com/Wio-WM1110-Dev-Kit-p-5677.html",
+  "url": "https://www.seeedstudio.com/Wio-Tracker-1110-Dev-Board-p-5799.html",
   "vendor": "Seeed Studio"
 }

boards/wiscore_rak3172.json

@@ -1,5 +1,8 @@
 {
   "build": {
+    "arduino": {
+      "variant_h": "variant_RAK3172_MODULE.h"
+    },
     "core": "stm32",
     "cpu": "cortex-m4",
     "extra_flags": "-DSTM32WLxx -DSTM32WLE5xx -DARDUINO_GENERIC_WLE5CCUX",

boards/wiscore_rak4631.json

@@ -35,7 +35,7 @@
     "svd_path": "nrf52840.svd",
     "openocd_target": "nrf52840-mdk-rs"
   },
-  "frameworks": ["arduino"],
+  "frameworks": ["arduino", "freertos"],
   "name": "WisCore RAK4631 Board",
   "upload": {
     "maximum_ram_size": 248832,

extra_scripts/README.md

@@ -0,0 +1,3 @@
+# extra_scripts
+
+This directory contains special [scripts](https://docs.platformio.org/en/latest/scripting/index.html) that are used to modify the platformio environment in rare cases.

extra_scripts/disable_adafruit_usb.py

@@ -0,0 +1,28 @@
+# trunk-ignore-all(flake8/F821)
+# trunk-ignore-all(ruff/F821)
+
+Import("env")
+
+# NOTE: This is not currently used, but can serve as an example on how to write extra_scripts
+
+# print("Current CLI targets", COMMAND_LINE_TARGETS)
+# print("Current Build targets", BUILD_TARGETS)
+# print("CPP defs", env.get("CPPDEFINES"))
+# print(env.Dump())
+
+# Adafruit.py in the platformio build tree is a bit naive and always enables their USB stack for building.  We don't want this.
+# So come in after that python script has run and disable it.  This hack avoids us having to fork that big project and send in a PR
+# which might not be accepted. -@geeksville
+
+lib_builders = env.get("__PIO_LIB_BUILDERS", None)
+if lib_builders is not None:
+    print("Disabling Adafruit USB stack")
+    for k in lib_builders:
+        if k.name == "Adafruit TinyUSB Library":
+            libenv = k.env
+            # print(f"{k.name }: { libenv.Dump() } ")
+            # libenv["CPPDEFINES"].remove("USBCON")
+            libenv["CPPDEFINES"].remove("USE_TINYUSB")
+
+# Custom actions when building program/firmware
+# env.AddPreAction("buildprog", callback...)

monitor/filter_c3_exception_decoder.py

@@ -18,10 +18,7 @@ import subprocess
 import sys
 
 from platformio.project.exception import PlatformioException
-from platformio.public import (
-    DeviceMonitorFilterBase,
-    load_build_metadata,
-)
+from platformio.public import DeviceMonitorFilterBase, load_build_metadata
 
 # By design, __init__ is called inside miniterm and we can't pass context to it.
 # pylint: disable=attribute-defined-outside-init
@@ -32,7 +29,7 @@ IS_WINDOWS = sys.platform.startswith("win")
 class Esp32C3ExceptionDecoder(DeviceMonitorFilterBase):
     NAME = "esp32_c3_exception_decoder"
 
-    PCADDR_PATTERN = re.compile(r'0x4[0-9a-f]{7}', re.IGNORECASE)
+    PCADDR_PATTERN = re.compile(r"0x4[0-9a-f]{7}", re.IGNORECASE)
 
     def __call__(self):
         self.buffer = ""
@@ -125,14 +122,10 @@ See https://docs.platformio.org/page/projectconf/build_configurations.html
     def get_backtrace(self, match):
         trace = "\n"
         enc = "mbcs" if IS_WINDOWS else "utf-8"
-        args = [self.addr2line_path, u"-fipC", u"-e", self.firmware_path]
+        args = [self.addr2line_path, "-fipC", "-e", self.firmware_path]
         try:
             addr = match.group()
-            output = (
-                subprocess.check_output(args + [addr])
-                .decode(enc)
-                .strip()
-            )
+            output = subprocess.check_output(args + [addr]).decode(enc).strip()
             output = output.replace(
                 "\n", "\n     "
             )  # newlines happen with inlined methods

platformio.ini

@@ -29,14 +29,24 @@ default_envs = tbeam
 ;default_envs = meshtastic-dr-dev
 ;default_envs = m5stack-coreink
 ;default_envs = rak4631
+;default_envs = rak2560
 ;default_envs = rak10701
 ;default_envs = wio-e5
+;default_envs = radiomaster_900_bandit_nano
+;default_envs = radiomaster_900_bandit_micro
+;default_envs = radiomaster_900_bandit
+;default_envs = heltec_capsule_sensor_v3
+;default_envs = heltec_vision_master_t190
+;default_envs = heltec_vision_master_e213
+;default_envs = heltec_vision_master_e290
+;default_envs = heltec_mesh_node_t114
 
 extra_configs =
   arch/*/*.ini
   variants/*/platformio.ini
 
 [env]
+test_build_src = true
 extra_scripts = bin/platformio-custom.py
 
 ; note: we add src to our include search path so that lmic_project_config can override
@@ -70,13 +80,15 @@ build_flags = -Wno-missing-field-initializers
   -DRADIOLIB_EXCLUDE_FSK4
   -DRADIOLIB_EXCLUDE_APRS
   -DRADIOLIB_EXCLUDE_LORAWAN
+  -DMESHTASTIC_EXCLUDE_DROPZONE=1
 
 monitor_speed = 115200
+monitor_filters = direct
 
 lib_deps =
   jgromes/RadioLib@~6.6.0
-  https://github.com/meshtastic/esp8266-oled-ssd1306.git#ee628ee6c9588d4c56c9e3da35f0fc9448ad54a8 ; ESP8266_SSD1306
-  mathertel/OneButton@^2.5.0 ; OneButton library for non-blocking button debounce
+  https://github.com/meshtastic/esp8266-oled-ssd1306.git#e16cee124fe26490cb14880c679321ad8ac89c95 ; ESP8266_SSD1306
+  https://github.com/mathertel/OneButton@~2.6.1 ; OneButton library for non-blocking button debounce
   https://github.com/meshtastic/arduino-fsm.git#7db3702bf0cfe97b783d6c72595e3f38e0b19159
   https://github.com/meshtastic/TinyGPSPlus.git#71a82db35f3b973440044c476d4bcdc673b104f4
   https://github.com/meshtastic/ArduinoThread.git#1ae8778c85d0a2a729f989e0b1e7d7c4dc84eef0
@@ -118,10 +130,7 @@ lib_deps =
   adafruit/Adafruit BMP280 Library@^2.6.8
   adafruit/Adafruit BMP085 Library@^1.2.4
   adafruit/Adafruit BME280 Library@^2.2.2
-  https://github.com/boschsensortec/Bosch-BSEC2-Library#v1.7.2502
-  boschsensortec/BME68x Sensor Library@^1.1.40407
   adafruit/Adafruit MCP9808 Library@^2.0.0
-  https://github.com/KodinLanewave/INA3221@^1.0.0
   adafruit/Adafruit INA260 Library@^1.5.0
   adafruit/Adafruit INA219@^1.2.0
   adafruit/Adafruit SHTC3 Library@^1.0.0
@@ -131,13 +140,21 @@ lib_deps =
   adafruit/Adafruit MPU6050@^2.2.4
   adafruit/Adafruit LIS3DH@^1.2.4
   adafruit/Adafruit AHTX0@^2.0.5
-  lewisxhe/SensorLib@^0.2.0
   adafruit/Adafruit LSM6DS@^4.7.2
-  mprograms/QMC5883LCompass@^1.2.0
   adafruit/Adafruit VEML7700 Library@^2.1.6
   adafruit/Adafruit SHT4x Library@^1.0.4
   adafruit/Adafruit TSL2591 Library@^1.4.5
+  sparkfun/SparkFun Qwiic Scale NAU7802 Arduino Library@^1.0.5
   ClosedCube OPT3001@^1.1.2
   emotibit/EmotiBit MLX90632@^1.0.8
   dfrobot/DFRobot_RTU@^1.0.3
-  https://github.com/meshtastic/DFRobot_LarkWeatherStation#0e884fc86b7a0b602c7ff3d26b893b997f15c6ac
+
+
+  https://github.com/boschsensortec/Bosch-BSEC2-Library#v1.7.2502
+  boschsensortec/BME68x Sensor Library@^1.1.40407
+  https://github.com/KodinLanewave/INA3221@^1.0.0
+  lewisxhe/SensorLib@^0.2.0
+  mprograms/QMC5883LCompass@^1.2.0
+  
+
+  https://github.com/meshtastic/DFRobot_LarkWeatherStation#dee914270dc7cb3e43fbf034edd85a63a16a12ee

pyocd.yaml

@@ -0,0 +1,7 @@
+# This is a config file to control pyocd ICE debugger probe options (only used for NRF52 targets with hardware debugging connections)
+# for more info see FIXMEURL
+
+# console or telnet
+semihost_console_type: telnet
+enable_semihosting: True
+telnet_port: 4444

src/AccelerometerThread.h

@@ -14,6 +14,12 @@
 #include <Arduino.h>
 #include <SensorBMA423.hpp>
 #include <Wire.h>
+#ifdef RAK_4631
+#include "Fusion/Fusion.h"
+#include "graphics/Screen.h"
+#include "graphics/ScreenFonts.h"
+#include <Rak_BMX160.h>
+#endif
 
 #define ACCELEROMETER_CHECK_INTERVAL_MS 100
 #define ACCELEROMETER_CLICK_THRESHOLD 40
@@ -50,12 +56,13 @@ class AccelerometerThread : public concurrency::OSThread
             return;
         }
         acceleremoter_type = type;
-
+#ifndef RAK_4631
         if (!config.display.wake_on_tap_or_motion && !config.device.double_tap_as_button_press) {
             LOG_DEBUG("AccelerometerThread disabling due to no interested configurations\n");
             disable();
             return;
         }
+#endif
         init();
     }
 
@@ -87,6 +94,79 @@ class AccelerometerThread : public concurrency::OSThread
                 wakeScreen();
                 return 500;
             }
+#ifdef RAK_4631
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMX160) {
+            sBmx160SensorData_t magAccel;
+            sBmx160SensorData_t gAccel;
+
+            /* Get a new sensor event */
+            bmx160.getAllData(&magAccel, NULL, &gAccel);
+
+            // expirimental calibrate routine. Limited to between 10 and 30 seconds after boot
+            if (millis() > 12 * 1000 && millis() < 30 * 1000) {
+                if (!showingScreen) {
+                    showingScreen = true;
+                    screen->startAlert((FrameCallback)drawFrameCalibration);
+                }
+                if (magAccel.x > highestX)
+                    highestX = magAccel.x;
+                if (magAccel.x < lowestX)
+                    lowestX = magAccel.x;
+                if (magAccel.y > highestY)
+                    highestY = magAccel.y;
+                if (magAccel.y < lowestY)
+                    lowestY = magAccel.y;
+                if (magAccel.z > highestZ)
+                    highestZ = magAccel.z;
+                if (magAccel.z < lowestZ)
+                    lowestZ = magAccel.z;
+            } else if (showingScreen && millis() >= 30 * 1000) {
+                showingScreen = false;
+                screen->endAlert();
+            }
+
+            int highestRealX = highestX - (highestX + lowestX) / 2;
+
+            magAccel.x -= (highestX + lowestX) / 2;
+            magAccel.y -= (highestY + lowestY) / 2;
+            magAccel.z -= (highestZ + lowestZ) / 2;
+            FusionVector ga, ma;
+            ga.axis.x = -gAccel.x; // default location for the BMX160 is on the rear of the board
+            ga.axis.y = -gAccel.y;
+            ga.axis.z = gAccel.z;
+            ma.axis.x = -magAccel.x;
+            ma.axis.y = -magAccel.y;
+            ma.axis.z = magAccel.z * 3;
+
+            // If we're set to one of the inverted positions
+            if (config.display.compass_orientation > meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270) {
+                ma = FusionAxesSwap(ma, FusionAxesAlignmentNXNYPZ);
+                ga = FusionAxesSwap(ga, FusionAxesAlignmentNXNYPZ);
+            }
+
+            float heading = FusionCompassCalculateHeading(FusionConventionNed, ga, ma);
+
+            switch (config.display.compass_orientation) {
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0_INVERTED:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0:
+                break;
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_90:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_90_INVERTED:
+                heading += 90;
+                break;
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_180:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_180_INVERTED:
+                heading += 180;
+                break;
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED:
+                heading += 270;
+                break;
+            }
+
+            screen->setHeading(heading);
+
+#endif
         } else if (acceleremoter_type == ScanI2C::DeviceType::LSM6DS3 && lsm.shake()) {
             wakeScreen();
             return 500;
@@ -149,6 +229,11 @@ class AccelerometerThread : public concurrency::OSThread
             bmaSensor.enableTiltIRQ();
             // It corresponds to isDoubleClick interrupt
             bmaSensor.enableWakeupIRQ();
+#ifdef RAK_4631
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMX160 && bmx160.begin()) {
+            bmx160.ODR_Config(BMX160_ACCEL_ODR_100HZ, BMX160_GYRO_ODR_100HZ); // set output data rate
+
+#endif
         } else if (acceleremoter_type == ScanI2C::DeviceType::LSM6DS3 && lsm.begin_I2C(accelerometer_found.address)) {
             LOG_DEBUG("LSM6DS3 initializing\n");
             // Default threshold of 2G, less sensitive options are 4, 8 or 16G
@@ -180,6 +265,33 @@ class AccelerometerThread : public concurrency::OSThread
     Adafruit_LSM6DS3TRC lsm;
     SensorBMA423 bmaSensor;
     bool BMA_IRQ = false;
+#ifdef RAK_4631
+    bool showingScreen = false;
+    RAK_BMX160 bmx160;
+    float highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+
+    static void drawFrameCalibration(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+    {
+        int x_offset = display->width() / 2;
+        int y_offset = display->height() <= 80 ? 0 : 32;
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+        display->setFont(FONT_MEDIUM);
+        display->drawString(x, y, "Calibrating\nCompass");
+        int16_t compassX = 0, compassY = 0;
+        uint16_t compassDiam = graphics::Screen::getCompassDiam(display->getWidth(), display->getHeight());
+
+        // coordinates for the center of the compass/circle
+        if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
+            compassX = x + display->getWidth() - compassDiam / 2 - 5;
+            compassY = y + display->getHeight() / 2;
+        } else {
+            compassX = x + display->getWidth() - compassDiam / 2 - 5;
+            compassY = y + FONT_HEIGHT_SMALL + (display->getHeight() - FONT_HEIGHT_SMALL) / 2;
+        }
+        display->drawCircle(compassX, compassY, compassDiam / 2);
+        screen->drawCompassNorth(display, compassX, compassY, screen->getHeading() * PI / 180);
+    }
+#endif
 };
 
 #endif

src/AmbientLightingThread.h

@@ -1,3 +1,4 @@
+#include "Observer.h"
 #include "configuration.h"
 
 #ifdef HAS_NCP5623
@@ -22,10 +23,18 @@ class AmbientLightingThread : public concurrency::OSThread
   public:
     explicit AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLightingThread")
     {
+        notifyDeepSleepObserver.observe(&notifyDeepSleep); // Let us know when shutdown() is issued.
+
+// Enables Ambient Lighting by default if conditions are meet.
+#if defined(HAS_NCP5623) || defined(RGBLED_RED) || defined(HAS_NEOPIXEL) || defined(UNPHONE)
+#ifdef ENABLE_AMBIENTLIGHTING
+        moduleConfig.ambient_lighting.led_state = true;
+#endif
+#endif
         // Uncomment to test module
         // moduleConfig.ambient_lighting.led_state = true;
         // moduleConfig.ambient_lighting.current = 10;
-        // // Default to a color based on our node number
+        // Default to a color based on our node number
         // moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
         // moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
         // moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
@@ -82,9 +91,46 @@ class AmbientLightingThread : public concurrency::OSThread
         return disable();
     }
 
+    // When shutdown() is issued, setLightingOff will be called.
+    CallbackObserver<AmbientLightingThread, void *> notifyDeepSleepObserver =
+        CallbackObserver<AmbientLightingThread, void *>(this, &AmbientLightingThread::setLightingOff);
+
   private:
     ScanI2C::DeviceType _type = ScanI2C::DeviceType::NONE;
 
+    // Turn RGB lighting off, is used in junction to shutdown()
+    int setLightingOff(void *unused)
+    {
+#ifdef HAS_NCP5623
+        rgb.setCurrent(0);
+        rgb.setRed(0);
+        rgb.setGreen(0);
+        rgb.setBlue(0);
+        LOG_INFO("Turn Off NCP5623 Ambient lighting.\n");
+#endif
+#ifdef HAS_NEOPIXEL
+        pixels.clear();
+        pixels.show();
+        LOG_INFO("Turn Off NeoPixel Ambient lighting.\n");
+#endif
+#ifdef RGBLED_CA
+        analogWrite(RGBLED_RED, 255 - 0);
+        analogWrite(RGBLED_GREEN, 255 - 0);
+        analogWrite(RGBLED_BLUE, 255 - 0);
+        LOG_INFO("Turn Off Ambient lighting RGB Common Anode.\n");
+#elif defined(RGBLED_RED)
+        analogWrite(RGBLED_RED, 0);
+        analogWrite(RGBLED_GREEN, 0);
+        analogWrite(RGBLED_BLUE, 0);
+        LOG_INFO("Turn Off Ambient lighting RGB Common Cathode.\n");
+#endif
+#ifdef UNPHONE
+        unphone.rgb(0, 0, 0);
+        LOG_INFO("Turn Off unPhone Ambient lighting.\n");
+#endif
+        return 0;
+    }
+
     void setLighting()
     {
 #ifdef HAS_NCP5623
@@ -100,6 +146,17 @@ class AmbientLightingThread : public concurrency::OSThread
         pixels.fill(pixels.Color(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
                                  moduleConfig.ambient_lighting.blue),
                     0, NEOPIXEL_COUNT);
+
+// RadioMaster Bandit has addressable LED at the two buttons
+// this allow us to set different lighting for them in variant.h file.
+#ifdef RADIOMASTER_900_BANDIT
+#if defined(BUTTON1_COLOR) && defined(BUTTON1_COLOR_INDEX)
+        pixels.fill(BUTTON1_COLOR, BUTTON1_COLOR_INDEX, 1);
+#endif
+#if defined(BUTTON2_COLOR) && defined(BUTTON2_COLOR_INDEX)
+        pixels.fill(BUTTON2_COLOR, BUTTON1_COLOR_INDEX, 1);
+#endif
+#endif
         pixels.show();
         LOG_DEBUG("Initializing NeoPixel Ambient lighting w/ brightness(current)=%d, red=%d, green=%d, blue=%d\n",
                   moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,

src/BluetoothCommon.cpp

@@ -11,3 +11,7 @@ const uint8_t FROMRADIO_UUID_16[16u] = {0x02, 0x00, 0x12, 0xac, 0x42, 0x02, 0x78
                                         0xed, 0x11, 0x93, 0x49, 0x9e, 0xe6, 0x55, 0x2c};
 const uint8_t FROMNUM_UUID_16[16u] = {0x53, 0x44, 0xe3, 0x47, 0x75, 0xaa, 0x70, 0xa6,
                                       0x66, 0x4f, 0x00, 0xa8, 0x8c, 0xa1, 0x9d, 0xed};
+const uint8_t LEGACY_LOGRADIO_UUID_16[16u] = {0xe2, 0xf2, 0x1e, 0xbe, 0xc5, 0x15, 0xcf, 0xaa,
+                                              0x6b, 0x43, 0xfa, 0x78, 0x38, 0xd2, 0x6f, 0x6c};
+const uint8_t LOGRADIO_UUID_16[16u] = {0x47, 0x95, 0xDF, 0x8C, 0xDE, 0xE9, 0x44, 0x99,
+                                       0x23, 0x44, 0xE6, 0x06, 0x49, 0x6E, 0x3D, 0x5A};

src/BluetoothCommon.h

@@ -11,10 +11,12 @@
 #define TORADIO_UUID "f75c76d2-129e-4dad-a1dd-7866124401e7"
 #define FROMRADIO_UUID "2c55e69e-4993-11ed-b878-0242ac120002"
 #define FROMNUM_UUID "ed9da18c-a800-4f66-a670-aa7547e34453"
+#define LEGACY_LOGRADIO_UUID "6c6fd238-78fa-436b-aacf-15c5be1ef2e2"
+#define LOGRADIO_UUID "5a3d6e49-06e6-4423-9944-e9de8cdf9547"
 
 // NRF52 wants these constants as byte arrays
 // Generated here https://yupana-engineering.com/online-uuid-to-c-array-converter - but in REVERSE BYTE ORDER
-extern const uint8_t MESH_SERVICE_UUID_16[], TORADIO_UUID_16[16u], FROMRADIO_UUID_16[], FROMNUM_UUID_16[];
+extern const uint8_t MESH_SERVICE_UUID_16[], TORADIO_UUID_16[16u], FROMRADIO_UUID_16[], FROMNUM_UUID_16[], LOGRADIO_UUID_16[];
 
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level);

src/ButtonThread.cpp

@@ -29,7 +29,6 @@ volatile ButtonThread::ButtonEventType ButtonThread::btnEvent = ButtonThread::BU
 #if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
 OneButton ButtonThread::userButton; // Get reference to static member
 #endif
-
 ButtonThread::ButtonThread() : OSThread("Button")
 {
 #if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
@@ -41,14 +40,24 @@ ButtonThread::ButtonThread() : OSThread("Button")
     }
 #elif defined(BUTTON_PIN)
     int pin = config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN; // Resolved button pin
+#if defined(HELTEC_CAPSULE_SENSOR_V3)
+    this->userButton = OneButton(pin, false, false);
+#elif defined(BUTTON_ACTIVE_LOW)
+    this->userButton = OneButton(pin, BUTTON_ACTIVE_LOW, BUTTON_ACTIVE_PULLUP);
+#else
     this->userButton = OneButton(pin, true, true);
+#endif
     LOG_DEBUG("Using GPIO%02d for button\n", pin);
 #endif
 
 #ifdef INPUT_PULLUP_SENSE
     // Some platforms (nrf52) have a SENSE variant which allows wake from sleep - override what OneButton did
+#ifdef BUTTON_SENSE_TYPE
+    pinMode(pin, BUTTON_SENSE_TYPE);
+#else
     pinMode(pin, INPUT_PULLUP_SENSE);
 #endif
+#endif
 
 #if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
     userButton.attachClick(userButtonPressed);
@@ -135,8 +144,8 @@ int32_t ButtonThread::runOnce()
 
         case BUTTON_EVENT_DOUBLE_PRESSED: {
             LOG_BUTTON("Double press!\n");
-            service.refreshLocalMeshNode();
-            auto sentPosition = service.trySendPosition(NODENUM_BROADCAST, true);
+            service->refreshLocalMeshNode();
+            auto sentPosition = service->trySendPosition(NODENUM_BROADCAST, true);
             if (screen) {
                 if (sentPosition)
                     screen->print("Sent ad-hoc position\n");
@@ -177,8 +186,9 @@ int32_t ButtonThread::runOnce()
         case BUTTON_EVENT_LONG_PRESSED: {
             LOG_BUTTON("Long press!\n");
             powerFSM.trigger(EVENT_PRESS);
-            if (screen)
-                screen->startShutdownScreen();
+            if (screen) {
+                screen->startAlert("Shutting down...");
+            }
             playBeep();
             break;
         }
@@ -214,7 +224,6 @@ int32_t ButtonThread::runOnce()
         btnEvent = BUTTON_EVENT_NONE;
     }
 
-    runASAP = false;
     return 50;
 }
 

src/ButtonThread.h

@@ -13,7 +13,7 @@
 #endif
 
 #ifndef BUTTON_TOUCH_MS
-#define BUTTON_TOCH_MS 400
+#define BUTTON_TOUCH_MS 400
 #endif
 
 class ButtonThread : public concurrency::OSThread

src/DebugConfiguration.cpp

@@ -26,7 +26,21 @@ SOFTWARE.*/
 
 #include "DebugConfiguration.h"
 
-#if HAS_WIFI || HAS_ETHERNET
+#ifdef ARCH_PORTDUINO
+#include "platform/portduino/PortduinoGlue.h"
+#endif
+
+/// A C wrapper for LOG_DEBUG that can be used from arduino C libs that don't know about C++ or meshtastic
+extern "C" void logLegacy(const char *level, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    if (console)
+        console->vprintf(level, fmt, args);
+    va_end(args);
+}
+
+#if HAS_NETWORKING
 
 Syslog::Syslog(UDP &client)
 {
@@ -129,6 +143,11 @@ bool Syslog::vlogf(uint16_t pri, const char *appName, const char *fmt, va_list a
 inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *message)
 {
     int result;
+#ifdef ARCH_PORTDUINO
+    bool utf = !settingsMap[ascii_logs];
+#else
+    bool utf = true;
+#endif
 
     if (!this->_enabled)
         return false;
@@ -159,7 +178,12 @@ inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *mess
     this->_client->print(this->_deviceHostname);
     this->_client->print(' ');
     this->_client->print(appName);
-    this->_client->print(F(" - - - \xEF\xBB\xBF"));
+    this->_client->print(F(" - - - "));
+    if (utf) {
+        this->_client->print(F("\xEF\xBB\xBF"));
+    } else {
+        this->_client->print(F(" "));
+    }
     this->_client->print(F("["));
     this->_client->print(int(millis() / 1000));
     this->_client->print(F("]: "));

src/DebugConfiguration.h

@@ -1,9 +1,10 @@
-#ifndef SYSLOG_H
-#define SYSLOG_H
+#pragma once
+
+#include "configuration.h"
 
 // DEBUG LED
-#ifndef LED_INVERTED
-#define LED_INVERTED 0 // define as 1 if LED is active low (on)
+#ifndef LED_STATE_ON
+#define LED_STATE_ON 1
 #endif
 
 // -----------------------------------------------------------------------------
@@ -25,6 +26,14 @@
 
 #include "SerialConsole.h"
 
+// If defined we will include support for ARM ICE "semihosting" for a virtual
+// console over the JTAG port (to replace the normal serial port)
+// Note: Normally this flag is passed into the gcc commandline by platformio.ini.
+// for an example see env:rak4631_dap.
+// #ifndef USE_SEMIHOSTING
+// #define USE_SEMIHOSTING
+// #endif
+
 #define DEBUG_PORT (*console) // Serial debug port
 
 #ifdef USE_SEGGER
@@ -36,7 +45,7 @@
 #define LOG_CRIT(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #define LOG_TRACE(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #else
-#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE) && !defined(PIO_UNIT_TESTING)
 #define LOG_DEBUG(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_DEBUG, __VA_ARGS__)
 #define LOG_INFO(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_INFO, __VA_ARGS__)
 #define LOG_WARN(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_WARN, __VA_ARGS__)
@@ -53,6 +62,9 @@
 #endif
 #endif
 
+/// A C wrapper for LOG_DEBUG that can be used from arduino C libs that don't know about C++ or meshtastic
+extern "C" void logLegacy(const char *level, const char *fmt, ...);
+
 #define SYSLOG_NILVALUE "-"
 
 #define SYSLOG_CRIT 2  /* critical conditions */
@@ -117,7 +129,7 @@
 #include <WiFi.h>
 #endif // HAS_WIFI
 
-#if HAS_WIFI || HAS_ETHERNET
+#if HAS_NETWORKING
 
 class Syslog
 {
@@ -153,5 +165,3 @@ class Syslog
 };
 
 #endif // HAS_ETHERNET || HAS_WIFI
-
-#endif // SYSLOG_H

src/DisplayFormatters.cpp

@@ -3,6 +3,9 @@
 const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName)
 {
     switch (preset) {
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+        return useShortName ? "ShortT" : "ShortTurbo";
+        break;
     case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
         return useShortName ? "ShortS" : "ShortSlow";
         break;

src/FSCommon.cpp

@@ -24,6 +24,39 @@ SPIClass SPI1(HSPI);
 
 #endif // HAS_SDCARD
 
+#if defined(ARCH_STM32WL)
+
+uint16_t OSFS::startOfEEPROM = 1;
+uint16_t OSFS::endOfEEPROM = 2048;
+
+// 3) How do I read from the medium?
+void OSFS::readNBytes(uint16_t address, unsigned int num, byte *output)
+{
+    for (uint16_t i = address; i < address + num; i++) {
+        *output = EEPROM.read(i);
+        output++;
+    }
+}
+
+// 4) How to I write to the medium?
+void OSFS::writeNBytes(uint16_t address, unsigned int num, const byte *input)
+{
+    for (uint16_t i = address; i < address + num; i++) {
+        EEPROM.update(i, *input);
+        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\n", reason);
+    lfs_assert_failed = true;
+}
+
 /**
  * @brief Copies a file from one location to another.
  *
@@ -33,7 +66,33 @@ SPIClass SPI1(HSPI);
  */
 bool copyFile(const char *from, const char *to)
 {
-#ifdef FSCom
+#ifdef ARCH_STM32WL
+    unsigned char cbuffer[2048];
+
+    // Var to hold the result of actions
+    OSFS::result r;
+
+    r = OSFS::getFile(from, cbuffer);
+
+    if (r == notfound) {
+        LOG_ERROR("Failed to open source file %s\n", from);
+        return false;
+    } else if (r == noerr) {
+        r = OSFS::newFile(to, cbuffer, true);
+        if (r == noerr) {
+            return true;
+        } else {
+            LOG_ERROR("OSFS Error %d\n", r);
+            return false;
+        }
+
+    } else {
+        LOG_ERROR("OSFS Error %d\n", r);
+        return false;
+    }
+    return true;
+
+#elif defined(FSCom)
     unsigned char cbuffer[16];
 
     File f1 = FSCom.open(from, FILE_O_READ);
@@ -70,7 +129,13 @@ bool copyFile(const char *from, const char *to)
  */
 bool renameFile(const char *pathFrom, const char *pathTo)
 {
-#ifdef FSCom
+#ifdef ARCH_STM32WL
+    if (copyFile(pathFrom, pathTo) && (OSFS::deleteFile(pathFrom) == OSFS::result::NO_ERROR)) {
+        return true;
+    } else {
+        return false;
+    }
+#elif defined(FSCom)
 #ifdef ARCH_ESP32
     // rename was fixed for ESP32 IDF LittleFS in April
     return FSCom.rename(pathFrom, pathTo);
@@ -84,6 +149,58 @@ bool renameFile(const char *pathFrom, const char *pathTo)
 #endif
 }
 
+#include <vector>
+
+/**
+ * @brief Get the list of files in a directory.
+ *
+ * This function returns a list of files in a directory. The list includes the full path of each file.
+ *
+ * @param dirname The name of the directory.
+ * @param levels The number of levels of subdirectories to list.
+ * @return A vector of strings containing the full path of each file in the directory.
+ */
+std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
+{
+    std::vector<meshtastic_FileInfo> filenames = {};
+#ifdef FSCom
+    File root = FSCom.open(dirname, FILE_O_READ);
+    if (!root)
+        return filenames;
+    if (!root.isDirectory())
+        return filenames;
+
+    File file = root.openNextFile();
+    while (file) {
+        if (file.isDirectory() && !String(file.name()).endsWith(".")) {
+            if (levels) {
+#ifdef ARCH_ESP32
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.path(), levels - 1);
+#else
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.name(), levels - 1);
+#endif
+                filenames.insert(filenames.end(), subDirFilenames.begin(), subDirFilenames.end());
+                file.close();
+            }
+        } else {
+            meshtastic_FileInfo fileInfo = {"", file.size()};
+#ifdef ARCH_ESP32
+            strcpy(fileInfo.file_name, file.path());
+#else
+            strcpy(fileInfo.file_name, file.name());
+#endif
+            if (!String(fileInfo.file_name).endsWith(".")) {
+                filenames.push_back(fileInfo);
+            }
+            file.close();
+        }
+        file = root.openNextFile();
+    }
+    root.close();
+#endif
+    return filenames;
+}
+
 /**
  * Lists the contents of a directory.
  *
@@ -91,7 +208,7 @@ bool renameFile(const char *pathFrom, const char *pathTo)
  * @param levels The number of levels of subdirectories to list.
  * @param del Whether or not to delete the contents of the directory after listing.
  */
-void listDir(const char *dirname, uint8_t levels, bool del = false)
+void listDir(const char *dirname, uint8_t levels, bool del)
 {
 #ifdef FSCom
 #if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
@@ -106,7 +223,9 @@ void listDir(const char *dirname, uint8_t levels, bool del = false)
     }
 
     File file = root.openNextFile();
-    while (file) {
+    while (
+        file &&
+        file.name()[0]) { // This file.name() check is a workaround for a bug in the Adafruit LittleFS nrf52 glue (see issue 4395)
         if (file.isDirectory() && !String(file.name()).endsWith(".")) {
             if (levels) {
 #ifdef ARCH_ESP32
@@ -130,6 +249,7 @@ void listDir(const char *dirname, uint8_t levels, bool del = false)
                     file.close();
                 }
 #else
+                LOG_DEBUG(" %s (directory)\n", file.name());
                 listDir(file.name(), levels - 1, del);
                 file.close();
 #endif
@@ -205,62 +325,6 @@ void rmDir(const char *dirname)
 #endif
 }
 
-bool fsCheck()
-{
-#if defined(ARCH_NRF52)
-    size_t write_size = 0;
-    size_t read_size = 0;
-    char buf[32] = {0};
-
-    Adafruit_LittleFS_Namespace::File file(FSCom);
-    const char *text = "meshtastic fs test";
-    size_t text_length = strlen(text);
-    const char *filename = "/meshtastic.txt";
-
-    LOG_DEBUG("Try create file .\n");
-    if (file.open(filename, FILE_O_WRITE)) {
-        write_size = file.write(text);
-    } else {
-        LOG_DEBUG("Open file failed .\n");
-        goto FORMAT_FS;
-    }
-
-    if (write_size != text_length) {
-        LOG_DEBUG("Text bytes do not match .\n");
-        file.close();
-        goto FORMAT_FS;
-    }
-
-    file.close();
-
-    if (!file.open(filename, FILE_O_READ)) {
-        LOG_DEBUG("Open file failed .\n");
-        goto FORMAT_FS;
-    }
-
-    read_size = file.readBytes(buf, text_length);
-    if (read_size != text_length) {
-        LOG_DEBUG("Text bytes do not match .\n");
-        file.close();
-        goto FORMAT_FS;
-    }
-
-    if (memcmp(buf, text, text_length) != 0) {
-        LOG_DEBUG("The written bytes do not match the read bytes .\n");
-        file.close();
-        goto FORMAT_FS;
-    }
-    return true;
-FORMAT_FS:
-    LOG_DEBUG("Format FS ....\n");
-    FSCom.format();
-    FSCom.begin();
-    return false;
-#else
-    return true;
-#endif
-}
-
 void fsInit()
 {
 #ifdef FSCom
@@ -270,35 +334,6 @@ void fsInit()
     }
 #if defined(ARCH_ESP32)
     LOG_DEBUG("Filesystem files (%d/%d Bytes):\n", FSCom.usedBytes(), FSCom.totalBytes());
-#elif defined(ARCH_NRF52)
-    /*
-     * nRF52840 has a certain chance of automatic formatting failure.
-     * Try to create a file after initializing the file system. If the creation fails,
-     * it means that the file system is not working properly. Please format it manually again.
-     * To check the normality of the file system, you need to disable the LFS_NO_ASSERT assertion.
-     * Otherwise, the assertion will be entered at the moment of reading or opening, and the FS will not be formatted.
-     * */
-    bool ret = false;
-    uint8_t retry = 3;
-
-    while (retry--) {
-        ret = fsCheck();
-        if (ret) {
-            LOG_DEBUG("File system check is OK.\n");
-            break;
-        }
-        delay(10);
-    }
-
-    // It may not be possible to reach this step.
-    // Add a loop here to prevent unpredictable situations from happening.
-    // Can add a screen to display error status later.
-    if (!ret) {
-        while (1) {
-            LOG_ERROR("The file system is damaged and cannot proceed to the next step.\n");
-            delay(1000);
-        }
-    }
 #else
     LOG_DEBUG("Filesystem files:\n");
 #endif

src/FSCommon.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "configuration.h"
+#include <vector>
 
 // Cross platform filesystem API
 
@@ -14,10 +15,13 @@
 #endif
 
 #if defined(ARCH_STM32WL)
-#include "platform/stm32wl/InternalFileSystem.h" // STM32WL version
-#define FSCom InternalFS
-#define FSBegin() FSCom.begin()
-using namespace LittleFS_Namespace;
+// STM32WL series 2 Kbytes (8 rows of 256 bytes)
+#include <EEPROM.h>
+#include <OSFS.h>
+
+// Useful consts
+const OSFS::result noerr = OSFS::result::NO_ERROR;
+const OSFS::result notfound = OSFS::result::FILE_NOT_FOUND;
 #endif
 
 #if defined(ARCH_RP2040)
@@ -47,8 +51,13 @@ using namespace Adafruit_LittleFS_Namespace;
 #endif
 
 void fsInit();
+void fsListFiles();
 bool copyFile(const char *from, const char *to);
 bool renameFile(const char *pathFrom, const char *pathTo);
-void listDir(const char *dirname, uint8_t levels, bool del);
+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)

src/Fusion/Fusion.h

@@ -0,0 +1,32 @@
+/**
+ * @file Fusion.h
+ * @author Seb Madgwick
+ * @brief Main header file for the Fusion library.  This is the only file that
+ * needs to be included when using the library.
+ */
+
+#ifndef FUSION_H
+#define FUSION_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "FusionAhrs.h"
+#include "FusionAxes.h"
+#include "FusionCalibration.h"
+#include "FusionCompass.h"
+#include "FusionConvention.h"
+#include "FusionMath.h"
+#include "FusionOffset.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionAhrs.c

@@ -0,0 +1,542 @@
+/**
+ * @file FusionAhrs.c
+ * @author Seb Madgwick
+ * @brief AHRS algorithm to combine gyroscope, accelerometer, and magnetometer
+ * measurements into a single measurement of orientation relative to the Earth.
+ */
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionAhrs.h"
+#include <float.h> // FLT_MAX
+#include <math.h>  // atan2f, cosf, fabsf, powf, sinf
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief Initial gain used during the initialisation.
+ */
+#define INITIAL_GAIN (10.0f)
+
+/**
+ * @brief Initialisation period in seconds.
+ */
+#define INITIALISATION_PERIOD (3.0f)
+
+//------------------------------------------------------------------------------
+// Function declarations
+
+static inline FusionVector HalfGravity(const FusionAhrs *const ahrs);
+
+static inline FusionVector HalfMagnetic(const FusionAhrs *const ahrs);
+
+static inline FusionVector Feedback(const FusionVector sensor, const FusionVector reference);
+
+static inline int Clamp(const int value, const int min, const int max);
+
+//------------------------------------------------------------------------------
+// Functions
+
+/**
+ * @brief Initialises the AHRS algorithm structure.
+ * @param ahrs AHRS algorithm structure.
+ */
+void FusionAhrsInitialise(FusionAhrs *const ahrs)
+{
+    const FusionAhrsSettings settings = {
+        .convention = FusionConventionNwu,
+        .gain = 0.5f,
+        .gyroscopeRange = 0.0f,
+        .accelerationRejection = 90.0f,
+        .magneticRejection = 90.0f,
+        .recoveryTriggerPeriod = 0,
+    };
+    FusionAhrsSetSettings(ahrs, &settings);
+    FusionAhrsReset(ahrs);
+}
+
+/**
+ * @brief Resets the AHRS algorithm.  This is equivalent to reinitialising the
+ * algorithm while maintaining the current settings.
+ * @param ahrs AHRS algorithm structure.
+ */
+void FusionAhrsReset(FusionAhrs *const ahrs)
+{
+    ahrs->quaternion = FUSION_IDENTITY_QUATERNION;
+    ahrs->accelerometer = FUSION_VECTOR_ZERO;
+    ahrs->initialising = true;
+    ahrs->rampedGain = INITIAL_GAIN;
+    ahrs->angularRateRecovery = false;
+    ahrs->halfAccelerometerFeedback = FUSION_VECTOR_ZERO;
+    ahrs->halfMagnetometerFeedback = FUSION_VECTOR_ZERO;
+    ahrs->accelerometerIgnored = false;
+    ahrs->accelerationRecoveryTrigger = 0;
+    ahrs->accelerationRecoveryTimeout = ahrs->settings.recoveryTriggerPeriod;
+    ahrs->magnetometerIgnored = false;
+    ahrs->magneticRecoveryTrigger = 0;
+    ahrs->magneticRecoveryTimeout = ahrs->settings.recoveryTriggerPeriod;
+}
+
+/**
+ * @brief Sets the AHRS algorithm settings.
+ * @param ahrs AHRS algorithm structure.
+ * @param settings Settings.
+ */
+void FusionAhrsSetSettings(FusionAhrs *const ahrs, const FusionAhrsSettings *const settings)
+{
+    ahrs->settings.convention = settings->convention;
+    ahrs->settings.gain = settings->gain;
+    ahrs->settings.gyroscopeRange = settings->gyroscopeRange == 0.0f ? FLT_MAX : 0.98f * settings->gyroscopeRange;
+    ahrs->settings.accelerationRejection = settings->accelerationRejection == 0.0f
+                                               ? FLT_MAX
+                                               : powf(0.5f * sinf(FusionDegreesToRadians(settings->accelerationRejection)), 2);
+    ahrs->settings.magneticRejection =
+        settings->magneticRejection == 0.0f ? FLT_MAX : powf(0.5f * sinf(FusionDegreesToRadians(settings->magneticRejection)), 2);
+    ahrs->settings.recoveryTriggerPeriod = settings->recoveryTriggerPeriod;
+    ahrs->accelerationRecoveryTimeout = ahrs->settings.recoveryTriggerPeriod;
+    ahrs->magneticRecoveryTimeout = ahrs->settings.recoveryTriggerPeriod;
+    if ((settings->gain == 0.0f) ||
+        (settings->recoveryTriggerPeriod == 0)) { // disable acceleration and magnetic rejection features if gain is zero
+        ahrs->settings.accelerationRejection = FLT_MAX;
+        ahrs->settings.magneticRejection = FLT_MAX;
+    }
+    if (ahrs->initialising == false) {
+        ahrs->rampedGain = ahrs->settings.gain;
+    }
+    ahrs->rampedGainStep = (INITIAL_GAIN - ahrs->settings.gain) / INITIALISATION_PERIOD;
+}
+
+/**
+ * @brief Updates the AHRS algorithm using the gyroscope, accelerometer, and
+ * magnetometer measurements.
+ * @param ahrs AHRS algorithm structure.
+ * @param gyroscope Gyroscope measurement in degrees per second.
+ * @param accelerometer Accelerometer measurement in g.
+ * @param magnetometer Magnetometer measurement in arbitrary units.
+ * @param deltaTime Delta time in seconds.
+ */
+void FusionAhrsUpdate(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer,
+                      const FusionVector magnetometer, const float deltaTime)
+{
+#define Q ahrs->quaternion.element
+
+    // Store accelerometer
+    ahrs->accelerometer = accelerometer;
+
+    // Reinitialise if gyroscope range exceeded
+    if ((fabsf(gyroscope.axis.x) > ahrs->settings.gyroscopeRange) || (fabsf(gyroscope.axis.y) > ahrs->settings.gyroscopeRange) ||
+        (fabsf(gyroscope.axis.z) > ahrs->settings.gyroscopeRange)) {
+        const FusionQuaternion quaternion = ahrs->quaternion;
+        FusionAhrsReset(ahrs);
+        ahrs->quaternion = quaternion;
+        ahrs->angularRateRecovery = true;
+    }
+
+    // Ramp down gain during initialisation
+    if (ahrs->initialising) {
+        ahrs->rampedGain -= ahrs->rampedGainStep * deltaTime;
+        if ((ahrs->rampedGain < ahrs->settings.gain) || (ahrs->settings.gain == 0.0f)) {
+            ahrs->rampedGain = ahrs->settings.gain;
+            ahrs->initialising = false;
+            ahrs->angularRateRecovery = false;
+        }
+    }
+
+    // Calculate direction of gravity indicated by algorithm
+    const FusionVector halfGravity = HalfGravity(ahrs);
+
+    // Calculate accelerometer feedback
+    FusionVector halfAccelerometerFeedback = FUSION_VECTOR_ZERO;
+    ahrs->accelerometerIgnored = true;
+    if (FusionVectorIsZero(accelerometer) == false) {
+
+        // Calculate accelerometer feedback scaled by 0.5
+        ahrs->halfAccelerometerFeedback = Feedback(FusionVectorNormalise(accelerometer), halfGravity);
+
+        // Don't ignore accelerometer if acceleration error below threshold
+        if (ahrs->initialising ||
+            ((FusionVectorMagnitudeSquared(ahrs->halfAccelerometerFeedback) <= ahrs->settings.accelerationRejection))) {
+            ahrs->accelerometerIgnored = false;
+            ahrs->accelerationRecoveryTrigger -= 9;
+        } else {
+            ahrs->accelerationRecoveryTrigger += 1;
+        }
+
+        // Don't ignore accelerometer during acceleration recovery
+        if (ahrs->accelerationRecoveryTrigger > ahrs->accelerationRecoveryTimeout) {
+            ahrs->accelerationRecoveryTimeout = 0;
+            ahrs->accelerometerIgnored = false;
+        } else {
+            ahrs->accelerationRecoveryTimeout = ahrs->settings.recoveryTriggerPeriod;
+        }
+        ahrs->accelerationRecoveryTrigger = Clamp(ahrs->accelerationRecoveryTrigger, 0, ahrs->settings.recoveryTriggerPeriod);
+
+        // Apply accelerometer feedback
+        if (ahrs->accelerometerIgnored == false) {
+            halfAccelerometerFeedback = ahrs->halfAccelerometerFeedback;
+        }
+    }
+
+    // Calculate magnetometer feedback
+    FusionVector halfMagnetometerFeedback = FUSION_VECTOR_ZERO;
+    ahrs->magnetometerIgnored = true;
+    if (FusionVectorIsZero(magnetometer) == false) {
+
+        // Calculate direction of magnetic field indicated by algorithm
+        const FusionVector halfMagnetic = HalfMagnetic(ahrs);
+
+        // Calculate magnetometer feedback scaled by 0.5
+        ahrs->halfMagnetometerFeedback =
+            Feedback(FusionVectorNormalise(FusionVectorCrossProduct(halfGravity, magnetometer)), halfMagnetic);
+
+        // Don't ignore magnetometer if magnetic error below threshold
+        if (ahrs->initialising ||
+            ((FusionVectorMagnitudeSquared(ahrs->halfMagnetometerFeedback) <= ahrs->settings.magneticRejection))) {
+            ahrs->magnetometerIgnored = false;
+            ahrs->magneticRecoveryTrigger -= 9;
+        } else {
+            ahrs->magneticRecoveryTrigger += 1;
+        }
+
+        // Don't ignore magnetometer during magnetic recovery
+        if (ahrs->magneticRecoveryTrigger > ahrs->magneticRecoveryTimeout) {
+            ahrs->magneticRecoveryTimeout = 0;
+            ahrs->magnetometerIgnored = false;
+        } else {
+            ahrs->magneticRecoveryTimeout = ahrs->settings.recoveryTriggerPeriod;
+        }
+        ahrs->magneticRecoveryTrigger = Clamp(ahrs->magneticRecoveryTrigger, 0, ahrs->settings.recoveryTriggerPeriod);
+
+        // Apply magnetometer feedback
+        if (ahrs->magnetometerIgnored == false) {
+            halfMagnetometerFeedback = ahrs->halfMagnetometerFeedback;
+        }
+    }
+
+    // Convert gyroscope to radians per second scaled by 0.5
+    const FusionVector halfGyroscope = FusionVectorMultiplyScalar(gyroscope, FusionDegreesToRadians(0.5f));
+
+    // Apply feedback to gyroscope
+    const FusionVector adjustedHalfGyroscope = FusionVectorAdd(
+        halfGyroscope,
+        FusionVectorMultiplyScalar(FusionVectorAdd(halfAccelerometerFeedback, halfMagnetometerFeedback), ahrs->rampedGain));
+
+    // Integrate rate of change of quaternion
+    ahrs->quaternion = FusionQuaternionAdd(
+        ahrs->quaternion,
+        FusionQuaternionMultiplyVector(ahrs->quaternion, FusionVectorMultiplyScalar(adjustedHalfGyroscope, deltaTime)));
+
+    // Normalise quaternion
+    ahrs->quaternion = FusionQuaternionNormalise(ahrs->quaternion);
+#undef Q
+}
+
+/**
+ * @brief Returns the direction of gravity scaled by 0.5.
+ * @param ahrs AHRS algorithm structure.
+ * @return Direction of gravity scaled by 0.5.
+ */
+static inline FusionVector HalfGravity(const FusionAhrs *const ahrs)
+{
+#define Q ahrs->quaternion.element
+    switch (ahrs->settings.convention) {
+    case FusionConventionNwu:
+    case FusionConventionEnu: {
+        const FusionVector halfGravity = {.axis = {
+                                              .x = Q.x * Q.z - Q.w * Q.y,
+                                              .y = Q.y * Q.z + Q.w * Q.x,
+                                              .z = Q.w * Q.w - 0.5f + Q.z * Q.z,
+                                          }}; // third column of transposed rotation matrix scaled by 0.5
+        return halfGravity;
+    }
+    case FusionConventionNed: {
+        const FusionVector halfGravity = {.axis = {
+                                              .x = Q.w * Q.y - Q.x * Q.z,
+                                              .y = -1.0f * (Q.y * Q.z + Q.w * Q.x),
+                                              .z = 0.5f - Q.w * Q.w - Q.z * Q.z,
+                                          }}; // third column of transposed rotation matrix scaled by -0.5
+        return halfGravity;
+    }
+    }
+    return FUSION_VECTOR_ZERO; // avoid compiler warning
+#undef Q
+}
+
+/**
+ * @brief Returns the direction of the magnetic field scaled by 0.5.
+ * @param ahrs AHRS algorithm structure.
+ * @return Direction of the magnetic field scaled by 0.5.
+ */
+static inline FusionVector HalfMagnetic(const FusionAhrs *const ahrs)
+{
+#define Q ahrs->quaternion.element
+    switch (ahrs->settings.convention) {
+    case FusionConventionNwu: {
+        const FusionVector halfMagnetic = {.axis = {
+                                               .x = Q.x * Q.y + Q.w * Q.z,
+                                               .y = Q.w * Q.w - 0.5f + Q.y * Q.y,
+                                               .z = Q.y * Q.z - Q.w * Q.x,
+                                           }}; // second column of transposed rotation matrix scaled by 0.5
+        return halfMagnetic;
+    }
+    case FusionConventionEnu: {
+        const FusionVector halfMagnetic = {.axis = {
+                                               .x = 0.5f - Q.w * Q.w - Q.x * Q.x,
+                                               .y = Q.w * Q.z - Q.x * Q.y,
+                                               .z = -1.0f * (Q.x * Q.z + Q.w * Q.y),
+                                           }}; // first column of transposed rotation matrix scaled by -0.5
+        return halfMagnetic;
+    }
+    case FusionConventionNed: {
+        const FusionVector halfMagnetic = {.axis = {
+                                               .x = -1.0f * (Q.x * Q.y + Q.w * Q.z),
+                                               .y = 0.5f - Q.w * Q.w - Q.y * Q.y,
+                                               .z = Q.w * Q.x - Q.y * Q.z,
+                                           }}; // second column of transposed rotation matrix scaled by -0.5
+        return halfMagnetic;
+    }
+    }
+    return FUSION_VECTOR_ZERO; // avoid compiler warning
+#undef Q
+}
+
+/**
+ * @brief Returns the feedback.
+ * @param sensor Sensor.
+ * @param reference Reference.
+ * @return Feedback.
+ */
+static inline FusionVector Feedback(const FusionVector sensor, const FusionVector reference)
+{
+    if (FusionVectorDotProduct(sensor, reference) < 0.0f) { // if error is >90 degrees
+        return FusionVectorNormalise(FusionVectorCrossProduct(sensor, reference));
+    }
+    return FusionVectorCrossProduct(sensor, reference);
+}
+
+/**
+ * @brief Returns a value limited to maximum and minimum.
+ * @param value Value.
+ * @param min Minimum value.
+ * @param max Maximum value.
+ * @return Value limited to maximum and minimum.
+ */
+static inline int Clamp(const int value, const int min, const int max)
+{
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+}
+
+/**
+ * @brief Updates the AHRS algorithm using the gyroscope and accelerometer
+ * measurements only.
+ * @param ahrs AHRS algorithm structure.
+ * @param gyroscope Gyroscope measurement in degrees per second.
+ * @param accelerometer Accelerometer measurement in g.
+ * @param deltaTime Delta time in seconds.
+ */
+void FusionAhrsUpdateNoMagnetometer(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer,
+                                    const float deltaTime)
+{
+
+    // Update AHRS algorithm
+    FusionAhrsUpdate(ahrs, gyroscope, accelerometer, FUSION_VECTOR_ZERO, deltaTime);
+
+    // Zero heading during initialisation
+    if (ahrs->initialising) {
+        FusionAhrsSetHeading(ahrs, 0.0f);
+    }
+}
+
+/**
+ * @brief Updates the AHRS algorithm using the gyroscope, accelerometer, and
+ * heading measurements.
+ * @param ahrs AHRS algorithm structure.
+ * @param gyroscope Gyroscope measurement in degrees per second.
+ * @param accelerometer Accelerometer measurement in g.
+ * @param heading Heading measurement in degrees.
+ * @param deltaTime Delta time in seconds.
+ */
+void FusionAhrsUpdateExternalHeading(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer,
+                                     const float heading, const float deltaTime)
+{
+#define Q ahrs->quaternion.element
+
+    // Calculate roll
+    const float roll = atan2f(Q.w * Q.x + Q.y * Q.z, 0.5f - Q.y * Q.y - Q.x * Q.x);
+
+    // Calculate magnetometer
+    const float headingRadians = FusionDegreesToRadians(heading);
+    const float sinHeadingRadians = sinf(headingRadians);
+    const FusionVector magnetometer = {.axis = {
+                                           .x = cosf(headingRadians),
+                                           .y = -1.0f * cosf(roll) * sinHeadingRadians,
+                                           .z = sinHeadingRadians * sinf(roll),
+                                       }};
+
+    // Update AHRS algorithm
+    FusionAhrsUpdate(ahrs, gyroscope, accelerometer, magnetometer, deltaTime);
+#undef Q
+}
+
+/**
+ * @brief Returns the quaternion describing the sensor relative to the Earth.
+ * @param ahrs AHRS algorithm structure.
+ * @return Quaternion describing the sensor relative to the Earth.
+ */
+FusionQuaternion FusionAhrsGetQuaternion(const FusionAhrs *const ahrs)
+{
+    return ahrs->quaternion;
+}
+
+/**
+ * @brief Sets the quaternion describing the sensor relative to the Earth.
+ * @param ahrs AHRS algorithm structure.
+ * @param quaternion Quaternion describing the sensor relative to the Earth.
+ */
+void FusionAhrsSetQuaternion(FusionAhrs *const ahrs, const FusionQuaternion quaternion)
+{
+    ahrs->quaternion = quaternion;
+}
+
+/**
+ * @brief Returns the linear acceleration measurement equal to the accelerometer
+ * measurement with the 1 g of gravity removed.
+ * @param ahrs AHRS algorithm structure.
+ * @return Linear acceleration measurement in g.
+ */
+FusionVector FusionAhrsGetLinearAcceleration(const FusionAhrs *const ahrs)
+{
+#define Q ahrs->quaternion.element
+
+    // Calculate gravity in the sensor coordinate frame
+    const FusionVector gravity = {.axis = {
+                                      .x = 2.0f * (Q.x * Q.z - Q.w * Q.y),
+                                      .y = 2.0f * (Q.y * Q.z + Q.w * Q.x),
+                                      .z = 2.0f * (Q.w * Q.w - 0.5f + Q.z * Q.z),
+                                  }}; // third column of transposed rotation matrix
+
+    // Remove gravity from accelerometer measurement
+    switch (ahrs->settings.convention) {
+    case FusionConventionNwu:
+    case FusionConventionEnu: {
+        return FusionVectorSubtract(ahrs->accelerometer, gravity);
+    }
+    case FusionConventionNed: {
+        return FusionVectorAdd(ahrs->accelerometer, gravity);
+    }
+    }
+    return FUSION_VECTOR_ZERO; // avoid compiler warning
+#undef Q
+}
+
+/**
+ * @brief Returns the Earth acceleration measurement equal to accelerometer
+ * measurement in the Earth coordinate frame with the 1 g of gravity removed.
+ * @param ahrs AHRS algorithm structure.
+ * @return Earth acceleration measurement in g.
+ */
+FusionVector FusionAhrsGetEarthAcceleration(const FusionAhrs *const ahrs)
+{
+#define Q ahrs->quaternion.element
+#define A ahrs->accelerometer.axis
+
+    // Calculate accelerometer measurement in the Earth coordinate frame
+    const float qwqw = Q.w * Q.w; // calculate common terms to avoid repeated operations
+    const float qwqx = Q.w * Q.x;
+    const float qwqy = Q.w * Q.y;
+    const float qwqz = Q.w * Q.z;
+    const float qxqy = Q.x * Q.y;
+    const float qxqz = Q.x * Q.z;
+    const float qyqz = Q.y * Q.z;
+    FusionVector accelerometer = {.axis = {
+                                      .x = 2.0f * ((qwqw - 0.5f + Q.x * Q.x) * A.x + (qxqy - qwqz) * A.y + (qxqz + qwqy) * A.z),
+                                      .y = 2.0f * ((qxqy + qwqz) * A.x + (qwqw - 0.5f + Q.y * Q.y) * A.y + (qyqz - qwqx) * A.z),
+                                      .z = 2.0f * ((qxqz - qwqy) * A.x + (qyqz + qwqx) * A.y + (qwqw - 0.5f + Q.z * Q.z) * A.z),
+                                  }}; // rotation matrix multiplied with the accelerometer
+
+    // Remove gravity from accelerometer measurement
+    switch (ahrs->settings.convention) {
+    case FusionConventionNwu:
+    case FusionConventionEnu:
+        accelerometer.axis.z -= 1.0f;
+        break;
+    case FusionConventionNed:
+        accelerometer.axis.z += 1.0f;
+        break;
+    }
+    return accelerometer;
+#undef Q
+#undef A
+}
+
+/**
+ * @brief Returns the AHRS algorithm internal states.
+ * @param ahrs AHRS algorithm structure.
+ * @return AHRS algorithm internal states.
+ */
+FusionAhrsInternalStates FusionAhrsGetInternalStates(const FusionAhrs *const ahrs)
+{
+    const FusionAhrsInternalStates internalStates = {
+        .accelerationError = FusionRadiansToDegrees(FusionAsin(2.0f * FusionVectorMagnitude(ahrs->halfAccelerometerFeedback))),
+        .accelerometerIgnored = ahrs->accelerometerIgnored,
+        .accelerationRecoveryTrigger =
+            ahrs->settings.recoveryTriggerPeriod == 0
+                ? 0.0f
+                : (float)ahrs->accelerationRecoveryTrigger / (float)ahrs->settings.recoveryTriggerPeriod,
+        .magneticError = FusionRadiansToDegrees(FusionAsin(2.0f * FusionVectorMagnitude(ahrs->halfMagnetometerFeedback))),
+        .magnetometerIgnored = ahrs->magnetometerIgnored,
+        .magneticRecoveryTrigger = ahrs->settings.recoveryTriggerPeriod == 0
+                                       ? 0.0f
+                                       : (float)ahrs->magneticRecoveryTrigger / (float)ahrs->settings.recoveryTriggerPeriod,
+    };
+    return internalStates;
+}
+
+/**
+ * @brief Returns the AHRS algorithm flags.
+ * @param ahrs AHRS algorithm structure.
+ * @return AHRS algorithm flags.
+ */
+FusionAhrsFlags FusionAhrsGetFlags(const FusionAhrs *const ahrs)
+{
+    const FusionAhrsFlags flags = {
+        .initialising = ahrs->initialising,
+        .angularRateRecovery = ahrs->angularRateRecovery,
+        .accelerationRecovery = ahrs->accelerationRecoveryTrigger > ahrs->accelerationRecoveryTimeout,
+        .magneticRecovery = ahrs->magneticRecoveryTrigger > ahrs->magneticRecoveryTimeout,
+    };
+    return flags;
+}
+
+/**
+ * @brief Sets the heading of the orientation measurement provided by the AHRS
+ * algorithm.  This function can be used to reset drift in heading when the AHRS
+ * algorithm is being used without a magnetometer.
+ * @param ahrs AHRS algorithm structure.
+ * @param heading Heading angle in degrees.
+ */
+void FusionAhrsSetHeading(FusionAhrs *const ahrs, const float heading)
+{
+#define Q ahrs->quaternion.element
+    const float yaw = atan2f(Q.w * Q.z + Q.x * Q.y, 0.5f - Q.y * Q.y - Q.z * Q.z);
+    const float halfYawMinusHeading = 0.5f * (yaw - FusionDegreesToRadians(heading));
+    const FusionQuaternion rotation = {.element = {
+                                           .w = cosf(halfYawMinusHeading),
+                                           .x = 0.0f,
+                                           .y = 0.0f,
+                                           .z = -1.0f * sinf(halfYawMinusHeading),
+                                       }};
+    ahrs->quaternion = FusionQuaternionMultiply(rotation, ahrs->quaternion);
+#undef Q
+}
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionAhrs.h

@@ -0,0 +1,112 @@
+/**
+ * @file FusionAhrs.h
+ * @author Seb Madgwick
+ * @brief AHRS algorithm to combine gyroscope, accelerometer, and magnetometer
+ * measurements into a single measurement of orientation relative to the Earth.
+ */
+
+#ifndef FUSION_AHRS_H
+#define FUSION_AHRS_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionConvention.h"
+#include "FusionMath.h"
+#include <stdbool.h>
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief AHRS algorithm settings.
+ */
+typedef struct {
+    FusionConvention convention;
+    float gain;
+    float gyroscopeRange;
+    float accelerationRejection;
+    float magneticRejection;
+    unsigned int recoveryTriggerPeriod;
+} FusionAhrsSettings;
+
+/**
+ * @brief AHRS algorithm structure.  Structure members are used internally and
+ * must not be accessed by the application.
+ */
+typedef struct {
+    FusionAhrsSettings settings;
+    FusionQuaternion quaternion;
+    FusionVector accelerometer;
+    bool initialising;
+    float rampedGain;
+    float rampedGainStep;
+    bool angularRateRecovery;
+    FusionVector halfAccelerometerFeedback;
+    FusionVector halfMagnetometerFeedback;
+    bool accelerometerIgnored;
+    int accelerationRecoveryTrigger;
+    int accelerationRecoveryTimeout;
+    bool magnetometerIgnored;
+    int magneticRecoveryTrigger;
+    int magneticRecoveryTimeout;
+} FusionAhrs;
+
+/**
+ * @brief AHRS algorithm internal states.
+ */
+typedef struct {
+    float accelerationError;
+    bool accelerometerIgnored;
+    float accelerationRecoveryTrigger;
+    float magneticError;
+    bool magnetometerIgnored;
+    float magneticRecoveryTrigger;
+} FusionAhrsInternalStates;
+
+/**
+ * @brief AHRS algorithm flags.
+ */
+typedef struct {
+    bool initialising;
+    bool angularRateRecovery;
+    bool accelerationRecovery;
+    bool magneticRecovery;
+} FusionAhrsFlags;
+
+//------------------------------------------------------------------------------
+// Function declarations
+
+void FusionAhrsInitialise(FusionAhrs *const ahrs);
+
+void FusionAhrsReset(FusionAhrs *const ahrs);
+
+void FusionAhrsSetSettings(FusionAhrs *const ahrs, const FusionAhrsSettings *const settings);
+
+void FusionAhrsUpdate(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer,
+                      const FusionVector magnetometer, const float deltaTime);
+
+void FusionAhrsUpdateNoMagnetometer(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer,
+                                    const float deltaTime);
+
+void FusionAhrsUpdateExternalHeading(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer,
+                                     const float heading, const float deltaTime);
+
+FusionQuaternion FusionAhrsGetQuaternion(const FusionAhrs *const ahrs);
+
+void FusionAhrsSetQuaternion(FusionAhrs *const ahrs, const FusionQuaternion quaternion);
+
+FusionVector FusionAhrsGetLinearAcceleration(const FusionAhrs *const ahrs);
+
+FusionVector FusionAhrsGetEarthAcceleration(const FusionAhrs *const ahrs);
+
+FusionAhrsInternalStates FusionAhrsGetInternalStates(const FusionAhrs *const ahrs);
+
+FusionAhrsFlags FusionAhrsGetFlags(const FusionAhrs *const ahrs);
+
+void FusionAhrsSetHeading(FusionAhrs *const ahrs, const float heading);
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionAxes.h

@@ -0,0 +1,188 @@
+/**
+ * @file FusionAxes.h
+ * @author Seb Madgwick
+ * @brief Swaps sensor axes for alignment with the body axes.
+ */
+
+#ifndef FUSION_AXES_H
+#define FUSION_AXES_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionMath.h"
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief Axes alignment describing the sensor axes relative to the body axes.
+ * For example, if the body X axis is aligned with the sensor Y axis and the
+ * body Y axis is aligned with sensor X axis but pointing the opposite direction
+ * then alignment is +Y-X+Z.
+ */
+typedef enum {
+    FusionAxesAlignmentPXPYPZ, /* +X+Y+Z */
+    FusionAxesAlignmentPXNZPY, /* +X-Z+Y */
+    FusionAxesAlignmentPXNYNZ, /* +X-Y-Z */
+    FusionAxesAlignmentPXPZNY, /* +X+Z-Y */
+    FusionAxesAlignmentNXPYNZ, /* -X+Y-Z */
+    FusionAxesAlignmentNXPZPY, /* -X+Z+Y */
+    FusionAxesAlignmentNXNYPZ, /* -X-Y+Z */
+    FusionAxesAlignmentNXNZNY, /* -X-Z-Y */
+    FusionAxesAlignmentPYNXPZ, /* +Y-X+Z */
+    FusionAxesAlignmentPYNZNX, /* +Y-Z-X */
+    FusionAxesAlignmentPYPXNZ, /* +Y+X-Z */
+    FusionAxesAlignmentPYPZPX, /* +Y+Z+X */
+    FusionAxesAlignmentNYPXPZ, /* -Y+X+Z */
+    FusionAxesAlignmentNYNZPX, /* -Y-Z+X */
+    FusionAxesAlignmentNYNXNZ, /* -Y-X-Z */
+    FusionAxesAlignmentNYPZNX, /* -Y+Z-X */
+    FusionAxesAlignmentPZPYNX, /* +Z+Y-X */
+    FusionAxesAlignmentPZPXPY, /* +Z+X+Y */
+    FusionAxesAlignmentPZNYPX, /* +Z-Y+X */
+    FusionAxesAlignmentPZNXNY, /* +Z-X-Y */
+    FusionAxesAlignmentNZPYPX, /* -Z+Y+X */
+    FusionAxesAlignmentNZNXPY, /* -Z-X+Y */
+    FusionAxesAlignmentNZNYNX, /* -Z-Y-X */
+    FusionAxesAlignmentNZPXNY, /* -Z+X-Y */
+} FusionAxesAlignment;
+
+//------------------------------------------------------------------------------
+// Inline functions
+
+/**
+ * @brief Swaps sensor axes for alignment with the body axes.
+ * @param sensor Sensor axes.
+ * @param alignment Axes alignment.
+ * @return Sensor axes aligned with the body axes.
+ */
+static inline FusionVector FusionAxesSwap(const FusionVector sensor, const FusionAxesAlignment alignment)
+{
+    FusionVector result;
+    switch (alignment) {
+    case FusionAxesAlignmentPXPYPZ:
+        break;
+    case FusionAxesAlignmentPXNZPY:
+        result.axis.x = +sensor.axis.x;
+        result.axis.y = -sensor.axis.z;
+        result.axis.z = +sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentPXNYNZ:
+        result.axis.x = +sensor.axis.x;
+        result.axis.y = -sensor.axis.y;
+        result.axis.z = -sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentPXPZNY:
+        result.axis.x = +sensor.axis.x;
+        result.axis.y = +sensor.axis.z;
+        result.axis.z = -sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentNXPYNZ:
+        result.axis.x = -sensor.axis.x;
+        result.axis.y = +sensor.axis.y;
+        result.axis.z = -sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentNXPZPY:
+        result.axis.x = -sensor.axis.x;
+        result.axis.y = +sensor.axis.z;
+        result.axis.z = +sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentNXNYPZ:
+        result.axis.x = -sensor.axis.x;
+        result.axis.y = -sensor.axis.y;
+        result.axis.z = +sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentNXNZNY:
+        result.axis.x = -sensor.axis.x;
+        result.axis.y = -sensor.axis.z;
+        result.axis.z = -sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentPYNXPZ:
+        result.axis.x = +sensor.axis.y;
+        result.axis.y = -sensor.axis.x;
+        result.axis.z = +sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentPYNZNX:
+        result.axis.x = +sensor.axis.y;
+        result.axis.y = -sensor.axis.z;
+        result.axis.z = -sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentPYPXNZ:
+        result.axis.x = +sensor.axis.y;
+        result.axis.y = +sensor.axis.x;
+        result.axis.z = -sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentPYPZPX:
+        result.axis.x = +sensor.axis.y;
+        result.axis.y = +sensor.axis.z;
+        result.axis.z = +sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentNYPXPZ:
+        result.axis.x = -sensor.axis.y;
+        result.axis.y = +sensor.axis.x;
+        result.axis.z = +sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentNYNZPX:
+        result.axis.x = -sensor.axis.y;
+        result.axis.y = -sensor.axis.z;
+        result.axis.z = +sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentNYNXNZ:
+        result.axis.x = -sensor.axis.y;
+        result.axis.y = -sensor.axis.x;
+        result.axis.z = -sensor.axis.z;
+        return result;
+    case FusionAxesAlignmentNYPZNX:
+        result.axis.x = -sensor.axis.y;
+        result.axis.y = +sensor.axis.z;
+        result.axis.z = -sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentPZPYNX:
+        result.axis.x = +sensor.axis.z;
+        result.axis.y = +sensor.axis.y;
+        result.axis.z = -sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentPZPXPY:
+        result.axis.x = +sensor.axis.z;
+        result.axis.y = +sensor.axis.x;
+        result.axis.z = +sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentPZNYPX:
+        result.axis.x = +sensor.axis.z;
+        result.axis.y = -sensor.axis.y;
+        result.axis.z = +sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentPZNXNY:
+        result.axis.x = +sensor.axis.z;
+        result.axis.y = -sensor.axis.x;
+        result.axis.z = -sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentNZPYPX:
+        result.axis.x = -sensor.axis.z;
+        result.axis.y = +sensor.axis.y;
+        result.axis.z = +sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentNZNXPY:
+        result.axis.x = -sensor.axis.z;
+        result.axis.y = -sensor.axis.x;
+        result.axis.z = +sensor.axis.y;
+        return result;
+    case FusionAxesAlignmentNZNYNX:
+        result.axis.x = -sensor.axis.z;
+        result.axis.y = -sensor.axis.y;
+        result.axis.z = -sensor.axis.x;
+        return result;
+    case FusionAxesAlignmentNZPXNY:
+        result.axis.x = -sensor.axis.z;
+        result.axis.y = +sensor.axis.x;
+        result.axis.z = -sensor.axis.y;
+        return result;
+    }
+    return sensor; // avoid compiler warning
+}
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionCalibration.h

@@ -0,0 +1,49 @@
+/**
+ * @file FusionCalibration.h
+ * @author Seb Madgwick
+ * @brief Gyroscope, accelerometer, and magnetometer calibration models.
+ */
+
+#ifndef FUSION_CALIBRATION_H
+#define FUSION_CALIBRATION_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionMath.h"
+
+//------------------------------------------------------------------------------
+// Inline functions
+
+/**
+ * @brief Gyroscope and accelerometer calibration model.
+ * @param uncalibrated Uncalibrated measurement.
+ * @param misalignment Misalignment matrix.
+ * @param sensitivity Sensitivity.
+ * @param offset Offset.
+ * @return Calibrated measurement.
+ */
+static inline FusionVector FusionCalibrationInertial(const FusionVector uncalibrated, const FusionMatrix misalignment,
+                                                     const FusionVector sensitivity, const FusionVector offset)
+{
+    return FusionMatrixMultiplyVector(misalignment,
+                                      FusionVectorHadamardProduct(FusionVectorSubtract(uncalibrated, offset), sensitivity));
+}
+
+/**
+ * @brief Magnetometer calibration model.
+ * @param uncalibrated Uncalibrated measurement.
+ * @param softIronMatrix Soft-iron matrix.
+ * @param hardIronOffset Hard-iron offset.
+ * @return Calibrated measurement.
+ */
+static inline FusionVector FusionCalibrationMagnetic(const FusionVector uncalibrated, const FusionMatrix softIronMatrix,
+                                                     const FusionVector hardIronOffset)
+{
+    return FusionMatrixMultiplyVector(softIronMatrix, FusionVectorSubtract(uncalibrated, hardIronOffset));
+}
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionCompass.c

@@ -0,0 +1,51 @@
+/**
+ * @file FusionCompass.c
+ * @author Seb Madgwick
+ * @brief Tilt-compensated compass to calculate the magnetic heading using
+ * accelerometer and magnetometer measurements.
+ */
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionCompass.h"
+#include "FusionAxes.h"
+#include <math.h> // atan2f
+
+//------------------------------------------------------------------------------
+// Functions
+
+/**
+ * @brief Calculates the magnetic heading.
+ * @param convention Earth axes convention.
+ * @param accelerometer Accelerometer measurement in any calibrated units.
+ * @param magnetometer Magnetometer measurement in any calibrated units.
+ * @return Heading angle in degrees.
+ */
+float FusionCompassCalculateHeading(const FusionConvention convention, const FusionVector accelerometer,
+                                    const FusionVector magnetometer)
+{
+    switch (convention) {
+    case FusionConventionNwu: {
+        const FusionVector west = FusionVectorNormalise(FusionVectorCrossProduct(accelerometer, magnetometer));
+        const FusionVector north = FusionVectorNormalise(FusionVectorCrossProduct(west, accelerometer));
+        return FusionRadiansToDegrees(atan2f(west.axis.x, north.axis.x));
+    }
+    case FusionConventionEnu: {
+        const FusionVector west = FusionVectorNormalise(FusionVectorCrossProduct(accelerometer, magnetometer));
+        const FusionVector north = FusionVectorNormalise(FusionVectorCrossProduct(west, accelerometer));
+        const FusionVector east = FusionVectorMultiplyScalar(west, -1.0f);
+        return FusionRadiansToDegrees(atan2f(north.axis.x, east.axis.x));
+    }
+    case FusionConventionNed: {
+        const FusionVector up = FusionVectorMultiplyScalar(accelerometer, -1.0f);
+        const FusionVector west = FusionVectorNormalise(FusionVectorCrossProduct(up, magnetometer));
+        const FusionVector north = FusionVectorNormalise(FusionVectorCrossProduct(west, up));
+        return FusionRadiansToDegrees(atan2f(west.axis.x, north.axis.x));
+    }
+    }
+    return 0; // avoid compiler warning
+}
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionCompass.h

@@ -0,0 +1,26 @@
+/**
+ * @file FusionCompass.h
+ * @author Seb Madgwick
+ * @brief Tilt-compensated compass to calculate the magnetic heading using
+ * accelerometer and magnetometer measurements.
+ */
+
+#ifndef FUSION_COMPASS_H
+#define FUSION_COMPASS_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionConvention.h"
+#include "FusionMath.h"
+
+//------------------------------------------------------------------------------
+// Function declarations
+
+float FusionCompassCalculateHeading(const FusionConvention convention, const FusionVector accelerometer,
+                                    const FusionVector magnetometer);
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionConvention.h

@@ -0,0 +1,25 @@
+/**
+ * @file FusionConvention.h
+ * @author Seb Madgwick
+ * @brief Earth axes convention.
+ */
+
+#ifndef FUSION_CONVENTION_H
+#define FUSION_CONVENTION_H
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief Earth axes convention.
+ */
+typedef enum {
+    FusionConventionNwu, /* North-West-Up */
+    FusionConventionEnu, /* East-North-Up */
+    FusionConventionNed, /* North-East-Down */
+} FusionConvention;
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionMath.h

@@ -0,0 +1,503 @@
+/**
+ * @file FusionMath.h
+ * @author Seb Madgwick
+ * @brief Math library.
+ */
+
+#ifndef FUSION_MATH_H
+#define FUSION_MATH_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include <math.h> // M_PI, sqrtf, atan2f, asinf
+#include <stdbool.h>
+#include <stdint.h>
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief 3D vector.
+ */
+typedef union {
+    float array[3];
+
+    struct {
+        float x;
+        float y;
+        float z;
+    } axis;
+} FusionVector;
+
+/**
+ * @brief Quaternion.
+ */
+typedef union {
+    float array[4];
+
+    struct {
+        float w;
+        float x;
+        float y;
+        float z;
+    } element;
+} FusionQuaternion;
+
+/**
+ * @brief 3x3 matrix in row-major order.
+ * See http://en.wikipedia.org/wiki/Row-major_order
+ */
+typedef union {
+    float array[3][3];
+
+    struct {
+        float xx;
+        float xy;
+        float xz;
+        float yx;
+        float yy;
+        float yz;
+        float zx;
+        float zy;
+        float zz;
+    } element;
+} FusionMatrix;
+
+/**
+ * @brief Euler angles.  Roll, pitch, and yaw correspond to rotations around
+ * X, Y, and Z respectively.
+ */
+typedef union {
+    float array[3];
+
+    struct {
+        float roll;
+        float pitch;
+        float yaw;
+    } angle;
+} FusionEuler;
+
+/**
+ * @brief Vector of zeros.
+ */
+#define FUSION_VECTOR_ZERO ((FusionVector){.array = {0.0f, 0.0f, 0.0f}})
+
+/**
+ * @brief Vector of ones.
+ */
+#define FUSION_VECTOR_ONES ((FusionVector){.array = {1.0f, 1.0f, 1.0f}})
+
+/**
+ * @brief Identity quaternion.
+ */
+#define FUSION_IDENTITY_QUATERNION ((FusionQuaternion){.array = {1.0f, 0.0f, 0.0f, 0.0f}})
+
+/**
+ * @brief Identity matrix.
+ */
+#define FUSION_IDENTITY_MATRIX ((FusionMatrix){.array = {{1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}}})
+
+/**
+ * @brief Euler angles of zero.
+ */
+#define FUSION_EULER_ZERO ((FusionEuler){.array = {0.0f, 0.0f, 0.0f}})
+
+/**
+ * @brief Pi. May not be defined in math.h.
+ */
+#ifndef M_PI
+#define M_PI (3.14159265358979323846)
+#endif
+
+/**
+ * @brief Include this definition or add as a preprocessor definition to use
+ * normal square root operations.
+ */
+// #define FUSION_USE_NORMAL_SQRT
+
+//------------------------------------------------------------------------------
+// Inline functions - Degrees and radians conversion
+
+/**
+ * @brief Converts degrees to radians.
+ * @param degrees Degrees.
+ * @return Radians.
+ */
+static inline float FusionDegreesToRadians(const float degrees)
+{
+    return degrees * ((float)M_PI / 180.0f);
+}
+
+/**
+ * @brief Converts radians to degrees.
+ * @param radians Radians.
+ * @return Degrees.
+ */
+static inline float FusionRadiansToDegrees(const float radians)
+{
+    return radians * (180.0f / (float)M_PI);
+}
+
+//------------------------------------------------------------------------------
+// Inline functions - Arc sine
+
+/**
+ * @brief Returns the arc sine of the value.
+ * @param value Value.
+ * @return Arc sine of the value.
+ */
+static inline float FusionAsin(const float value)
+{
+    if (value <= -1.0f) {
+        return (float)M_PI / -2.0f;
+    }
+    if (value >= 1.0f) {
+        return (float)M_PI / 2.0f;
+    }
+    return asinf(value);
+}
+
+//------------------------------------------------------------------------------
+// Inline functions - Fast inverse square root
+
+#ifndef FUSION_USE_NORMAL_SQRT
+
+/**
+ * @brief Calculates the reciprocal of the square root.
+ * See https://pizer.wordpress.com/2008/10/12/fast-inverse-square-root/
+ * @param x Operand.
+ * @return Reciprocal of the square root of x.
+ */
+static inline float FusionFastInverseSqrt(const float x)
+{
+
+    typedef union {
+        float f;
+        int32_t i;
+    } Union32;
+
+    Union32 union32 = {.f = x};
+    union32.i = 0x5F1F1412 - (union32.i >> 1);
+    return union32.f * (1.69000231f - 0.714158168f * x * union32.f * union32.f);
+}
+
+#endif
+
+//------------------------------------------------------------------------------
+// Inline functions - Vector operations
+
+/**
+ * @brief Returns true if the vector is zero.
+ * @param vector Vector.
+ * @return True if the vector is zero.
+ */
+static inline bool FusionVectorIsZero(const FusionVector vector)
+{
+    return (vector.axis.x == 0.0f) && (vector.axis.y == 0.0f) && (vector.axis.z == 0.0f);
+}
+
+/**
+ * @brief Returns the sum of two vectors.
+ * @param vectorA Vector A.
+ * @param vectorB Vector B.
+ * @return Sum of two vectors.
+ */
+static inline FusionVector FusionVectorAdd(const FusionVector vectorA, const FusionVector vectorB)
+{
+    const FusionVector result = {.axis = {
+                                     .x = vectorA.axis.x + vectorB.axis.x,
+                                     .y = vectorA.axis.y + vectorB.axis.y,
+                                     .z = vectorA.axis.z + vectorB.axis.z,
+                                 }};
+    return result;
+}
+
+/**
+ * @brief Returns vector B subtracted from vector A.
+ * @param vectorA Vector A.
+ * @param vectorB Vector B.
+ * @return Vector B subtracted from vector A.
+ */
+static inline FusionVector FusionVectorSubtract(const FusionVector vectorA, const FusionVector vectorB)
+{
+    const FusionVector result = {.axis = {
+                                     .x = vectorA.axis.x - vectorB.axis.x,
+                                     .y = vectorA.axis.y - vectorB.axis.y,
+                                     .z = vectorA.axis.z - vectorB.axis.z,
+                                 }};
+    return result;
+}
+
+/**
+ * @brief Returns the sum of the elements.
+ * @param vector Vector.
+ * @return Sum of the elements.
+ */
+static inline float FusionVectorSum(const FusionVector vector)
+{
+    return vector.axis.x + vector.axis.y + vector.axis.z;
+}
+
+/**
+ * @brief Returns the multiplication of a vector by a scalar.
+ * @param vector Vector.
+ * @param scalar Scalar.
+ * @return Multiplication of a vector by a scalar.
+ */
+static inline FusionVector FusionVectorMultiplyScalar(const FusionVector vector, const float scalar)
+{
+    const FusionVector result = {.axis = {
+                                     .x = vector.axis.x * scalar,
+                                     .y = vector.axis.y * scalar,
+                                     .z = vector.axis.z * scalar,
+                                 }};
+    return result;
+}
+
+/**
+ * @brief Calculates the Hadamard product (element-wise multiplication).
+ * @param vectorA Vector A.
+ * @param vectorB Vector B.
+ * @return Hadamard product.
+ */
+static inline FusionVector FusionVectorHadamardProduct(const FusionVector vectorA, const FusionVector vectorB)
+{
+    const FusionVector result = {.axis = {
+                                     .x = vectorA.axis.x * vectorB.axis.x,
+                                     .y = vectorA.axis.y * vectorB.axis.y,
+                                     .z = vectorA.axis.z * vectorB.axis.z,
+                                 }};
+    return result;
+}
+
+/**
+ * @brief Returns the cross product.
+ * @param vectorA Vector A.
+ * @param vectorB Vector B.
+ * @return Cross product.
+ */
+static inline FusionVector FusionVectorCrossProduct(const FusionVector vectorA, const FusionVector vectorB)
+{
+#define A vectorA.axis
+#define B vectorB.axis
+    const FusionVector result = {.axis = {
+                                     .x = A.y * B.z - A.z * B.y,
+                                     .y = A.z * B.x - A.x * B.z,
+                                     .z = A.x * B.y - A.y * B.x,
+                                 }};
+    return result;
+#undef A
+#undef B
+}
+
+/**
+ * @brief Returns the dot product.
+ * @param vectorA Vector A.
+ * @param vectorB Vector B.
+ * @return Dot product.
+ */
+static inline float FusionVectorDotProduct(const FusionVector vectorA, const FusionVector vectorB)
+{
+    return FusionVectorSum(FusionVectorHadamardProduct(vectorA, vectorB));
+}
+
+/**
+ * @brief Returns the vector magnitude squared.
+ * @param vector Vector.
+ * @return Vector magnitude squared.
+ */
+static inline float FusionVectorMagnitudeSquared(const FusionVector vector)
+{
+    return FusionVectorSum(FusionVectorHadamardProduct(vector, vector));
+}
+
+/**
+ * @brief Returns the vector magnitude.
+ * @param vector Vector.
+ * @return Vector magnitude.
+ */
+static inline float FusionVectorMagnitude(const FusionVector vector)
+{
+    return sqrtf(FusionVectorMagnitudeSquared(vector));
+}
+
+/**
+ * @brief Returns the normalised vector.
+ * @param vector Vector.
+ * @return Normalised vector.
+ */
+static inline FusionVector FusionVectorNormalise(const FusionVector vector)
+{
+#ifdef FUSION_USE_NORMAL_SQRT
+    const float magnitudeReciprocal = 1.0f / sqrtf(FusionVectorMagnitudeSquared(vector));
+#else
+    const float magnitudeReciprocal = FusionFastInverseSqrt(FusionVectorMagnitudeSquared(vector));
+#endif
+    return FusionVectorMultiplyScalar(vector, magnitudeReciprocal);
+}
+
+//------------------------------------------------------------------------------
+// Inline functions - Quaternion operations
+
+/**
+ * @brief Returns the sum of two quaternions.
+ * @param quaternionA Quaternion A.
+ * @param quaternionB Quaternion B.
+ * @return Sum of two quaternions.
+ */
+static inline FusionQuaternion FusionQuaternionAdd(const FusionQuaternion quaternionA, const FusionQuaternion quaternionB)
+{
+    const FusionQuaternion result = {.element = {
+                                         .w = quaternionA.element.w + quaternionB.element.w,
+                                         .x = quaternionA.element.x + quaternionB.element.x,
+                                         .y = quaternionA.element.y + quaternionB.element.y,
+                                         .z = quaternionA.element.z + quaternionB.element.z,
+                                     }};
+    return result;
+}
+
+/**
+ * @brief Returns the multiplication of two quaternions.
+ * @param quaternionA Quaternion A (to be post-multiplied).
+ * @param quaternionB Quaternion B (to be pre-multiplied).
+ * @return Multiplication of two quaternions.
+ */
+static inline FusionQuaternion FusionQuaternionMultiply(const FusionQuaternion quaternionA, const FusionQuaternion quaternionB)
+{
+#define A quaternionA.element
+#define B quaternionB.element
+    const FusionQuaternion result = {.element = {
+                                         .w = A.w * B.w - A.x * B.x - A.y * B.y - A.z * B.z,
+                                         .x = A.w * B.x + A.x * B.w + A.y * B.z - A.z * B.y,
+                                         .y = A.w * B.y - A.x * B.z + A.y * B.w + A.z * B.x,
+                                         .z = A.w * B.z + A.x * B.y - A.y * B.x + A.z * B.w,
+                                     }};
+    return result;
+#undef A
+#undef B
+}
+
+/**
+ * @brief Returns the multiplication of a quaternion with a vector.  This is a
+ * normal quaternion multiplication where the vector is treated a
+ * quaternion with a W element value of zero.  The quaternion is post-
+ * multiplied by the vector.
+ * @param quaternion Quaternion.
+ * @param vector Vector.
+ * @return Multiplication of a quaternion with a vector.
+ */
+static inline FusionQuaternion FusionQuaternionMultiplyVector(const FusionQuaternion quaternion, const FusionVector vector)
+{
+#define Q quaternion.element
+#define V vector.axis
+    const FusionQuaternion result = {.element = {
+                                         .w = -Q.x * V.x - Q.y * V.y - Q.z * V.z,
+                                         .x = Q.w * V.x + Q.y * V.z - Q.z * V.y,
+                                         .y = Q.w * V.y - Q.x * V.z + Q.z * V.x,
+                                         .z = Q.w * V.z + Q.x * V.y - Q.y * V.x,
+                                     }};
+    return result;
+#undef Q
+#undef V
+}
+
+/**
+ * @brief Returns the normalised quaternion.
+ * @param quaternion Quaternion.
+ * @return Normalised quaternion.
+ */
+static inline FusionQuaternion FusionQuaternionNormalise(const FusionQuaternion quaternion)
+{
+#define Q quaternion.element
+#ifdef FUSION_USE_NORMAL_SQRT
+    const float magnitudeReciprocal = 1.0f / sqrtf(Q.w * Q.w + Q.x * Q.x + Q.y * Q.y + Q.z * Q.z);
+#else
+    const float magnitudeReciprocal = FusionFastInverseSqrt(Q.w * Q.w + Q.x * Q.x + Q.y * Q.y + Q.z * Q.z);
+#endif
+    const FusionQuaternion result = {.element = {
+                                         .w = Q.w * magnitudeReciprocal,
+                                         .x = Q.x * magnitudeReciprocal,
+                                         .y = Q.y * magnitudeReciprocal,
+                                         .z = Q.z * magnitudeReciprocal,
+                                     }};
+    return result;
+#undef Q
+}
+
+//------------------------------------------------------------------------------
+// Inline functions - Matrix operations
+
+/**
+ * @brief Returns the multiplication of a matrix with a vector.
+ * @param matrix Matrix.
+ * @param vector Vector.
+ * @return Multiplication of a matrix with a vector.
+ */
+static inline FusionVector FusionMatrixMultiplyVector(const FusionMatrix matrix, const FusionVector vector)
+{
+#define R matrix.element
+    const FusionVector result = {.axis = {
+                                     .x = R.xx * vector.axis.x + R.xy * vector.axis.y + R.xz * vector.axis.z,
+                                     .y = R.yx * vector.axis.x + R.yy * vector.axis.y + R.yz * vector.axis.z,
+                                     .z = R.zx * vector.axis.x + R.zy * vector.axis.y + R.zz * vector.axis.z,
+                                 }};
+    return result;
+#undef R
+}
+
+//------------------------------------------------------------------------------
+// Inline functions - Conversion operations
+
+/**
+ * @brief Converts a quaternion to a rotation matrix.
+ * @param quaternion Quaternion.
+ * @return Rotation matrix.
+ */
+static inline FusionMatrix FusionQuaternionToMatrix(const FusionQuaternion quaternion)
+{
+#define Q quaternion.element
+    const float qwqw = Q.w * Q.w; // calculate common terms to avoid repeated operations
+    const float qwqx = Q.w * Q.x;
+    const float qwqy = Q.w * Q.y;
+    const float qwqz = Q.w * Q.z;
+    const float qxqy = Q.x * Q.y;
+    const float qxqz = Q.x * Q.z;
+    const float qyqz = Q.y * Q.z;
+    const FusionMatrix matrix = {.element = {
+                                     .xx = 2.0f * (qwqw - 0.5f + Q.x * Q.x),
+                                     .xy = 2.0f * (qxqy - qwqz),
+                                     .xz = 2.0f * (qxqz + qwqy),
+                                     .yx = 2.0f * (qxqy + qwqz),
+                                     .yy = 2.0f * (qwqw - 0.5f + Q.y * Q.y),
+                                     .yz = 2.0f * (qyqz - qwqx),
+                                     .zx = 2.0f * (qxqz - qwqy),
+                                     .zy = 2.0f * (qyqz + qwqx),
+                                     .zz = 2.0f * (qwqw - 0.5f + Q.z * Q.z),
+                                 }};
+    return matrix;
+#undef Q
+}
+
+/**
+ * @brief Converts a quaternion to ZYX Euler angles in degrees.
+ * @param quaternion Quaternion.
+ * @return Euler angles in degrees.
+ */
+static inline FusionEuler FusionQuaternionToEuler(const FusionQuaternion quaternion)
+{
+#define Q quaternion.element
+    const float halfMinusQySquared = 0.5f - Q.y * Q.y; // calculate common terms to avoid repeated operations
+    const FusionEuler euler = {.angle = {
+                                   .roll = FusionRadiansToDegrees(atan2f(Q.w * Q.x + Q.y * Q.z, halfMinusQySquared - Q.x * Q.x)),
+                                   .pitch = FusionRadiansToDegrees(FusionAsin(2.0f * (Q.w * Q.y - Q.z * Q.x))),
+                                   .yaw = FusionRadiansToDegrees(atan2f(Q.w * Q.z + Q.x * Q.y, halfMinusQySquared - Q.z * Q.z)),
+                               }};
+    return euler;
+#undef Q
+}
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionOffset.c

@@ -0,0 +1,80 @@
+/**
+ * @file FusionOffset.c
+ * @author Seb Madgwick
+ * @brief Gyroscope offset correction algorithm for run-time calibration of the
+ * gyroscope offset.
+ */
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionOffset.h"
+#include <math.h> // fabsf
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief Cutoff frequency in Hz.
+ */
+#define CUTOFF_FREQUENCY (0.02f)
+
+/**
+ * @brief Timeout in seconds.
+ */
+#define TIMEOUT (5)
+
+/**
+ * @brief Threshold in degrees per second.
+ */
+#define THRESHOLD (3.0f)
+
+//------------------------------------------------------------------------------
+// Functions
+
+/**
+ * @brief Initialises the gyroscope offset algorithm.
+ * @param offset Gyroscope offset algorithm structure.
+ * @param sampleRate Sample rate in Hz.
+ */
+void FusionOffsetInitialise(FusionOffset *const offset, const unsigned int sampleRate)
+{
+    offset->filterCoefficient = 2.0f * (float)M_PI * CUTOFF_FREQUENCY * (1.0f / (float)sampleRate);
+    offset->timeout = TIMEOUT * sampleRate;
+    offset->timer = 0;
+    offset->gyroscopeOffset = FUSION_VECTOR_ZERO;
+}
+
+/**
+ * @brief Updates the gyroscope offset algorithm and returns the corrected
+ * gyroscope measurement.
+ * @param offset Gyroscope offset algorithm structure.
+ * @param gyroscope Gyroscope measurement in degrees per second.
+ * @return Corrected gyroscope measurement in degrees per second.
+ */
+FusionVector FusionOffsetUpdate(FusionOffset *const offset, FusionVector gyroscope)
+{
+
+    // Subtract offset from gyroscope measurement
+    gyroscope = FusionVectorSubtract(gyroscope, offset->gyroscopeOffset);
+
+    // Reset timer if gyroscope not stationary
+    if ((fabsf(gyroscope.axis.x) > THRESHOLD) || (fabsf(gyroscope.axis.y) > THRESHOLD) || (fabsf(gyroscope.axis.z) > THRESHOLD)) {
+        offset->timer = 0;
+        return gyroscope;
+    }
+
+    // Increment timer while gyroscope stationary
+    if (offset->timer < offset->timeout) {
+        offset->timer++;
+        return gyroscope;
+    }
+
+    // Adjust offset if timer has elapsed
+    offset->gyroscopeOffset =
+        FusionVectorAdd(offset->gyroscopeOffset, FusionVectorMultiplyScalar(gyroscope, offset->filterCoefficient));
+    return gyroscope;
+}
+
+//------------------------------------------------------------------------------
+// End of file

src/Fusion/FusionOffset.h

@@ -0,0 +1,40 @@
+/**
+ * @file FusionOffset.h
+ * @author Seb Madgwick
+ * @brief Gyroscope offset correction algorithm for run-time calibration of the
+ * gyroscope offset.
+ */
+
+#ifndef FUSION_OFFSET_H
+#define FUSION_OFFSET_H
+
+//------------------------------------------------------------------------------
+// Includes
+
+#include "FusionMath.h"
+
+//------------------------------------------------------------------------------
+// Definitions
+
+/**
+ * @brief Gyroscope offset algorithm structure.  Structure members are used
+ * internally and must not be accessed by the application.
+ */
+typedef struct {
+    float filterCoefficient;
+    unsigned int timeout;
+    unsigned int timer;
+    FusionVector gyroscopeOffset;
+} FusionOffset;
+
+//------------------------------------------------------------------------------
+// Function declarations
+
+void FusionOffsetInitialise(FusionOffset *const offset, const unsigned int sampleRate);
+
+FusionVector FusionOffsetUpdate(FusionOffset *const offset, FusionVector gyroscope);
+
+#endif
+
+//------------------------------------------------------------------------------
+// End of file

src/GPSStatus.h

@@ -124,7 +124,7 @@ class GPSStatus : public Status
         if (isDirty) {
             if (hasLock) {
                 // In debug logs, identify position by @timestamp:stage (stage 3 = notify)
-                LOG_DEBUG("New GPS pos@%x:3 lat=%f, lon=%f, alt=%d, pdop=%.2f, track=%.2f, speed=%.2f, sats=%d\n", p.timestamp,
+                LOG_DEBUG("New GPS pos@%x:3 lat=%f lon=%f alt=%d pdop=%.2f track=%.2f speed=%.2f sats=%d\n", p.timestamp,
                           p.latitude_i * 1e-7, p.longitude_i * 1e-7, p.altitude, p.PDOP * 1e-2, p.ground_track * 1e-5,
                           p.ground_speed * 1e-2, p.sats_in_view);
             } else {

src/GpioLogic.cpp

@@ -0,0 +1,84 @@
+#include "GpioLogic.h"
+#include <assert.h>
+
+void GpioVirtPin::set(bool value)
+{
+    if (value != this->value) {
+        this->value = value ? PinState::On : PinState::Off;
+        if (dependentPin)
+            dependentPin->update();
+    }
+}
+
+GpioTransformer::GpioTransformer(GpioPin *outPin) : outPin(outPin) {}
+
+void GpioTransformer::set(bool value)
+{
+    outPin->set(value);
+}
+
+GpioNotTransformer::GpioNotTransformer(GpioVirtPin *inPin, GpioPin *outPin) : GpioTransformer(outPin), inPin(inPin)
+{
+    assert(!inPin->dependentPin); // We only allow one dependent pin
+    inPin->dependentPin = this;
+
+    // Don't update at construction time, because various GpioPins might be global constructor based not yet initied because
+    // order of operations for global constructors is not defined.
+    // update();
+}
+
+/**
+ * Update the output pin based on the current state of the input pin.
+ */
+void GpioNotTransformer::update()
+{
+    auto p = inPin->get();
+    if (p == GpioVirtPin::PinState::Unset)
+        return; // Not yet fully initialized
+
+    set(!p);
+}
+
+GpioBinaryTransformer::GpioBinaryTransformer(GpioVirtPin *inPin1, GpioVirtPin *inPin2, GpioPin *outPin, Operation operation)
+    : GpioTransformer(outPin), inPin1(inPin1), inPin2(inPin2), operation(operation)
+{
+    assert(!inPin1->dependentPin); // We only allow one dependent pin
+    inPin1->dependentPin = this;
+    assert(!inPin2->dependentPin); // We only allow one dependent pin
+    inPin2->dependentPin = this;
+
+    // Don't update at construction time, because various GpioPins might be global constructor based not yet initied because
+    // order of operations for global constructors is not defined.
+    // update();
+}
+
+void GpioBinaryTransformer::update()
+{
+    auto p1 = inPin1->get(), p2 = inPin2->get();
+    GpioVirtPin::PinState newValue = GpioVirtPin::PinState::Unset;
+
+    if (p1 == GpioVirtPin::PinState::Unset)
+        newValue = p2; // Not yet fully initialized
+    else if (p2 == GpioVirtPin::PinState::Unset)
+        newValue = p1; // Not yet fully initialized
+
+    // If we've already found our value just use it, otherwise need to do the operation
+    if (newValue == GpioVirtPin::PinState::Unset) {
+        switch (operation) {
+        case And:
+            newValue = (GpioVirtPin::PinState)(p1 && p2);
+            break;
+        case Or:
+            newValue = (GpioVirtPin::PinState)(p1 || p2);
+            break;
+        case Xor:
+            newValue = (GpioVirtPin::PinState)(p1 != p2);
+            break;
+        default:
+            assert(false);
+        }
+    }
+    set(newValue);
+}
+
+GpioSplitter::GpioSplitter(GpioPin *outPin1, GpioPin *outPin2) : outPin1(outPin1), outPin2(outPin2) {}

src/GpioLogic.h

@@ -0,0 +1,144 @@
+#pragma once
+
+#include "configuration.h"
+
+/**This is a set of classes to mediate access to GPIOs in a structured way.  Most usage of GPIOs do not
+    require these classes!  But if your hardware has a GPIO that is 'shared' between multiple devices (i.e. a shared power enable)
+    then using these classes might be able to let you cleanly turn on that enable when either dependent device is needed.
+
+    Note: these classes are intended to be 99% inline for the common case so should have minimal impact on flash or RAM
+   requirements.
+*/
+
+/**
+ * A logical GPIO pin (not necessary raw hardware).
+ */
+class GpioPin
+{
+  public:
+    virtual void set(bool value) = 0;
+};
+
+/**
+ * A physical GPIO hw pin.
+ */
+class GpioHwPin : public GpioPin
+{
+    uint32_t num;
+
+  public:
+    explicit GpioHwPin(uint32_t num) : num(num) {}
+
+    void set(bool value) { digitalWrite(num, value); }
+};
+
+class GpioTransformer;
+class GpioNotTransformer;
+class GpioBinaryTransformer;
+
+/**
+ * A virtual GPIO pin.
+ */
+class GpioVirtPin : public GpioPin
+{
+    friend class GpioBinaryTransformer;
+    friend class GpioNotTransformer;
+
+  public:
+    enum PinState { On = true, Off = false, Unset = 2 };
+
+    void set(bool value);
+    PinState get() const { return value; }
+
+  private:
+    PinState value = PinState::Unset;
+    GpioTransformer *dependentPin = NULL;
+};
+
+#include <assert.h>
+
+/**
+ * A 'smart' trigger that can depend in a fake GPIO and if that GPIO changes, drive some other downstream GPIO to change.
+ * notably: the set method is not public (because it always is calculated by a subclass)
+ */
+class GpioTransformer
+{
+  public:
+    /**
+     * Update the output pin based on the current state of the input pin.
+     */
+    virtual void update() = 0;
+
+  protected:
+    GpioTransformer(GpioPin *outPin);
+
+    void set(bool value);
+
+  private:
+    GpioPin *outPin;
+};
+
+/**
+ * A transformer that performs a unary NOT operation from an input.
+ */
+class GpioNotTransformer : public GpioTransformer
+{
+  public:
+    GpioNotTransformer(GpioVirtPin *inPin, GpioPin *outPin);
+
+  protected:
+    friend class GpioVirtPin;
+
+    /**
+     * Update the output pin based on the current state of the input pin.
+     */
+    void update();
+
+  private:
+    GpioVirtPin *inPin;
+};
+
+/**
+ * A transformer that combines multiple virtual pins to drive an output pin
+ */
+class GpioBinaryTransformer : public GpioTransformer
+{
+
+  public:
+    enum Operation { And, Or, Xor };
+
+    GpioBinaryTransformer(GpioVirtPin *inPin1, GpioVirtPin *inPin2, GpioPin *outPin, Operation operation);
+
+  protected:
+    friend class GpioVirtPin;
+
+    /**
+     * Update the output pin based on the current state of the input pins.
+     */
+    void update();
+
+  private:
+    GpioVirtPin *inPin1;
+    GpioVirtPin *inPin2;
+    Operation operation;
+};
+
+/**
+ * Sometimes a single output GPIO single needs to drive multiple physical GPIOs.  This class provides that.
+ */
+class GpioSplitter : public GpioPin
+{
+
+  public:
+    GpioSplitter(GpioPin *outPin1, GpioPin *outPin2);
+
+    void set(bool value)
+    {
+        outPin1->set(value);
+        outPin2->set(value);
+    }
+
+  private:
+    GpioPin *outPin1;
+    GpioPin *outPin2;
+};

src/Led.cpp

@@ -0,0 +1,66 @@
+#include "Led.h"
+#include "PowerMon.h"
+#include "main.h"
+#include "power.h"
+
+GpioVirtPin ledForceOn, ledBlink;
+
+#if defined(LED_PIN)
+// Most boards have a GPIO for LED control
+static GpioHwPin ledRawHwPin(LED_PIN);
+#else
+static GpioVirtPin ledRawHwPin; // Dummy pin for no hardware
+#endif
+
+#if LED_STATE_ON == 0
+static GpioVirtPin ledHwPin;
+static GpioNotTransformer ledInverter(&ledHwPin, &ledRawHwPin);
+#else
+static GpioPin &ledHwPin = ledRawHwPin;
+#endif
+
+#if defined(HAS_PMU)
+/**
+ * A GPIO controlled by the PMU
+ */
+class GpioPmuPin : public GpioPin
+{
+  public:
+    void set(bool value)
+    {
+        if (pmu_found && PMU) {
+            // blink the axp led
+            PMU->setChargingLedMode(value ? XPOWERS_CHG_LED_ON : XPOWERS_CHG_LED_OFF);
+        }
+    }
+} ledPmuHwPin;
+
+// In some cases we need to drive a PMU LED and a normal LED
+static GpioSplitter ledFinalPin(&ledHwPin, &ledPmuHwPin);
+#else
+static GpioPin &ledFinalPin = ledHwPin;
+#endif
+
+#ifdef USE_POWERMON
+/**
+ * We monitor changes to the LED drive output because we use that as a sanity test in our power monitor stuff.
+ */
+class MonitoredLedPin : public GpioPin
+{
+  public:
+    void set(bool value)
+    {
+        if (powerMon) {
+            if (value)
+                powerMon->setState(meshtastic_PowerMon_State_LED_On);
+            else
+                powerMon->clearState(meshtastic_PowerMon_State_LED_On);
+        }
+        ledFinalPin.set(value);
+    }
+} monitoredLedPin;
+#else
+static GpioPin &monitoredLedPin = ledFinalPin;
+#endif
+
+static GpioBinaryTransformer ledForcer(&ledForceOn, &ledBlink, &monitoredLedPin, GpioBinaryTransformer::Or);

src/Led.h

@@ -0,0 +1,7 @@
+#include "GpioLogic.h"
+#include "configuration.h"
+
+/**
+ * ledForceOn and ledForceOff both override the normal ledBlinker behavior (which is controlled by main)
+ */
+extern GpioVirtPin ledForceOn, ledBlink;

src/OSTimer.cpp

@@ -1,60 +0,0 @@
-#include "OSTimer.h"
-#include "configuration.h"
-
-/**
- * Schedule a callback to run.  The callback must _not_ block, though it is called from regular thread level (not ISR)
- *
- * NOTE! xTimerPend... seems to ignore the time passed in on ESP32 and on NRF52
- * The reason this didn't work is because xTimerPednFunctCall really isn't a timer function at all - it just means run the
-callback
- * from the timer thread the next time you have spare cycles.
- *
- * @return true if successful, false if the timer fifo is too full.
-
-bool scheduleOSCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec)
-{
-    return xTimerPendFunctionCall(callback, param1, param2, pdMS_TO_TICKS(delayMsec));
-} */
-
-#ifdef ARCH_ESP32
-
-// Super skanky quick hack to use hardware timers of the ESP32
-static hw_timer_t *timer;
-static PendableFunction tCallback;
-static void *tParam1;
-static uint32_t tParam2;
-
-static void IRAM_ATTR onTimer()
-{
-    (*tCallback)(tParam1, tParam2);
-}
-
-/**
- * Schedules a hardware callback function to be executed after a specified delay.
- *
- * @param callback The function to be executed.
- * @param param1 The first parameter to be passed to the function.
- * @param param2 The second parameter to be passed to the function.
- * @param delayMsec The delay time in milliseconds before the function is executed.
- *
- * @return True if the function was successfully scheduled, false otherwise.
- */
-bool scheduleHWCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec)
-{
-    if (!timer) {
-        timer = timerBegin(0, 80, true); // one usec per tick (main clock is 80MhZ on ESP32)
-        assert(timer);
-        timerAttachInterrupt(timer, &onTimer, true);
-    }
-
-    tCallback = callback;
-    tParam1 = param1;
-    tParam2 = param2;
-
-    timerAlarmWrite(timer, delayMsec * 1000UL, false); // Do not reload, we want it to be a single shot timer
-    timerRestart(timer);
-    timerAlarmEnable(timer);
-    return true;
-}
-
-#endif

src/OSTimer.h

@@ -1,8 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-
-typedef void (*PendableFunction)(void *pvParameter1, uint32_t ulParameter2);
-
-/// Uses a hardware timer, but calls the handler in _interrupt_ context
-bool scheduleHWCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec);

src/Power.cpp

@@ -27,7 +27,7 @@
 #if defined(DEBUG_HEAP_MQTT) && !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #include "target_specific.h"
-#if !MESTASTIC_EXCLUDE_WIFI
+#if HAS_WIFI
 #include <WiFi.h>
 #endif
 #endif
@@ -75,10 +75,11 @@ INA219Sensor ina219Sensor;
 INA3221Sensor ina3221Sensor;
 #endif
 
+#if HAS_RAKPROT && !defined(ARCH_PORTDUINO)
+RAK9154Sensor rak9154Sensor;
+#endif
+
 #ifdef HAS_PMU
-#include "XPowersAXP192.tpp"
-#include "XPowersAXP2101.tpp"
-#include "XPowersLibInterface.hpp"
 XPowersLibInterface *PMU = NULL;
 #else
 
@@ -145,6 +146,12 @@ class AnalogBatteryLevel : public HasBatteryLevel
      */
     virtual int getBatteryPercent() override
     {
+#if defined(HAS_RAKPROT) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU)
+        if (hasRAK()) {
+            return rak9154Sensor.getBusBatteryPercent();
+        }
+#endif
+
         float v = getBattVoltage();
 
         if (v < noBatVolt)
@@ -184,7 +191,14 @@ class AnalogBatteryLevel : public HasBatteryLevel
     virtual uint16_t getBattVoltage() override
     {
 
-#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+#if defined(HAS_RAKPROT) && !defined(ARCH_PORTDUINO) && !defined(HAS_PMU)
+        if (hasRAK()) {
+            return getRAKVoltage();
+        }
+#endif
+
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(HAS_PMU) &&                                  \
+    !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
         if (hasINA()) {
             LOG_DEBUG("Using INA on I2C addr 0x%x for device battery voltage\n", config.power.device_battery_ina_address);
             return getINAVoltage();
@@ -217,11 +231,19 @@ class AnalogBatteryLevel : public HasBatteryLevel
             scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
             scaled *= operativeAdcMultiplier;
 #else           // block for all other platforms
+#ifdef ADC_CTRL // enable adc voltage divider when we need to read
+            pinMode(ADC_CTRL, OUTPUT);
+            digitalWrite(ADC_CTRL, ADC_CTRL_ENABLED);
+            delay(10);
+#endif
             for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
                 raw += analogRead(BATTERY_PIN);
             }
             raw = raw / BATTERY_SENSE_SAMPLES;
             scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
+#ifdef ADC_CTRL // disable adc voltage divider when we need to read
+            digitalWrite(ADC_CTRL, !ADC_CTRL_ENABLED);
+#endif
 #endif
 
             if (!initial_read_done) {
@@ -335,13 +357,20 @@ class AnalogBatteryLevel : public HasBatteryLevel
     virtual bool isVbusIn() override
     {
 #ifdef EXT_PWR_DETECT
+#ifdef HELTEC_CAPSULE_SENSOR_V3
+        // if external powered that pin will be pulled down
+        if (digitalRead(EXT_PWR_DETECT) == LOW) {
+            return true;
+        }
+        // if it's not LOW - check the battery
+#else
         // if external powered that pin will be pulled up
         if (digitalRead(EXT_PWR_DETECT) == HIGH) {
             return true;
         }
         // if it's not HIGH - check the battery
 #endif
-
+#endif
         return getBattVoltage() > chargingVolt;
     }
 
@@ -349,6 +378,11 @@ 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 (hasRAK()) {
+            return (rak9154Sensor.isCharging()) ? OptTrue : OptFalse;
+        }
+#endif
 #ifdef EXT_CHRG_DETECT
         return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
 #else
@@ -372,7 +406,19 @@ class AnalogBatteryLevel : public HasBatteryLevel
     float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
     uint32_t last_read_time_ms = 0;
 
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(ARCH_PORTDUINO)
+#if defined(HAS_RAKPROT)
+
+    uint16_t getRAKVoltage() { return rak9154Sensor.getBusVoltageMv(); }
+
+    bool hasRAK()
+    {
+        if (!rak9154Sensor.isInitialized())
+            return rak9154Sensor.runOnce() > 0;
+        return rak9154Sensor.isRunning();
+    }
+#endif
+
+#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
     uint16_t getINAVoltage()
     {
         if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
@@ -401,13 +447,18 @@ class AnalogBatteryLevel : public HasBatteryLevel
             if (!ina260Sensor.isInitialized())
                 return ina260Sensor.runOnce() > 0;
             return ina260Sensor.isRunning();
+        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first ==
+                   config.power.device_battery_ina_address) {
+            if (!ina3221Sensor.isInitialized())
+                return ina3221Sensor.runOnce() > 0;
+            return ina3221Sensor.isRunning();
         }
         return false;
     }
 #endif
 };
 
-AnalogBatteryLevel analogLevel;
+static AnalogBatteryLevel analogLevel;
 
 Power::Power() : OSThread("Power")
 {
@@ -421,8 +472,12 @@ Power::Power() : OSThread("Power")
 bool Power::analogInit()
 {
 #ifdef EXT_PWR_DETECT
+#ifdef HELTEC_CAPSULE_SENSOR_V3
+    pinMode(EXT_PWR_DETECT, INPUT_PULLUP);
+#else
     pinMode(EXT_PWR_DETECT, INPUT);
 #endif
+#endif
 #ifdef EXT_CHRG_DETECT
     pinMode(EXT_CHRG_DETECT, ext_chrg_detect_mode);
 #endif
@@ -502,6 +557,10 @@ bool Power::setup()
 {
     bool found = axpChipInit() || analogInit();
 
+#ifdef NRF_APM
+    found = true;
+#endif
+
     enabled = found;
     low_voltage_counter = 0;
 
@@ -531,10 +590,16 @@ void Power::shutdown()
 // TODO(girts): move this and other axp stuff to power.h/power.cpp.
 void Power::readPowerStatus()
 {
+    int32_t batteryVoltageMv = -1; // Assume unknown
+    int8_t batteryChargePercent = -1;
+    OptionalBool usbPowered = OptUnknown;
+    OptionalBool hasBattery = OptUnknown; // These must be static because NRF_APM code doesn't run every time
+    OptionalBool isCharging = OptUnknown;
+
     if (batteryLevel) {
-        bool hasBattery = batteryLevel->isBatteryConnect();
-        uint32_t batteryVoltageMv = 0;
-        int8_t batteryChargePercent = 0;
+        hasBattery = batteryLevel->isBatteryConnect() ? OptTrue : OptFalse;
+        usbPowered = batteryLevel->isVbusIn() ? OptTrue : OptFalse;
+        isCharging = batteryLevel->isCharging() ? OptTrue : OptFalse;
         if (hasBattery) {
             batteryVoltageMv = batteryLevel->getBattVoltage();
             // If the AXP192 returns a valid battery percentage, use it
@@ -549,36 +614,29 @@ void Power::readPowerStatus()
                                              0, 100);
             }
         }
+    }
 
-        OptionalBool NRF_USB = OptFalse;
-
+// FIXME: IMO we shouldn't be littering our code with all these ifdefs.  Way better instead to make a Nrf52IsUsbPowered subclass
+// (which shares a superclass with the BatteryLevel stuff)
+// that just provides a few methods.  But in the interest of fixing this bug I'm going to follow current
+// practice.
 #ifdef NRF_APM // Section of code detects USB power on the RAK4631 and updates the power states.  Takes 20 seconds or so to detect
                // changes.
 
-        static nrfx_power_usb_state_t prev_nrf_usb_state = (nrfx_power_usb_state_t)-1; // -1 so that state detected at boot
     nrfx_power_usb_state_t nrf_usb_state = nrfx_power_usbstatus_get();
+    // LOG_DEBUG("NRF Power %d\n", nrf_usb_state);
 
-        // If state changed
-        if (nrf_usb_state != prev_nrf_usb_state) {
     // If changed to DISCONNECTED
-            if (nrf_usb_state == NRFX_POWER_USB_STATE_DISCONNECTED) {
-                powerFSM.trigger(EVENT_POWER_DISCONNECTED);
-                NRF_USB = OptFalse;
-            }
+    if (nrf_usb_state == NRFX_POWER_USB_STATE_DISCONNECTED)
+        isCharging = usbPowered = OptFalse;
     // If changed to CONNECTED / READY
-            else {
-                powerFSM.trigger(EVENT_POWER_CONNECTED);
-                NRF_USB = OptTrue;
-            }
+    else
+        isCharging = usbPowered = OptTrue;
 
-            // Cache the current state
-            prev_nrf_usb_state = nrf_usb_state;
-        }
 #endif
+
     // Notify any status instances that are observing us
-        const PowerStatus powerStatus2 = PowerStatus(
-            hasBattery ? OptTrue : OptFalse, batteryLevel->isVbusIn() || NRF_USB == OptTrue ? OptTrue : OptFalse,
-            batteryLevel->isCharging() || NRF_USB == OptTrue ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
+    const PowerStatus powerStatus2 = PowerStatus(hasBattery, usbPowered, isCharging, batteryVoltageMv, batteryChargePercent);
     LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
               powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
     newStatus.notifyObservers(&powerStatus2);
@@ -624,7 +682,7 @@ void Power::readPowerStatus()
     // If we have a battery at all and it is less than 0%, force deep sleep if we have more than 10 low readings in
     // a row. NOTE: min LiIon/LiPo voltage is 2.0 to 2.5V, current OCV min is set to 3100 that is large enough.
     //
-        if (powerStatus2.getHasBattery() && !powerStatus2.getHasUSB()) {
+    if (batteryLevel && powerStatus2.getHasBattery() && !powerStatus2.getHasUSB()) {
         if (batteryLevel->getBattVoltage() < OCV[NUM_OCV_POINTS - 1]) {
             low_voltage_counter++;
             LOG_DEBUG("Low voltage counter: %d/10\n", low_voltage_counter);
@@ -641,11 +699,6 @@ void Power::readPowerStatus()
             low_voltage_counter = 0;
         }
     }
-    } else {
-        // No power sensing on this board - tell everyone else we have no idea what is happening
-        const PowerStatus powerStatus3 = PowerStatus(OptUnknown, OptUnknown, OptUnknown, -1, -1);
-        newStatus.notifyObservers(&powerStatus3);
-    }
 }
 
 int32_t Power::runOnce()

src/PowerFSM.cpp

@@ -9,8 +9,10 @@
  */
 #include "PowerFSM.h"
 #include "Default.h"
+#include "Led.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "PowerMon.h"
 #include "configuration.h"
 #include "graphics/Screen.h"
 #include "main.h"
@@ -20,12 +22,15 @@
 #ifndef SLEEP_TIME
 #define SLEEP_TIME 30
 #endif
-
+#if EXCLUDE_POWER_FSM
+FakeFsm powerFSM;
+void PowerFSM_setup(){};
+#else
 /// Should we behave as if we have AC power now?
 static bool isPowered()
 {
 // Circumvent the battery sensing logic and assumes constant power if no battery pin or power mgmt IC
-#if !defined(BATTERY_PIN) && !defined(HAS_AXP192) && !defined(HAS_AXP2101)
+#if !defined(BATTERY_PIN) && !defined(HAS_AXP192) && !defined(HAS_AXP2101) && !defined(NRF_APM)
     return true;
 #endif
 
@@ -87,14 +92,16 @@ static void lsIdle()
             // Briefly come out of sleep long enough to blink the led once every few seconds
             uint32_t sleepTime = SLEEP_TIME;
 
-            setLed(false); // Never leave led on while in light sleep
+            powerMon->setState(meshtastic_PowerMon_State_CPU_LightSleep);
+            ledBlink.set(false); // Never leave led on while in light sleep
             esp_sleep_source_t wakeCause2 = doLightSleep(sleepTime * 1000LL);
+            powerMon->clearState(meshtastic_PowerMon_State_CPU_LightSleep);
 
             switch (wakeCause2) {
             case ESP_SLEEP_WAKEUP_TIMER:
                 // Normal case: timer expired, we should just go back to sleep ASAP
 
-                setLed(true);                   // briefly turn on led
+                ledBlink.set(true);             // briefly turn on led
                 wakeCause2 = doLightSleep(100); // leave led on for 1ms
 
                 secsSlept += sleepTime;
@@ -129,7 +136,7 @@ static void lsIdle()
         }
     } else {
         // Time to stop sleeping!
-        setLed(false);
+        ledBlink.set(false);
         LOG_INFO("Reached ls_secs, servicing loop()\n");
         powerFSM.trigger(EVENT_WAKE_TIMER);
     }
@@ -392,3 +399,4 @@ void PowerFSM_setup()
 
     powerFSM.run_machine(); // run one iteration of the state machine, so we run our on enter tasks for the initial DARK state
 }
+#endif

src/PowerFSM.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Fsm.h>
+#include "configuration.h"
 
 // See sw-design.md for documentation
 
@@ -22,7 +22,30 @@
 #define EVENT_SHUTDOWN 16        // force a full shutdown now (not just sleep)
 #define EVENT_INPUT 17           // input broker wants something, we need to wake up and enable screen
 
+#if EXCLUDE_POWER_FSM
+class FakeFsm
+{
+  public:
+    void trigger(int event)
+    {
+        if (event == EVENT_SERIAL_CONNECTED) {
+            serialConnected = true;
+        } else if (event == EVENT_SERIAL_DISCONNECTED) {
+            serialConnected = false;
+        }
+    };
+    bool getState() { return serialConnected; };
+
+  private:
+    bool serialConnected = false;
+};
+extern FakeFsm powerFSM;
+void PowerFSM_setup();
+
+#else
+#include <Fsm.h>
 extern Fsm powerFSM;
 extern State stateON, statePOWER, stateSERIAL, stateDARK;
 
 void PowerFSM_setup();
+#endif

src/PowerFSMThread.h

@@ -18,6 +18,7 @@ class PowerFSMThread : public OSThread
   protected:
     int32_t runOnce() override
     {
+#if !EXCLUDE_POWER_FSM
         powerFSM.run_machine();
 
         /// If we are in power state we force the CPU to wake every 10ms to check for serial characters (we don't yet wake
@@ -35,6 +36,9 @@ class PowerFSMThread : public OSThread
         }
 
         return 100;
+#else
+        return INT32_MAX;
+#endif
     }
 };
 

src/PowerMon.cpp

@@ -0,0 +1,47 @@
+#include "PowerMon.h"
+#include "NodeDB.h"
+
+// Use the 'live' config flag to figure out if we should be showing this message
+bool PowerMon::is_power_enabled(uint64_t m)
+{
+    // FIXME: VERY STRANGE BUG: if I or in "force_enabled || " the flashed image on a rak4631 is not accepted by the bootloader as
+    // valid!!!  Possibly a linker/gcc/bootloader bug somewhere?
+    return ((m & config.power.powermon_enables) ? true : false);
+}
+
+void PowerMon::setState(_meshtastic_PowerMon_State state, const char *reason)
+{
+#ifdef USE_POWERMON
+    auto oldstates = states;
+    states |= state;
+    if (oldstates != states && is_power_enabled(state)) {
+        emitLog(reason);
+    }
+#endif
+}
+
+void PowerMon::clearState(_meshtastic_PowerMon_State state, const char *reason)
+{
+#ifdef USE_POWERMON
+    auto oldstates = states;
+    states &= ~state;
+    if (oldstates != states && is_power_enabled(state)) {
+        emitLog(reason);
+    }
+#endif
+}
+
+void PowerMon::emitLog(const char *reason)
+{
+#ifdef USE_POWERMON
+    // The nrf52 printf doesn't understand 64 bit ints, so if we ever reach that point this function will need to change.
+    LOG_INFO("S:PM:0x%08lx,%s\n", (uint32_t)states, reason);
+#endif
+}
+
+PowerMon *powerMon;
+
+void powerMonInit()
+{
+    powerMon = new PowerMon();
+}

src/PowerMon.h

@@ -0,0 +1,44 @@
+#pragma once
+#include "configuration.h"
+
+#include "meshtastic/powermon.pb.h"
+
+#ifndef MESHTASTIC_EXCLUDE_POWERMON
+#define USE_POWERMON // FIXME turn this only for certain builds
+#endif
+
+/**
+ * The singleton class for monitoring power consumption of device
+ * subsystems/modes.
+ *
+ * For more information see the PowerMon docs.
+ */
+class PowerMon
+{
+    uint64_t states = 0UL;
+
+    friend class PowerStressModule;
+
+    /**
+     * If stress testing we always want all events logged
+     */
+    bool force_enabled = false;
+
+  public:
+    PowerMon() {}
+
+    // Mark entry/exit of a power consuming state
+    void setState(_meshtastic_PowerMon_State state, const char *reason = "");
+    void clearState(_meshtastic_PowerMon_State state, const char *reason = "");
+
+  private:
+    // Emit the coded log message
+    void emitLog(const char *reason);
+
+    // Use the 'live' config flag to figure out if we should be showing this message
+    bool is_power_enabled(uint64_t m);
+};
+
+extern PowerMon *powerMon;
+
+void powerMonInit();

src/RedirectablePrint.cpp

@@ -3,6 +3,8 @@
 #include "RTC.h"
 #include "concurrency/OSThread.h"
 #include "configuration.h"
+#include "main.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
 #include <assert.h>
 #include <cstring>
 #include <memory>
@@ -14,12 +16,7 @@
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
-/**
- * A printer that doesn't go anywhere
- */
-NoopPrint noopPrint;
-
-#if HAS_WIFI || HAS_ETHERNET
+#if HAS_NETWORKING
 extern Syslog syslog;
 #endif
 void RedirectablePrint::rpInit()
@@ -38,21 +35,32 @@ void RedirectablePrint::setDestination(Print *_dest)
 size_t RedirectablePrint::write(uint8_t c)
 {
     // Always send the characters to our segger JTAG debugger
-#ifdef SEGGER_STDOUT_CH
+#ifdef USE_SEGGER
     SEGGER_RTT_PutChar(SEGGER_STDOUT_CH, c);
 #endif
-
-    if (!config.has_lora || config.device.serial_enabled)
+    // Account for legacy config transition
+    bool serialEnabled = config.has_security ? config.security.serial_enabled : config.device.serial_enabled;
+    if (!config.has_lora || serialEnabled)
         dest->write(c);
 
     return 1; // We always claim one was written, rather than trusting what the
               // serial port said (which could be zero)
 }
 
-size_t RedirectablePrint::vprintf(const char *format, va_list arg)
+size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_list arg)
 {
     va_list copy;
+#if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
+    static char printBuf[512];
+#else
     static char printBuf[160];
+#endif
+
+#ifdef ARCH_PORTDUINO
+    bool color = !settingsMap[ascii_logs];
+#else
+    bool color = true;
+#endif
 
     va_copy(copy, arg);
     size_t len = vsnprintf(printBuf, sizeof(printBuf), format, copy);
@@ -65,40 +73,54 @@ size_t RedirectablePrint::vprintf(const char *format, va_list arg)
         len = sizeof(printBuf) - 1;
         printBuf[sizeof(printBuf) - 2] = '\n';
     }
-
+    for (size_t f = 0; f < len; f++) {
+        if (!std::isprint(static_cast<unsigned char>(printBuf[f])) && printBuf[f] != '\n')
+            printBuf[f] = '#';
+    }
+    if (color && logLevel != nullptr) {
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+            Print::write("\u001b[34m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+            Print::write("\u001b[32m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+            Print::write("\u001b[33m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
+            Print::write("\u001b[31m", 6);
+    }
     len = Print::write(printBuf, len);
+    if (color && logLevel != nullptr) {
+        Print::write("\u001b[0m", 5);
+    }
     return len;
 }
 
-size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
+void RedirectablePrint::log_to_serial(const char *logLevel, const char *format, va_list arg)
 {
-#ifdef ARCH_PORTDUINO
-    if (settingsMap[logoutputlevel] < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
-        return 0;
-    else if (settingsMap[logoutputlevel] < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
-        return 0;
-    else if (settingsMap[logoutputlevel] < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
-        return 0;
-#endif
-    if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
-        return 0;
-    }
     size_t r = 0;
-#ifdef HAS_FREE_RTOS
-    if (inDebugPrint != nullptr && xSemaphoreTake(inDebugPrint, portMAX_DELAY) == pdTRUE) {
-#else
-    if (!inDebugPrint) {
-        inDebugPrint = true;
-#endif
-
-        va_list arg;
-        va_start(arg, format);
 
     // Cope with 0 len format strings, but look for new line terminator
     bool hasNewline = *format && format[strlen(format) - 1] == '\n';
+#ifdef ARCH_PORTDUINO
+    bool color = !settingsMap[ascii_logs];
+#else
+    bool color = true;
+#endif
 
     // If we are the first message on a report, include the header
     if (!isContinuationMessage) {
+        if (color) {
+            if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+                Print::write("\u001b[34m", 6);
+            if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+                Print::write("\u001b[32m", 6);
+            if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+                Print::write("\u001b[33m", 6);
+            if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
+                Print::write("\u001b[31m", 6);
+            if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0)
+                Print::write("\u001b[35m", 6);
+        }
+
         uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // display local time on logfile
         if (rtc_sec > 0) {
             long hms = rtc_sec % SEC_PER_DAY;
@@ -112,17 +134,33 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
             int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
             int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
 #ifdef ARCH_PORTDUINO
-                r += ::printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
+            ::printf("%s ", logLevel);
+            if (color) {
+                ::printf("\u001b[0m");
+            }
+            ::printf("| %02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
 #else
-                r += printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
+            printf("%s ", logLevel);
+            if (color) {
+                printf("\u001b[0m");
+            }
+            printf("| %02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
 #endif
-            } else
+        } else {
 #ifdef ARCH_PORTDUINO
-                r += ::printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
+            ::printf("%s ", logLevel);
+            if (color) {
+                ::printf("\u001b[0m");
+            }
+            ::printf("| ??:??:?? %u ", millis() / 1000);
 #else
-                r += printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
+            printf("%s ", logLevel);
+            if (color) {
+                printf("\u001b[0m");
+            }
+            printf("| ??:??:?? %u ", millis() / 1000);
 #endif
-
+        }
         auto thread = concurrency::OSThread::currentThread;
         if (thread) {
             print("[");
@@ -132,9 +170,14 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
             print("] ");
         }
     }
-        r += vprintf(format, arg);
+    r += vprintf(logLevel, format, arg);
 
-#if (HAS_WIFI || HAS_ETHERNET) && !defined(ARCH_PORTDUINO)
+    isContinuationMessage = !hasNewline;
+}
+
+void RedirectablePrint::log_to_syslog(const char *logLevel, const char *format, va_list arg)
+{
+#if HAS_NETWORKING && !defined(ARCH_PORTDUINO)
     // if syslog is in use, collect the log messages and send them to syslog
     if (syslog.isEnabled()) {
         int ll = 0;
@@ -165,10 +208,122 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
         }
     }
 #endif
+}
+
+void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_list arg)
+{
+#if !MESHTASTIC_EXCLUDE_BLUETOOTH
+    if (config.security.debug_log_api_enabled && !pauseBluetoothLogging) {
+        bool isBleConnected = false;
+#ifdef ARCH_ESP32
+        isBleConnected = nimbleBluetooth && nimbleBluetooth->isActive() && nimbleBluetooth->isConnected();
+#elif defined(ARCH_NRF52)
+        isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
+#endif
+        if (isBleConnected) {
+            char *message;
+            size_t initialLen;
+            size_t len;
+            initialLen = strlen(format);
+            message = new char[initialLen + 1];
+            len = vsnprintf(message, initialLen + 1, format, arg);
+            if (len > initialLen) {
+                delete[] message;
+                message = new char[len + 1];
+                vsnprintf(message, len + 1, format, arg);
+            }
+            auto thread = concurrency::OSThread::currentThread;
+            meshtastic_LogRecord logRecord = meshtastic_LogRecord_init_zero;
+            logRecord.level = getLogLevel(logLevel);
+            strcpy(logRecord.message, message);
+            if (thread)
+                strcpy(logRecord.source, thread->ThreadName.c_str());
+            logRecord.time = getValidTime(RTCQuality::RTCQualityDevice, true);
+
+            uint8_t *buffer = new uint8_t[meshtastic_LogRecord_size];
+            size_t size = pb_encode_to_bytes(buffer, meshtastic_LogRecord_size, meshtastic_LogRecord_fields, &logRecord);
+#ifdef ARCH_ESP32
+            nimbleBluetooth->sendLog(buffer, size);
+#elif defined(ARCH_NRF52)
+            nrf52Bluetooth->sendLog(buffer, size);
+#endif
+            delete[] message;
+            delete[] buffer;
+        }
+    }
+#else
+    (void)logLevel;
+    (void)format;
+    (void)arg;
+#endif
+}
+
+meshtastic_LogRecord_Level RedirectablePrint::getLogLevel(const char *logLevel)
+{
+    meshtastic_LogRecord_Level ll = meshtastic_LogRecord_Level_UNSET; // default to unset
+    switch (logLevel[0]) {
+    case 'D':
+        ll = meshtastic_LogRecord_Level_DEBUG;
+        break;
+    case 'I':
+        ll = meshtastic_LogRecord_Level_INFO;
+        break;
+    case 'W':
+        ll = meshtastic_LogRecord_Level_WARNING;
+        break;
+    case 'E':
+        ll = meshtastic_LogRecord_Level_ERROR;
+        break;
+    case 'C':
+        ll = meshtastic_LogRecord_Level_CRITICAL;
+        break;
+    }
+    return ll;
+}
+
+void RedirectablePrint::log(const char *logLevel, const char *format, ...)
+{
+#if ARCH_PORTDUINO
+    // level trace is special, two possible ways to handle it.
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
+        if (settingsStrings[traceFilename] != "") {
+            va_list arg;
+            va_start(arg, format);
+            try {
+                traceFile << va_arg(arg, char *) << std::endl;
+            } catch (const std::ios_base::failure &e) {
+            }
+            va_end(arg);
+        }
+        if (settingsMap[logoutputlevel] < level_trace && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0)
+            return;
+    }
+    if (settingsMap[logoutputlevel] < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+        return;
+    else if (settingsMap[logoutputlevel] < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+        return;
+    else if (settingsMap[logoutputlevel] < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+        return;
+#endif
+    if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
+        return;
+    }
+
+#ifdef HAS_FREE_RTOS
+    if (inDebugPrint != nullptr && xSemaphoreTake(inDebugPrint, portMAX_DELAY) == pdTRUE) {
+#else
+    if (!inDebugPrint) {
+        inDebugPrint = true;
+#endif
+
+        va_list arg;
+        va_start(arg, format);
+
+        log_to_serial(logLevel, format, arg);
+        log_to_syslog(logLevel, format, arg);
+        log_to_ble(logLevel, format, arg);
 
         va_end(arg);
-
-        isContinuationMessage = !hasNewline;
 #ifdef HAS_FREE_RTOS
         xSemaphoreGive(inDebugPrint);
 #else
@@ -176,7 +331,7 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
 #endif
     }
 
-    return r;
+    return;
 }
 
 void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16_t len)

src/RedirectablePrint.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../freertosinc.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
 #include <Print.h>
 #include <stdarg.h>
 #include <string>
@@ -41,23 +42,21 @@ class RedirectablePrint : public Print
      * log message.  Otherwise we assume more prints will come before the log message ends.  This
      * allows you to call logDebug a few times to build up a single log message line if you wish.
      */
-    size_t log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
+    void log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
 
     /** like printf but va_list based */
-    size_t vprintf(const char *format, va_list arg);
+    size_t vprintf(const char *logLevel, const char *format, va_list arg);
 
     void hexDump(const char *logLevel, unsigned char *buf, uint16_t len);
 
     std::string mt_sprintf(const std::string fmt_str, ...);
-};
 
-class NoopPrint : public Print
-{
-  public:
-    virtual size_t write(uint8_t c) { return 1; }
-};
+  protected:
+    /// Subclasses can override if they need to change how we format over the serial port
+    virtual void log_to_serial(const char *logLevel, const char *format, va_list arg);
 
-/**
- * A printer that doesn't go anywhere
- */
-extern NoopPrint noopPrint;
+  private:
+    void log_to_syslog(const char *logLevel, const char *format, va_list arg);
+    void log_to_ble(const char *logLevel, const char *format, va_list arg);
+    meshtastic_LogRecord_Level getLogLevel(const char *logLevel);
+};

src/SafeFile.cpp

@@ -0,0 +1,105 @@
+#include "SafeFile.h"
+
+#ifdef FSCom
+
+// Only way to work on both esp32 and nrf52
+static File openFile(const char *filename, bool fullAtomic)
+{
+    if (!fullAtomic)
+        FSCom.remove(filename); // Nuke the old file to make space (ignore if it !exists)
+
+    String filenameTmp = filename;
+    filenameTmp += ".tmp";
+
+    // clear any previous LFS errors
+    lfs_assert_failed = false;
+
+    return FSCom.open(filenameTmp.c_str(), FILE_O_WRITE);
+}
+
+SafeFile::SafeFile(const char *_filename, bool fullAtomic)
+    : filename(_filename), f(openFile(_filename, fullAtomic)), fullAtomic(fullAtomic)
+{
+}
+
+size_t SafeFile::write(uint8_t ch)
+{
+    if (!f)
+        return 0;
+
+    hash ^= ch;
+    return f.write(ch);
+}
+
+size_t SafeFile::write(const uint8_t *buffer, size_t size)
+{
+    if (!f)
+        return 0;
+
+    for (size_t i = 0; i < size; i++) {
+        hash ^= buffer[i];
+    }
+    return f.write((uint8_t const *)buffer, size); // This nasty cast is _IMPORTANT_ otherwise the correct adafruit method does
+                                                   // not get used (they made a mistake in their typing)
+}
+
+/**
+ * Atomically close the file (deleting any old versions) and readback the contents to confirm the hash matches
+ *
+ * @return false for failure
+ */
+bool SafeFile::close()
+{
+    if (!f)
+        return false;
+
+    f.close();
+    if (!testReadback())
+        return false;
+
+    // brief window of risk here ;-)
+    if (fullAtomic && FSCom.exists(filename.c_str()) && !FSCom.remove(filename.c_str())) {
+        LOG_ERROR("Can't remove old pref file\n");
+        return false;
+    }
+
+    String filenameTmp = filename;
+    filenameTmp += ".tmp";
+    if (!renameFile(filenameTmp.c_str(), filename.c_str())) {
+        LOG_ERROR("Error: can't rename new pref file\n");
+        return false;
+    }
+
+    return true;
+}
+
+/// Read our (closed) tempfile back in and compare the hash
+bool SafeFile::testReadback()
+{
+    bool lfs_failed = lfs_assert_failed;
+    lfs_assert_failed = false;
+
+    String filenameTmp = filename;
+    filenameTmp += ".tmp";
+    auto f2 = FSCom.open(filenameTmp.c_str(), FILE_O_READ);
+    if (!f2) {
+        LOG_ERROR("Can't open tmp file for readback\n");
+        return false;
+    }
+
+    int c = 0;
+    uint8_t test_hash = 0;
+    while ((c = f2.read()) >= 0) {
+        test_hash ^= (uint8_t)c;
+    }
+    f2.close();
+
+    if (test_hash != hash) {
+        LOG_ERROR("Readback failed hash mismatch\n");
+        return false;
+    }
+
+    return !lfs_failed;
+}
+
+#endif

src/SafeFile.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "FSCommon.h"
+#include "configuration.h"
+
+#ifdef FSCom
+
+/**
+ * This class provides 'safe'/paranoid file writing.
+ *
+ * Some of our filesystems (in particular the nrf52) may have bugs beneath our layer.  Therefore we want to
+ * be very careful about how we write files.  This class provides a restricted (Stream only) writing API for writing to files.
+ *
+ * Notably:
+ * - we keep a simple xor hash of all characters that were written.
+ * - We do not allow seeking (because we want to maintain our hash)
+ * - we provide an close() method which is similar to close but returns false if we were unable to successfully write the
+ * file.  Also this method
+ * - atomically replaces any old version of the file on the disk with our new file (after first rereading the file from the disk
+ * to confirm the hash matches)
+ * - Some files are super huge so we can't do the full atomic rename/copy (because of filesystem size limits).  If !fullAtomic
+ * then we still do the readback to verify file is valid so higher level code can handle failures.
+ */
+class SafeFile : public Print
+{
+  public:
+    SafeFile(char const *filepath, bool fullAtomic = false);
+
+    virtual size_t write(uint8_t);
+    virtual size_t write(const uint8_t *buffer, size_t size);
+
+    /**
+     * Atomically close the file (deleting any old versions) and readback the contents to confirm the hash matches
+     *
+     * @return false for failure
+     */
+    bool close();
+
+  private:
+    /// Read our (closed) tempfile back in and compare the hash
+    bool testReadback();
+
+    String filename;
+    File f;
+    bool fullAtomic;
+    uint8_t hash = 0;
+};
+
+#endif

src/SerialConsole.cpp

@@ -7,8 +7,12 @@
 #ifdef RP2040_SLOW_CLOCK
 #define Port Serial2
 #else
+#ifdef USER_DEBUG_PORT // change by WayenWeng
+#define Port USER_DEBUG_PORT
+#else
 #define Port Serial
 #endif
+#endif
 // Defaulting to the formerly removed phone_timeout_secs value of 15 minutes
 #define SERIAL_CONNECTION_TIMEOUT (15 * 60) * 1000UL
 
@@ -24,7 +28,7 @@ void consolePrintf(const char *format, ...)
 {
     va_list arg;
     va_start(arg, format);
-    console->vprintf(format, arg);
+    console->vprintf(nullptr, format, arg);
     va_end(arg);
     console->flush();
 }
@@ -34,7 +38,6 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), con
     assert(!console);
     console = this;
     canWrite = false; // We don't send packets to our port until it has talked to us first
-                      // setDestination(&noopPrint); for testing, try turning off 'all' debug output and see what leaks
 
 #ifdef RP2040_SLOW_CLOCK
     Port.setTX(SERIAL2_TX);
@@ -80,10 +83,9 @@ bool SerialConsole::checkIsConnected()
 bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
 {
     // only talk to the API once the configuration has been loaded and we're sure the serial port is not disabled.
-    if (config.has_lora && config.device.serial_enabled) {
-        // Turn off debug serial printing once the API is activated, because other threads could print and corrupt packets
-        if (!config.device.debug_log_enabled)
-            setDestination(&noopPrint);
+    if (config.has_lora && config.security.serial_enabled) {
+        // Switch to protobufs for log messages
+        usingProtobufs = true;
         canWrite = true;
 
         return StreamAPI::handleToRadio(buf, len);
@@ -91,3 +93,31 @@ bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
         return false;
     }
 }
+
+void SerialConsole::log_to_serial(const char *logLevel, const char *format, va_list arg)
+{
+    if (usingProtobufs && config.security.debug_log_api_enabled) {
+        meshtastic_LogRecord_Level ll = meshtastic_LogRecord_Level_UNSET; // default to unset
+        switch (logLevel[0]) {
+        case 'D':
+            ll = meshtastic_LogRecord_Level_DEBUG;
+            break;
+        case 'I':
+            ll = meshtastic_LogRecord_Level_INFO;
+            break;
+        case 'W':
+            ll = meshtastic_LogRecord_Level_WARNING;
+            break;
+        case 'E':
+            ll = meshtastic_LogRecord_Level_ERROR;
+            break;
+        case 'C':
+            ll = meshtastic_LogRecord_Level_CRITICAL;
+            break;
+        }
+
+        auto thread = concurrency::OSThread::currentThread;
+        emitLogRecord(ll, thread ? thread->ThreadName.c_str() : "", format, arg);
+    } else
+        RedirectablePrint::log_to_serial(logLevel, format, arg);
+}

src/SerialConsole.h

@@ -8,6 +8,11 @@
  */
 class SerialConsole : public StreamAPI, public RedirectablePrint, private concurrency::OSThread
 {
+    /**
+     * If true we are talking to a smart host and all messages (including log messages) must be framed as protobufs.
+     */
+    bool usingProtobufs = false;
+
   public:
     SerialConsole();
 
@@ -31,6 +36,9 @@ class SerialConsole : public StreamAPI, public RedirectablePrint, private concur
   protected:
     /// Check the current underlying physical link to see if the client is currently connected
     virtual bool checkIsConnected() override;
+
+    /// Possibly switch to protobufs if we see a valid protobuf message
+    virtual void log_to_serial(const char *logLevel, const char *format, va_list arg);
 };
 
 // A simple wrapper to allow non class aware code write to the console

src/commands.h

@@ -8,13 +8,11 @@ enum class Cmd {
     SET_ON,
     SET_OFF,
     ON_PRESS,
-    START_BLUETOOTH_PIN_SCREEN,
+    START_ALERT_FRAME,
+    STOP_ALERT_FRAME,
     START_FIRMWARE_UPDATE_SCREEN,
-    STOP_BLUETOOTH_PIN_SCREEN,
     STOP_BOOT_SCREEN,
     PRINT,
-    START_SHUTDOWN_SCREEN,
-    START_REBOOT_SCREEN,
     SHOW_PREV_FRAME,
     SHOW_NEXT_FRAME
 };

src/configuration.h

@@ -52,10 +52,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Configuration
 // -----------------------------------------------------------------------------
 
-// If we are using the JTAG port for debugging, some pins must be left free for that (and things like GPS have to be disabled)
-// we don't support jtag on the ttgo - access to gpio 12 is a PITA
-#define REQUIRE_RADIO true // If true, we will fail to start if the radio is not found
-
 /// Convert a preprocessor name into a quoted string
 #define xstr(s) ystr(s)
 #define ystr(s) #s
@@ -75,11 +71,17 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 // -----------------------------------------------------------------------------
-// Regulatory overrides for producing regional builds
+// Regulatory overrides
 // -----------------------------------------------------------------------------
 
-// Define if region should override user saved region
-// #define LORA_REGIONCODE meshtastic_Config_LoRaConfig_RegionCode_SG_923
+// Override user saved region, for producing region-locked builds
+// #define REGULATORY_LORA_REGIONCODE meshtastic_Config_LoRaConfig_RegionCode_SG_923
+
+// Total system gain in dBm to subtract from Tx power to remain within regulatory ERP limit for non-licensed operators
+// This value should be set in variant.h and is PA gain + antenna gain (if system ships with an antenna)
+#ifndef REGULATORY_GAIN_LORA
+#define REGULATORY_GAIN_LORA 0
+#endif
 
 // -----------------------------------------------------------------------------
 // Feature toggles
@@ -136,6 +138,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 NAU7802_ADDR 0x2A
 
 // -----------------------------------------------------------------------------
 // ACCELEROMETER
@@ -144,6 +147,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LIS3DH_ADR 0x18
 #define BMA423_ADDR 0x19
 #define LSM6DS3_ADDR 0x6A
+#define BMX160_ADDR 0x69
 
 // -----------------------------------------------------------------------------
 // LED
@@ -163,10 +167,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // -----------------------------------------------------------------------------
 // GPS
 // -----------------------------------------------------------------------------
-#ifndef GPS_BAUDRATE
-#define GPS_BAUDRATE 9600
-#endif
-
 #ifndef GPS_THREAD_INTERVAL
 #define GPS_THREAD_INTERVAL 200
 #endif
@@ -177,6 +177,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Step #1: offer chance for variant-specific defines */
 #include "variant.h"
 
+#ifndef GPS_BAUDRATE
+#define GPS_BAUDRATE 9600
+#endif
+
 /* Step #2: follow with defines common to the architecture;
    also enable HAS_ option not specifically disabled by variant.h */
 #include "architecture.h"
@@ -189,6 +193,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEFAULT_SHUTDOWN_SECONDS 2
 #endif
 
+#ifndef MINIMUM_SAFE_FREE_HEAP
+#define MINIMUM_SAFE_FREE_HEAP 1500
+#endif
+
 /* Step #3: mop up with disabled values for HAS_ options not handled by the above two */
 
 #ifndef HAS_WIFI
@@ -234,9 +242,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_BLUETOOTH 0
 #endif
 
-#include "DebugConfiguration.h"
-#include "RF95Configuration.h"
-
 #ifndef HW_VENDOR
 #error HW_VENDOR must be defined
 #endif
@@ -253,6 +258,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_GPS 1
 #define MESHTASTIC_EXCLUDE_SCREEN 1
 #define MESHTASTIC_EXCLUDE_MQTT 1
+#define MESHTASTIC_EXCLUDE_POWERMON 1
+#define MESHTASTIC_EXCLUDE_I2C 1
+#define MESHTASTIC_EXCLUDE_PKI 1
+#define MESHTASTIC_EXCLUDE_POWER_FSM 1
+#define MESHTASTIC_EXCLUDE_TZ 1
 #endif
 
 // Turn off all optional modules
@@ -266,6 +276,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_RANGETEST 1
 #define MESHTASTIC_EXCLUDE_REMOTEHARDWARE 1
 #define MESHTASTIC_EXCLUDE_STOREFORWARD 1
+#define MESHTASTIC_EXCLUDE_TEXTMESSAGE 1
 #define MESHTASTIC_EXCLUDE_ATAK 1
 #define MESHTASTIC_EXCLUDE_CANNEDMESSAGES 1
 #define MESHTASTIC_EXCLUDE_NEIGHBORINFO 1
@@ -273,6 +284,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_WAYPOINT 1
 #define MESHTASTIC_EXCLUDE_INPUTBROKER 1
 #define MESHTASTIC_EXCLUDE_SERIAL 1
+#define MESHTASTIC_EXCLUDE_POWERSTRESS 1
+#define MESHTASTIC_EXCLUDE_ADMIN 1
 #endif
 
 // // Turn off wifi even if HW supports wifi (webserver relies on wifi and is also disabled)
@@ -282,6 +295,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_WIFI 0
 #endif
 
+// Allow code that needs internet to just check HAS_NETWORKING rather than HAS_WIFI || HAS_ETHERNET
+#define HAS_NETWORKING (HAS_WIFI || HAS_ETHERNET)
+
 // // Turn off Bluetooth
 #ifdef MESHTASTIC_EXCLUDE_BLUETOOTH
 #undef HAS_BLUETOOTH
@@ -301,3 +317,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #undef HAS_SCREEN
 #define HAS_SCREEN 0
 #endif
+
+#include "DebugConfiguration.h"
+#include "RF95Configuration.h"

src/detect/ScanI2C.cpp

@@ -6,6 +6,7 @@ const ScanI2C::FoundDevice ScanI2C::DEVICE_NONE = ScanI2C::FoundDevice(ScanI2C::
 ScanI2C::ScanI2C() = default;
 
 void ScanI2C::scanPort(ScanI2C::I2CPort port) {}
+void ScanI2C::scanPort(ScanI2C::I2CPort port, uint8_t *address, uint8_t asize) {}
 
 void ScanI2C::setSuppressScreen()
 {
@@ -36,8 +37,8 @@ ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
 
 ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const
 {
-    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423, LSM6DS3};
-    return firstOfOrNONE(4, types);
+    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423, LSM6DS3, BMX160};
+    return firstOfOrNONE(5, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::find(ScanI2C::DeviceType) const

src/detect/ScanI2C.h

@@ -49,7 +49,9 @@ class ScanI2C
         OPT3001,
         MLX90632,
         AHT10,
+        BMX160,
         DFROBOT_LARK,
+        NAU7802
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;
@@ -86,6 +88,7 @@ class ScanI2C
     ScanI2C();
 
     virtual void scanPort(ScanI2C::I2CPort);
+    virtual void scanPort(ScanI2C::I2CPort, uint8_t *, uint8_t);
 
     /*
      * A bit of a hack, this tells the scanner not to tell later systems there is a screen to avoid enabling it.

src/detect/ScanI2CTwoWire.cpp

@@ -1,7 +1,8 @@
 #include "ScanI2CTwoWire.h"
 
+#if !MESHTASTIC_EXCLUDE_I2C
+
 #include "concurrency/LockGuard.h"
-#include "configuration.h"
 #if defined(ARCH_PORTDUINO)
 #include "linux/LinuxHardwareI2C.h"
 #endif
@@ -14,6 +15,15 @@
 #define XPOWERS_AXP192_AXP2101_ADDRESS 0x34
 #endif
 
+bool in_array(uint8_t *array, int size, uint8_t lookfor)
+{
+    int i;
+    for (i = 0; i < size; i++)
+        if (lookfor == array[i])
+            return true;
+    return false;
+}
+
 ScanI2C::FoundDevice ScanI2CTwoWire::find(ScanI2C::DeviceType type) const
 {
     concurrency::LockGuard guard((concurrency::Lock *)&lock);
@@ -135,11 +145,11 @@ uint16_t ScanI2CTwoWire::getRegisterValue(const ScanI2CTwoWire::RegisterLocation
         type = T;                                                                                                                \
         break;
 
-void ScanI2CTwoWire::scanPort(I2CPort port)
+void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 {
     concurrency::LockGuard guard((concurrency::Lock *)&lock);
 
-    LOG_DEBUG("Scanning for i2c devices on port %d\n", port);
+    LOG_DEBUG("Scanning for I2C devices on port %d\n", port);
 
     uint8_t err;
 
@@ -163,6 +173,11 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
 #endif
 
     for (addr.address = 1; addr.address < 127; addr.address++) {
+        if (asize != 0) {
+            if (!in_array(address, asize, addr.address))
+                continue;
+            LOG_DEBUG("Scanning address 0x%x\n", addr.address);
+        }
         i2cBus->beginTransmission(addr.address);
 #ifdef ARCH_PORTDUINO
         if (i2cBus->read() != -1)
@@ -300,7 +315,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
 
             case SHT31_4x_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
-                if (registerValue == 0x11a2) {
+                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0xe9c) {
                     type = SHT4X;
                     LOG_INFO("SHT4X sensor found\n");
                 } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
@@ -342,6 +357,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
 
                 SCAN_SIMPLE_CASE(PMSA0031_ADDR, PMSA0031, "PMSA0031 air quality sensor found\n")
                 SCAN_SIMPLE_CASE(MPU6050_ADDR, MPU6050, "MPU6050 accelerometer found\n");
+                SCAN_SIMPLE_CASE(BMX160_ADDR, BMX160, "BMX160 accelerometer found\n");
                 SCAN_SIMPLE_CASE(BMA423_ADDR, BMA423, "BMA423 accelerometer found\n");
                 SCAN_SIMPLE_CASE(LSM6DS3_ADDR, LSM6DS3, "LSM6DS3 accelerometer found at address 0x%x\n", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(TCA9555_ADDR, TCA9555, "TCA9555 I2C expander found\n");
@@ -349,12 +365,13 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
                 SCAN_SIMPLE_CASE(TSL25911_ADDR, TSL2591, "TSL2591 light sensor found\n");
                 SCAN_SIMPLE_CASE(OPT3001_ADDR, OPT3001, "OPT3001 light sensor found\n");
                 SCAN_SIMPLE_CASE(MLX90632_ADDR, MLX90632, "MLX90632 IR temp sensor found\n");
+                SCAN_SIMPLE_CASE(NAU7802_ADDR, NAU7802, "NAU7802 based scale found\n");
 
             default:
                 LOG_INFO("Device found at address 0x%x was not able to be enumerated\n", addr.address);
             }
         } else if (err == 4) {
-            LOG_ERROR("Unknown error at address 0x%x\n", addr);
+            LOG_ERROR("Unknown error at address 0x%x\n", addr.address);
         }
 
         // Check if a type was found for the enumerated device - save, if so
@@ -365,6 +382,11 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
     }
 }
 
+void ScanI2CTwoWire::scanPort(I2CPort port)
+{
+    scanPort(port, nullptr, 0);
+}
+
 TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address) const
 {
     if (address.port == ScanI2C::I2CPort::WIRE) {
@@ -382,3 +404,4 @@ size_t ScanI2CTwoWire::countDevices() const
 {
     return foundDevices.size();
 }
+#endif