add a .clang-format file (#9154)

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

.clang-format

@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+ColumnLimit: 150

.clusterfuzzlite/router_fuzzer.cpp

@@ -16,8 +16,7 @@
 #include "mesh/TypeConversions.h"
 #include "mesh/mesh-pb-constants.h"
 
-namespace
-{
+namespace {
 constexpr uint32_t nodeId = 0x12345678;
 // Set to true when lateInitVariant finishes. Used to ensure lateInitVariant was called during startup.
 bool hasBeenConfigured = false;
@@ -35,135 +34,130 @@ std::condition_variable loopCV;
 std::thread meshtasticThread;
 
 // This exception is thrown when the portuino main thread should exit.
-class ShouldExitException : public std::runtime_error
-{
-  public:
-    using std::runtime_error::runtime_error;
+class ShouldExitException : public std::runtime_error {
+public:
+  using std::runtime_error::runtime_error;
 };
 
 // Start the loop for one test case and wait till the loop has completed. This ensures fuzz
 // test cases do not overlap with one another. This helps the fuzzer attribute a crash to the
 // single, currently running, test case.
-void runLoopOnce()
-{
-    realHardware = true; // Avoids delay(100) within portduino/main.cpp
-    std::unique_lock<std::mutex> lck(loopLock);
-    fuzzerRunning = true;
-    loopCanRun = true;
-    loopCV.notify_one();
-    loopCV.wait(lck, [] { return !loopCanRun && loopIsWaiting; });
+void runLoopOnce() {
+  realHardware = true; // Avoids delay(100) within portduino/main.cpp
+  std::unique_lock<std::mutex> lck(loopLock);
+  fuzzerRunning = true;
+  loopCanRun = true;
+  loopCV.notify_one();
+  loopCV.wait(lck, [] { return !loopCanRun && loopIsWaiting; });
 }
 } // namespace
 
 // Called in the main Arduino loop function to determine if the loop can delay/sleep before running again.
 // We use this as a way to block the loop from sleeping and to start the loop function immediately when a
 // fuzzer input is ready.
-bool loopCanSleep()
-{
-    std::unique_lock<std::mutex> lck(loopLock);
-    loopIsWaiting = true;
-    loopCV.notify_one();
-    loopCV.wait(lck, [] { return loopCanRun || loopShouldExit; });
-    loopIsWaiting = false;
-    if (loopShouldExit)
-        throw ShouldExitException("exit");
-    if (!fuzzerRunning)
-        return true;    // The loop can sleep before the fuzzer starts.
-    loopCanRun = false; // Only run the loop once before waiting again.
-    return false;
+bool loopCanSleep() {
+  std::unique_lock<std::mutex> lck(loopLock);
+  loopIsWaiting = true;
+  loopCV.notify_one();
+  loopCV.wait(lck, [] { return loopCanRun || loopShouldExit; });
+  loopIsWaiting = false;
+  if (loopShouldExit)
+    throw ShouldExitException("exit");
+  if (!fuzzerRunning)
+    return true;      // The loop can sleep before the fuzzer starts.
+  loopCanRun = false; // Only run the loop once before waiting again.
+  return false;
 }
 
 // Called just prior to starting Meshtastic. Allows for setting config values before startup.
-void lateInitVariant()
-{
-    portduino_config.logoutputlevel = level_error;
-    channelFile.channels[0] = meshtastic_Channel{
-        .has_settings = true,
-        .settings =
-            meshtastic_ChannelSettings{
-                .psk = {.size = 1, .bytes = {/*defaultpskIndex=*/1}},
-                .name = "LongFast",
-                .uplink_enabled = true,
-                .has_module_settings = true,
-                .module_settings = {.position_precision = 16},
-            },
-        .role = meshtastic_Channel_Role_PRIMARY,
-    };
-    config.security.admin_key[0] = {
-        .size = 32,
-        .bytes = {0xcd, 0xc0, 0xb4, 0x3c, 0x53, 0x24, 0xdf, 0x13, 0xca, 0x5a, 0xa6, 0x0c, 0x0d, 0xec, 0x85, 0x5a,
-                  0x4c, 0xf6, 0x1a, 0x96, 0x04, 0x1a, 0x3e, 0xfc, 0xbb, 0x8e, 0x33, 0x71, 0xe5, 0xfc, 0xff, 0x3c},
-    };
-    config.security.admin_key_count = 1;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    moduleConfig.has_mqtt = true;
-    moduleConfig.mqtt = meshtastic_ModuleConfig_MQTTConfig{
-        .enabled = true,
-        .proxy_to_client_enabled = true,
-    };
-    moduleConfig.has_store_forward = true;
-    moduleConfig.store_forward = meshtastic_ModuleConfig_StoreForwardConfig{
-        .enabled = true,
-        .history_return_max = 4,
-        .history_return_window = 600,
-        .is_server = true,
-    };
-    meshtastic_Position fixedGPS = meshtastic_Position{
-        .has_latitude_i = true,
-        .latitude_i = static_cast<uint32_t>(1 * 1e7),
-        .has_longitude_i = true,
-        .longitude_i = static_cast<uint32_t>(3 * 1e7),
-        .has_altitude = true,
-        .altitude = 64,
-        .location_source = meshtastic_Position_LocSource_LOC_MANUAL,
-    };
-    nodeDB->setLocalPosition(fixedGPS);
-    config.has_position = true;
-    config.position.fixed_position = true;
-    meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    info->has_position = true;
-    info->position = TypeConversions::ConvertToPositionLite(fixedGPS);
-    hasBeenConfigured = true;
+void lateInitVariant() {
+  portduino_config.logoutputlevel = level_error;
+  channelFile.channels[0] = meshtastic_Channel{
+      .has_settings = true,
+      .settings =
+          meshtastic_ChannelSettings{
+              .psk = {.size = 1, .bytes = {/*defaultpskIndex=*/1}},
+              .name = "LongFast",
+              .uplink_enabled = true,
+              .has_module_settings = true,
+              .module_settings = {.position_precision = 16},
+          },
+      .role = meshtastic_Channel_Role_PRIMARY,
+  };
+  config.security.admin_key[0] = {
+      .size = 32,
+      .bytes = {0xcd, 0xc0, 0xb4, 0x3c, 0x53, 0x24, 0xdf, 0x13, 0xca, 0x5a, 0xa6, 0x0c, 0x0d, 0xec, 0x85, 0x5a,
+                0x4c, 0xf6, 0x1a, 0x96, 0x04, 0x1a, 0x3e, 0xfc, 0xbb, 0x8e, 0x33, 0x71, 0xe5, 0xfc, 0xff, 0x3c},
+  };
+  config.security.admin_key_count = 1;
+  config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
+  moduleConfig.has_mqtt = true;
+  moduleConfig.mqtt = meshtastic_ModuleConfig_MQTTConfig{
+      .enabled = true,
+      .proxy_to_client_enabled = true,
+  };
+  moduleConfig.has_store_forward = true;
+  moduleConfig.store_forward = meshtastic_ModuleConfig_StoreForwardConfig{
+      .enabled = true,
+      .history_return_max = 4,
+      .history_return_window = 600,
+      .is_server = true,
+  };
+  meshtastic_Position fixedGPS = meshtastic_Position{
+      .has_latitude_i = true,
+      .latitude_i = static_cast<uint32_t>(1 * 1e7),
+      .has_longitude_i = true,
+      .longitude_i = static_cast<uint32_t>(3 * 1e7),
+      .has_altitude = true,
+      .altitude = 64,
+      .location_source = meshtastic_Position_LocSource_LOC_MANUAL,
+  };
+  nodeDB->setLocalPosition(fixedGPS);
+  config.has_position = true;
+  config.position.fixed_position = true;
+  meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(nodeDB->getNodeNum());
+  info->has_position = true;
+  info->position = TypeConversions::ConvertToPositionLite(fixedGPS);
+  hasBeenConfigured = true;
 }
 
 extern "C" {
 int portduino_main(int argc, char **argv); // Renamed "main" function from Meshtastic binary.
 
 // Start Meshtastic in a thread and wait till it has reached the ON state.
-int LLVMFuzzerInitialize(int *argc, char ***argv)
-{
-    portduino_config.maxtophone = 5;
+int LLVMFuzzerInitialize(int *argc, char ***argv) {
+  portduino_config.maxtophone = 5;
 
-    meshtasticThread = std::thread([program = *argv[0]]() {
-        char nodeIdStr[12];
-        strcpy(nodeIdStr, std::to_string(nodeId).c_str());
-        int argc = 7;
-        char *argv[] = {program, "-d", "/tmp/meshtastic", "-h", nodeIdStr, "-p", "0", nullptr};
-        try {
-            portduino_main(argc, argv);
-        } catch (const ShouldExitException &) {
-        }
-    });
-    std::atexit([] {
-        {
-            const std::lock_guard<std::mutex> lck(loopLock);
-            loopShouldExit = true;
-            loopCV.notify_one();
-        }
-        meshtasticThread.join();
-    });
-
-    // Wait for startup.
-    for (int i = 1; i < 20; ++i) {
-        if (powerFSM.getState() == &stateON) {
-            assert(hasBeenConfigured);
-            assert(router);
-            assert(nodeDB);
-            return 0;
-        }
-        std::this_thread::sleep_for(std::chrono::seconds(1));
+  meshtasticThread = std::thread([program = *argv[0]]() {
+    char nodeIdStr[12];
+    strcpy(nodeIdStr, std::to_string(nodeId).c_str());
+    int argc = 7;
+    char *argv[] = {program, "-d", "/tmp/meshtastic", "-h", nodeIdStr, "-p", "0", nullptr};
+    try {
+      portduino_main(argc, argv);
+    } catch (const ShouldExitException &) {
     }
-    return 1;
+  });
+  std::atexit([] {
+    {
+      const std::lock_guard<std::mutex> lck(loopLock);
+      loopShouldExit = true;
+      loopCV.notify_one();
+    }
+    meshtasticThread.join();
+  });
+
+  // Wait for startup.
+  for (int i = 1; i < 20; ++i) {
+    if (powerFSM.getState() == &stateON) {
+      assert(hasBeenConfigured);
+      assert(router);
+      assert(nodeDB);
+      return 0;
+    }
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+  }
+  return 1;
 }
 
 // This is the main entrypoint for the fuzzer (the fuzz target). The fuzzer will provide an array of bytes to be
@@ -173,34 +167,33 @@ int LLVMFuzzerInitialize(int *argc, char ***argv)
 //
 // This guide provides best practices for writing a fuzzer target.
 // https://github.com/google/fuzzing/blob/master/docs/good-fuzz-target.md
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t length)
-{
-    meshtastic_MeshPacket p = meshtastic_MeshPacket_init_default;
-    pb_istream_t stream = pb_istream_from_buffer(data, length);
-    // Ignore any inputs that fail to decode or have fields set that are not transmitted over LoRa.
-    if (!pb_decode(&stream, &meshtastic_MeshPacket_msg, &p) || p.rx_time || p.rx_snr || p.priority || p.rx_rssi || p.delayed ||
-        p.public_key.size || p.next_hop || p.relay_node || p.tx_after)
-        return -1; // Reject: The input will not be added to the corpus.
-    if (p.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
-        meshtastic_Data d;
-        stream = pb_istream_from_buffer(p.decoded.payload.bytes, p.decoded.payload.size);
-        if (!pb_decode(&stream, &meshtastic_Data_msg, &d))
-            return -1; // Reject: The input will not be added to the corpus.
-    }
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t length) {
+  meshtastic_MeshPacket p = meshtastic_MeshPacket_init_default;
+  pb_istream_t stream = pb_istream_from_buffer(data, length);
+  // Ignore any inputs that fail to decode or have fields set that are not transmitted over LoRa.
+  if (!pb_decode(&stream, &meshtastic_MeshPacket_msg, &p) || p.rx_time || p.rx_snr || p.priority || p.rx_rssi || p.delayed || p.public_key.size ||
+      p.next_hop || p.relay_node || p.tx_after)
+    return -1; // Reject: The input will not be added to the corpus.
+  if (p.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+    meshtastic_Data d;
+    stream = pb_istream_from_buffer(p.decoded.payload.bytes, p.decoded.payload.size);
+    if (!pb_decode(&stream, &meshtastic_Data_msg, &d))
+      return -1; // Reject: The input will not be added to the corpus.
+  }
 
-    // Provide default values for a few fields so the fuzzer doesn't need to guess them.
-    if (p.from == 0)
-        p.from = nodeDB->getNodeNum();
-    if (p.to == 0)
-        p.to = nodeDB->getNodeNum();
-    static uint32_t packetId = 0;
-    if (p.id == 0)
-        p.id == ++packetId;
-    if (p.pki_encrypted && config.security.admin_key_count)
-        memcpy(&p.public_key, &config.security.admin_key[0], sizeof(p.public_key));
+  // Provide default values for a few fields so the fuzzer doesn't need to guess them.
+  if (p.from == 0)
+    p.from = nodeDB->getNodeNum();
+  if (p.to == 0)
+    p.to = nodeDB->getNodeNum();
+  static uint32_t packetId = 0;
+  if (p.id == 0)
+    p.id == ++packetId;
+  if (p.pki_encrypted && config.security.admin_key_count)
+    memcpy(&p.public_key, &config.security.admin_key[0], sizeof(p.public_key));
 
-    router->enqueueReceivedMessage(packetPool.allocCopy(p));
-    runLoopOnce();
-    return 0; // Accept: The input may be added to the corpus.
+  router->enqueueReceivedMessage(packetPool.allocCopy(p));
+  runLoopOnce();
+  return 0; // Accept: The input may be added to the corpus.
 }
 }

.github/actionlint.yaml

@@ -2,4 +2,5 @@
 self-hosted-runner:
   # Labels of self-hosted runner in array of strings.
   labels:
+    - arctastic
     - test-runner

.github/actions/build-variant/action.yml

@@ -76,7 +76,7 @@ runs:
         done
 
     - name: PlatformIO ${{ inputs.arch }} download cache
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ~/.platformio/.cache
         key: pio-cache-${{ inputs.arch }}-${{ hashFiles('.github/actions/**', '**.ini') }}
@@ -100,7 +100,7 @@ runs:
       id: version
 
     - name: Store binaries as an artifact
-      uses: actions/upload-artifact@v5
+      uses: actions/upload-artifact@v6
       with:
         name: firmware-${{ inputs.arch }}-${{ inputs.board }}-${{ steps.version.outputs.long }}
         overwrite: true

.github/workflows/build_debian_src.yml

@@ -64,7 +64,7 @@ jobs:
           PKG_VERSION: ${{ steps.version.outputs.deb }}
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           overwrite: true

.github/workflows/build_firmware.yml

@@ -18,9 +18,10 @@ permissions: read-all
 jobs:
   pio-build:
     name: build-${{ inputs.platform }}
-    runs-on: ubuntu-24.04
+    # Use 'arctastic' self-hosted runner pool when building in the main repo
+    runs-on: ${{ github.repository_owner == 'meshtastic' && 'arctastic' || 'ubuntu-latest' }}
     outputs:
-      artifact-id: ${{ steps.upload.outputs.artifact-id }}
+      artifact-id: ${{ steps.upload-firmware.outputs.artifact-id }}
     steps:
       - uses: actions/checkout@v6
         with:
@@ -55,20 +56,22 @@ jobs:
           ota_firmware_source: ${{ steps.ota_dir.outputs.src || '' }}
           ota_firmware_target: ${{ steps.ota_dir.outputs.tgt || '' }}
 
-      - name: Echo manifest from release/firmware-*.mt.json to job summary
-        if: ${{ always() }}
+      - name: Job summary
         env:
           PIO_ENV: ${{ inputs.pio_env }}
         run: |
-          echo "## Manifest: \`$PIO_ENV\`" >> $GITHUB_STEP_SUMMARY
+          echo "## $PIO_ENV" >> $GITHUB_STEP_SUMMARY
+          echo "<details><summary><strong>Manifest</strong></summary>" >> $GITHUB_STEP_SUMMARY
+          echo '' >> $GITHUB_STEP_SUMMARY
           echo '```json' >> $GITHUB_STEP_SUMMARY
           cat release/firmware-*.mt.json >> $GITHUB_STEP_SUMMARY
           echo '' >> $GITHUB_STEP_SUMMARY
           echo '```' >> $GITHUB_STEP_SUMMARY
+          echo "</details>" >> $GITHUB_STEP_SUMMARY
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
-        id: upload
+        uses: actions/upload-artifact@v6
+        id: upload-firmware
         with:
           name: firmware-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}
           overwrite: true
@@ -81,3 +84,12 @@ jobs:
             release/*.zip
             release/device-*.sh
             release/device-*.bat
+
+      - name: Store manifests as an artifact
+        uses: actions/upload-artifact@v6
+        id: upload-manifest
+        with:
+          name: manifest-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}
+          overwrite: true
+          path: |
+            release/*.mt.json

.github/workflows/build_one_target.yml

@@ -98,7 +98,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           path: ./
           pattern: firmware-*-*
@@ -111,7 +111,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: firmware-${{inputs.target}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -127,7 +127,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           pattern: firmware-*-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -146,7 +146,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
           overwrite: true

.github/workflows/first_time_contributor.yml

@@ -0,0 +1,47 @@
+name: Welcome First-Time Contributor
+
+on:
+  issues:
+    types: opened
+  pull_request_target:
+    types: opened
+
+permissions: {}
+
+jobs:
+  welcome:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write # Required to post comments and labels on issues
+      pull-requests: write # Required to post comments and labels on PRs
+    steps:
+      - uses: plbstl/first-contribution@v4
+        with:
+          labels: first-contribution
+          issue-opened-msg: |
+            ### @{fc-author}, Welcome to Meshtastic! :wave:
+
+            Thanks for opening your first issue. If it's helpful, an easy way
+            to get logs is the "Open Serial Monitor" button on the [Web Flasher](https://flasher.meshtastic.org).
+
+            If you have ideas for features, note that we often debate big ideas
+            in the [discussions tab](https://github.com/meshtastic/firmware/discussions/categories/ideas)
+            first. This tracker tends to be for ideas that have community
+            consensus and a clear implementation.
+
+            We're very active [on discord](https://discord.com/invite/meshtastic),
+            especially the \#firmware and \#alphanauts-testing channels. If you'll
+            be around for a while, we'd love to see you there!
+
+            Welcome to the community! :heart:
+
+          pr-opened-msg: |
+            ### @{fc-author}, Welcome to Meshtastic!
+
+            Thanks for opening your first pull request. We really appreciate it.
+
+            We discuss work as a team in discord, please join us in the [#firmware channel](https://discord.com/invite/meshtastic).
+            There's a big backlog of patches at the moment. If you have time,
+            please help us with some code review and testing of [other PRs](https://github.com/meshtastic/firmware/pulls)!
+
+            Welcome to the team :smile:

.github/workflows/main_matrix.yml

@@ -77,16 +77,21 @@ jobs:
       fail-fast: false
       matrix:
         check: ${{ fromJson(needs.setup.outputs.check) }}
-
-    runs-on: ubuntu-latest
+    # Use 'arctastic' self-hosted runner pool when checking in the main repo
+    runs-on: ${{ github.repository_owner == 'meshtastic' && 'arctastic' || 'ubuntu-latest' }}
     if: ${{ github.event_name != 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
     steps:
       - uses: actions/checkout@v6
-      - name: Build base
-        id: base
-        uses: ./.github/actions/setup-base
+        with:
+          submodules: recursive
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
       - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
+        uses: meshtastic/gh-action-firmware@main
+        with:
+          pio_platform: ${{ matrix.check.platform }}
+          pio_env: ${{ matrix.check.board }}
+          pio_target: check
 
   build:
     needs: [setup, version]
@@ -168,7 +173,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           path: ./
           pattern: firmware-${{matrix.arch}}-*
@@ -178,7 +183,7 @@ jobs:
         run: ls -R
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -195,7 +200,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -214,7 +219,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -228,6 +233,48 @@ jobs:
           description: "Download firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
           github-token: ${{ secrets.GITHUB_TOKEN }}
 
+  shame:
+    if: github.repository == 'meshtastic/firmware'
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v6
+        if: github.event_name == 'pull_request_target'
+        with:
+          filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
+          fetch-depth: 0
+      - name: Download the current manifests
+        uses: actions/download-artifact@v7
+        with:
+          path: ./manifests-new/
+          pattern: manifest-*
+          merge-multiple: true
+      - name: Upload combined manifests for later commit and global stats crunching.
+        uses: actions/upload-artifact@v6
+        id: upload-manifest
+        with:
+          name: manifests-${{ github.sha }}
+          overwrite: true
+          path: manifests-new/*.mt.json
+      - name: Find the merge base
+        if: github.event_name == 'pull_request_target'
+        run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
+        env:
+          base: ${{ github.base_ref }}
+          head: ${{ github.sha }}
+      # Currently broken (for-loop through EVERY artifact -- rate limiting)
+      # - name: Download the old manifests
+      #   if: github.event_name == 'pull_request_target'
+      #   run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
+      #   env:
+      #     GH_TOKEN: ${{ github.token }}
+      #     merge_base: ${{ env.MERGE_BASE }}
+      #     repo: ${{ github.repository }}
+      # - name: Do scan and post comment
+      #   if: github.event_name == 'pull_request_target'
+      #   run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
+
   release-artifacts:
     runs-on: ubuntu-latest
     if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
@@ -255,14 +302,14 @@ jobs:
             Autogenerated by github action, developer should edit as required before publishing...
 
       - name: Download source deb
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
           merge-multiple: true
           path: ./output/debian-src
 
       - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -286,7 +333,7 @@ jobs:
           }' > firmware-${{ needs.version.outputs.long }}.json
 
       - name: Save Release manifest artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: manifest-${{ needs.version.outputs.long }}
           overwrite: true
@@ -327,7 +374,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -344,7 +391,7 @@ jobs:
       - name: Zip firmware
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -383,14 +430,14 @@ jobs:
           python-version: 3.x
 
       - name: Get firmware artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
           merge-multiple: true
           path: ./publish
 
       - name: Get manifest artifact
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: manifest-${{ needs.version.outputs.long }}
           path: ./publish

.github/workflows/merge_queue.yml

@@ -147,7 +147,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           path: ./
           pattern: firmware-${{matrix.arch}}-*
@@ -160,7 +160,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -176,7 +176,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -195,7 +195,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -235,14 +235,14 @@ jobs:
             Autogenerated by github action, developer should edit as required before publishing...
 
       - name: Download source deb
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
           merge-multiple: true
           path: ./output/debian-src
 
       - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -292,7 +292,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -309,7 +309,7 @@ jobs:
       - name: Zip firmware
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -347,7 +347,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
           merge-multiple: true

.github/workflows/package_obs.yml

@@ -58,7 +58,7 @@ jobs:
         id: version
 
       - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           merge-multiple: true

.github/workflows/package_pio_deps.yml

@@ -56,7 +56,7 @@ jobs:
           PLATFORMIO_CORE_DIR: pio/core
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: platformio-deps-${{ inputs.pio_env }}-${{ steps.version.outputs.long }}
           overwrite: true

.github/workflows/package_ppa.yml

@@ -60,7 +60,7 @@ jobs:
         id: version
 
       - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           merge-multiple: true

.github/workflows/pr_tests.yml

@@ -50,7 +50,7 @@ jobs:
 
       - name: Download test artifacts
         if: needs.native-tests.result != 'skipped'
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}
           merge-multiple: true

.github/workflows/release_channels.yml

@@ -102,7 +102,7 @@ jobs:
           PIP_DISABLE_PIP_VERSION_CHECK: 1
 
       - name: Create Bumps pull request
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@v8
         with:
           base: ${{ github.event.repository.default_branch }}
           branch: create-pull-request/bump-version

.github/workflows/sec_sast_semgrep_cron.yml

@@ -33,7 +33,7 @@ jobs:
 
       # step 3
       - name: save report as pipeline artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: report.sarif
           overwrite: true

.github/workflows/test_native.yml

@@ -59,7 +59,7 @@ jobs:
         id: version
 
       - name: Save coverage information
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         if: always() # run this step even if previous step failed
         with:
           name: lcov-coverage-info-native-simulator-test-${{ steps.version.outputs.long }}
@@ -94,7 +94,7 @@ jobs:
 
       - name: Save test results
         if: always() # run this step even if previous step failed
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}
           overwrite: true
@@ -108,7 +108,7 @@ jobs:
           sed -i -e "s#${PWD}#.#" coverage_tests.info # Make paths relative.
 
       - name: Save coverage information
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         if: always() # run this step even if previous step failed
         with:
           name: lcov-coverage-info-native-platformio-tests-${{ steps.version.outputs.long }}
@@ -137,20 +137,20 @@ jobs:
         id: version
 
       - name: Download test artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}
           merge-multiple: true
 
       - name: Test Report
-        uses: dorny/test-reporter@v2.3.0
+        uses: dorny/test-reporter@v2.4.0
         with:
           name: PlatformIO Tests
           path: testreport.xml
           reporter: java-junit
 
       - name: Download coverage artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v7
         with:
           pattern: lcov-coverage-info-native-*-${{ steps.version.outputs.long }}
           path: code-coverage-report
@@ -163,7 +163,7 @@ jobs:
           genhtml --quiet --legend --prefix "${PWD}" code-coverage-report/coverage_src.info --output-directory code-coverage-report
 
       - name: Save Code Coverage Report
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: code-coverage-report-${{ steps.version.outputs.long }}
           path: code-coverage-report

.github/workflows/update_protobufs.yml

@@ -16,7 +16,7 @@ jobs:
           submodules: true
 
       - name: Update submodule
-        if: ${{ github.ref == 'refs/heads/master' }}
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' }}
         run: |
           git submodule update --remote protobufs
 
@@ -31,7 +31,7 @@ jobs:
           ./bin/regen-protos.sh
 
       - name: Create pull request
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@v8
         with:
           branch: create-pull-request/update-protobufs
           labels: submodules

.gitignore

@@ -41,3 +41,12 @@ src/mesh/raspihttp/private_key.pem
 
 # Ignore logo (set at build time with platformio-custom.py)
 data/boot/logo.*
+
+# pioarduino platform
+managed_components/*
+arduino-lib-builder*
+dependencies.lock
+idf_component.yml
+CMakeLists.txt
+sdkconfig.*
+.dummy/*

.trunk/trunk.yaml

@@ -8,25 +8,25 @@ plugins:
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.495
-    - renovate@42.30.4
+    - checkov@3.2.496
+    - renovate@42.66.14
     - prettier@3.7.4
-    - trufflehog@3.91.2
+    - trufflehog@3.92.4
     - yamllint@1.37.1
     - bandit@1.9.2
-    - trivy@0.67.2
+    - trivy@0.68.2
     - taplo@0.10.0
-    - ruff@0.14.7
+    - ruff@0.14.10
     - isort@7.0.0
-    - markdownlint@0.46.0
-    - oxipng@9.1.5
+    - markdownlint@0.47.0
+    - oxipng@10.0.0
     - svgo@4.0.0
     - actionlint@1.7.9
     - flake8@7.3.0
     - hadolint@2.14.0
     - shfmt@3.6.0
     - shellcheck@0.11.0
-    - black@25.11.0
+    - black@25.12.0
     - git-diff-check
     - gitleaks@8.30.0
     - clang-format@16.0.3

SECURITY.md

@@ -4,8 +4,8 @@
 
 | Firmware Version | Supported          |
 | ---------------- | ------------------ |
-| 2.6.x            | :white_check_mark: |
-| <= 2.5.x         | :x:                |
+| 2.7.x            | :white_check_mark: |
+| <= 2.6.x         | :x:                |
 
 ## Reporting a Vulnerability
 

bin/build-esp32.sh

@@ -22,7 +22,7 @@ export APP_VERSION=$VERSION
 
 basename=firmware-$1-$VERSION
 
-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v
 
 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf
 
@@ -32,20 +32,10 @@ cp $BUILDDIR/$basename.factory.bin $OUTDIR/$basename.factory.bin
 echo "Copying ESP32 update bin file"
 cp $BUILDDIR/$basename.bin $OUTDIR/$basename.bin
 
-echo "Building Filesystem for ESP32 targets"
-# If you want to build the webui, uncomment the following lines
-# pio run --environment $1 -t buildfs
-# cp .pio/build/$1/littlefs.bin $OUTDIR/littlefswebui-$1-$VERSION.bin
-# # Remove webserver files from the filesystem and rebuild
-# ls -l data/static # Diagnostic list of files
-# rm -rf data/static
-pio run --environment $1 -t buildfs --disable-auto-clean
+echo "Copying Filesystem for ESP32 targets"
 cp $BUILDDIR/littlefs-$1-$VERSION.bin $OUTDIR/littlefs-$1-$VERSION.bin
 cp bin/device-install.* $OUTDIR/
 cp bin/device-update.* $OUTDIR/
 
-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
+echo "Copying manifest"
 cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json

bin/build-nrf52.sh

@@ -21,13 +21,14 @@ rm -f $BUILDDIR/firmware*
 export APP_VERSION=$VERSION
 
 basename=firmware-$1-$VERSION
+ota_basename=${basename}-ota
 
-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v
 
 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf
 
 echo "Copying NRF52 dfu (OTA) file"
-cp $BUILDDIR/$basename.zip $OUTDIR/$basename.zip
+cp $BUILDDIR/$basename.zip $OUTDIR/$ota_basename.zip
 
 echo "Copying NRF52 UF2 file"
 cp $BUILDDIR/$basename.uf2 $OUTDIR/$basename.uf2
@@ -47,8 +48,5 @@ if (echo $1 | grep -q "rak4631"); then
 	cp $SRCHEX $OUTDIR/
 fi
 
-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
+echo "Copying manifest"
 cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json

bin/build-rp2xx0.sh

@@ -22,15 +22,12 @@ export APP_VERSION=$VERSION
 
 basename=firmware-$1-$VERSION
 
-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v
 
 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf
 
 echo "Copying uf2 file"
 cp $BUILDDIR/$basename.uf2 $OUTDIR/$basename.uf2
 
-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
+echo "Copying manifest"
 cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json

bin/build-stm32wl.sh

@@ -22,15 +22,12 @@ export APP_VERSION=$VERSION
 
 basename=firmware-$1-$VERSION
 
-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v
 
 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf
 
 echo "Copying STM32 bin file"
 cp $BUILDDIR/$basename.bin $OUTDIR/$basename.bin
 
-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
+echo "Copying manifest"
 cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json

bin/config-dist.yaml

@@ -184,6 +184,8 @@ Input:
 Logging:
   LogLevel: info # debug, info, warn, error
 #  TraceFile: /var/log/meshtasticd.json
+#  JSONFile: /packets.json # File location for JSON output of decoded packets
+#  JSONFilter: position # filter for packets to save to JSON file
 #  AsciiLogs: true     # default if not specified is !isatty() on stdout
 
 Webserver:

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,6 +87,9 @@
   </screenshots>
 
   <releases>
+    <release version="2.7.18" date="2026-01-02">
+      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.18</url>
+    </release>
     <release version="2.7.17" date="2025-11-28">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.17</url>
     </release>

bin/platformio-custom.py

@@ -17,6 +17,8 @@ lfsbin = f"{progname.replace('firmware-', 'littlefs-')}.bin"
 
 def manifest_gather(source, target, env):
     out = []
+    board_platform = env.BoardConfig().get("platform")
+    needs_ota_suffix = board_platform == "nordicnrf52"
     check_paths = [
         progname,
         f"{progname}.elf",
@@ -32,8 +34,11 @@ def manifest_gather(source, target, env):
     for p in check_paths:
         f = env.File(env.subst(f"$BUILD_DIR/{p}"))
         if f.exists():
+            manifest_name = p
+            if needs_ota_suffix and p == f"{progname}.zip":
+                manifest_name = f"{progname}-ota.zip"
             d = {
-                "name": p,
+                "name": manifest_name,
                 "md5": f.get_content_hash(), # Returns MD5 hash
                 "bytes": f.get_size() # Returns file size in bytes
             }
@@ -159,20 +164,22 @@ def load_boot_logo(source, target, env):
 
 # Load the boot logo on TFT builds
 if ("HAS_TFT", 1) in env.get("CPPDEFINES", []):
-    env.AddPreAction('$BUILD_DIR/littlefs.bin', load_boot_logo)
+    env.AddPreAction(f"$BUILD_DIR/{lfsbin}", load_boot_logo)
 
-# Rename (mv) littlefs.bin to include the PROGNAME
-# This ensures the littlefs.bin is named consistently with the firmware
-env.AddPostAction('$BUILD_DIR/littlefs.bin', env.VerboseAction(
-    f'mv $BUILD_DIR/littlefs.bin $BUILD_DIR/{lfsbin}',
-    f'Renaming littlefs.bin to {lfsbin}'
-))
+mtjson_deps = ["buildprog"]
+if platform.name == "espressif32":
+    # Build littlefs image as part of mtjson target
+    # Equivalent to `pio run -t buildfs`
+    target_lfs = env.DataToBin(
+        join("$BUILD_DIR", "${ESP32_FS_IMAGE_NAME}"), "$PROJECT_DATA_DIR"
+    )
+    mtjson_deps.append(target_lfs)
 
 env.AddCustomTarget(
     name="mtjson",
-    dependencies=None,
+    dependencies=mtjson_deps,
     actions=[manifest_gather],
     title="Meshtastic Manifest",
     description="Generating Meshtastic manifest JSON + Checksums",
-    always_build=True,
+    always_build=False,
 )

bin/platformio-pre.py

@@ -11,6 +11,9 @@ else:
     prefsLoc = env["PROJECT_DIR"] + "/version.properties"
     verObj = readProps(prefsLoc)
     env.Replace(PROGNAME=f"firmware-{env.get('PIOENV')}-{verObj['long']}")
+    env.Replace(ESP32_FS_IMAGE_NAME=f"littlefs-{env.get('PIOENV')}-{verObj['long']}")
 
 # Print the new program name for verification
 print(f"PROGNAME: {env.get('PROGNAME')}")
+if platform.name == "espressif32":
+    print(f"ESP32_FS_IMAGE_NAME: {env.get('ESP32_FS_IMAGE_NAME')}")

bin/shame.py

@@ -0,0 +1,95 @@
+import sys
+import os
+import json
+from github import Github
+
+def parseFile(path):
+    with open(path, "r") as f:
+        data = json.loads(f)
+    for file in data["files"]:
+        if file["name"].endswith(".bin"):
+            return file["name"], file["bytes"]
+
+if len(sys.argv) != 4:
+    print(f"expected usage: {sys.argv[0]} <PR number> <path to old-manifests> <path to new-manifests>")
+    sys.exit(1)
+
+pr_number = int(sys.argv[1])
+
+token = os.getenv("GITHUB_TOKEN")
+if not token:
+    raise EnvironmentError("GITHUB_TOKEN not found in environment.")
+
+repo_name = os.getenv("GITHUB_REPOSITORY")  # "owner/repo"
+if not repo_name:
+    raise EnvironmentError("GITHUB_REPOSITORY not found in environment.")
+
+oldFiles = sys.argv[2]
+old = set(os.path.join(oldFiles, f) for f in os.listdir(oldFiles) if os.path.isfile(f))
+newFiles = sys.argv[3]
+new = set(os.path.join(newFiles, f) for f in os.listdir(newFiles) if os.path.isfile(f))
+
+startMarkdown = "# Target Size Changes\n\n"
+markdown = ""
+
+newlyIntroduced = new - old
+if len(newlyIntroduced) > 0:
+    markdown += "## Newly Introduced Targets\n\n"
+    # create a table
+    markdown += "| File | Size |\n"
+    markdown += "| ---- | ---- |\n"
+    for f in newlyIntroduced:
+        name, size = parseFile(f)
+        markdown += f"| `{name}` | {size}b |\n"
+
+# do not log removed targets
+# PRs only run a small subset of builds, so removed targets are not meaningful
+# since they are very likely to just be not ran in PR CI
+
+both = old & new
+degradations = []
+improvements = []
+for f in both:
+    oldName, oldSize = parseFile(f)
+    _, newSize = parseFile(f)
+    if oldSize != newSize:
+        if newSize < oldSize:
+            improvements.append((oldName, oldSize, newSize))
+        else:
+            degradations.append((oldName, oldSize, newSize))
+
+if len(degradations) > 0:
+    markdown += "\n## Degradation\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in degradations:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(improvements) > 0:
+    markdown += "\n## Improvement\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in improvements:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(markdown) == 0:
+    markdown = "No changes in target sizes detected."
+
+g = Github(token)
+repo = g.get_repo(repo_name)
+pr = repo.get_pull(pr_number)
+
+existing_comment = None
+for comment in pr.get_issue_comments():
+    if comment.body.startswith(startMarkdown):
+        existing_comment = comment
+        break
+
+final_markdown = startMarkdown + markdown
+
+if existing_comment:
+    existing_comment.edit(body=final_markdown)
+else:
+    pr.create_issue_comment(body=final_markdown)

debian/changelog

@@ -1,3 +1,9 @@
+meshtasticd (2.7.18.0) unstable; urgency=medium
+
+  * Version 2.7.18
+
+ -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Fri, 02 Jan 2026 12:45:36 +0000
+
 meshtasticd (2.7.17.0) unstable; urgency=medium
 
   * Version 2.7.17

extra_scripts/esp32_extra.py

@@ -10,6 +10,12 @@ Import("env")
 platform = env.PioPlatform()
 
 sys.path.append(join(platform.get_package_dir("tool-esptoolpy")))
+# IntelHex workaround, remove after fixed upstream
+# https://github.com/platformio/platform-espressif32/issues/1632
+try:
+    import intelhex
+except ImportError:
+    env.Execute("$PYTHONEXE -m pip install intelhex")
 import esptool
 
 

platformio.ini

@@ -64,7 +64,7 @@ monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/2887bf4a19f64d92c984dcc8fd5ca7429e425e4a.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/b34c6817c25d6faabb3a8a162b5d14fb75395433.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -103,17 +103,13 @@ lib_deps =
 	thingsboard/TBPubSubClient@2.12.1
 	# renovate: datasource=custom.pio depName=NTPClient packageName=arduino-libraries/library/NTPClient
 	arduino-libraries/NTPClient@3.2.1
+
+; Extra TCP/IP networking libs for supported devices
+[networking_extra]
+lib_deps =
 	# renovate: datasource=custom.pio depName=Syslog packageName=arcao/library/Syslog
 	arcao/Syslog@2.0.0
 
-; Minimal networking libs for nrf52 (excludes Syslog to save flash)
-[nrf52_networking_base]
-lib_deps =
-	# renovate: datasource=custom.pio depName=TBPubSubClient packageName=thingsboard/library/TBPubSubClient
-	thingsboard/TBPubSubClient@2.12.1
-	# renovate: datasource=custom.pio depName=NTPClient packageName=arduino-libraries/library/NTPClient
-	arduino-libraries/NTPClient@3.2.1
-
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=RadioLib packageName=jgromes/library/RadioLib
@@ -123,7 +119,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/4fb5f24787caa841b58dbf623a52c4c5861d6722.zip
+	https://github.com/meshtastic/device-ui/archive/a8e2f947f7abaf0c5ac8e6dd189a22156335beaa.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -162,8 +158,8 @@ lib_deps =
 	emotibit/EmotiBit MLX90632@1.0.8
 	# renovate: datasource=custom.pio depName=Adafruit MLX90614 packageName=adafruit/library/Adafruit MLX90614 Library
 	adafruit/Adafruit MLX90614 Library@2.1.5
-	# renovate: datasource=github-tags depName=INA3221 packageName=sgtwilko/INA3221
-	https://github.com/sgtwilko/INA3221#bb03d7e9bfcc74fc798838a54f4f99738f29fc6a
+	# renovate: datasource=git-refs depName=INA3221 packageName=https://github.com/sgtwilko/INA3221 gitBranch=FixOverflow
+	https://github.com/sgtwilko/INA3221/archive/bb03d7e9bfcc74fc798838a54f4f99738f29fc6a.zip
 	# renovate: datasource=custom.pio depName=QMC5883L Compass packageName=mprograms/library/QMC5883LCompass
 	mprograms/QMC5883LCompass@1.2.3
 	# renovate: datasource=custom.pio depName=DFRobot_RTU packageName=dfrobot/library/DFRobot_RTU
@@ -207,7 +203,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=SparkFun Qwiic Scale NAU7802 packageName=sparkfun/library/SparkFun Qwiic Scale NAU7802 Arduino Library
 	sparkfun/SparkFun Qwiic Scale NAU7802 Arduino Library@1.0.6
 	# renovate: datasource=custom.pio depName=ClosedCube OPT3001 packageName=closedcube/library/ClosedCube OPT3001
-	ClosedCube OPT3001@1.1.2
+	closedcube/ClosedCube OPT3001@1.1.2
 	# renovate: datasource=custom.pio depName=Bosch BSEC2 packageName=boschsensortec/library/bsec2
 	boschsensortec/bsec2@1.10.2610
 	# renovate: datasource=custom.pio depName=Bosch BME68x packageName=boschsensortec/library/BME68x Sensor Library

src/AmbientLightingThread.h

@@ -21,192 +21,183 @@ Adafruit_NeoPixel pixels(NEOPIXEL_COUNT, NEOPIXEL_DATA, NEOPIXEL_TYPE);
 extern unPhone unphone;
 #endif
 
-namespace concurrency
-{
-class AmbientLightingThread : public concurrency::OSThread
-{
-  public:
-    explicit AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLighting")
-    {
-        notifyDeepSleepObserver.observe(&notifyDeepSleep); // Let us know when shutdown() is issued.
+namespace concurrency {
+class AmbientLightingThread : public concurrency::OSThread {
+public:
+  explicit AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLighting") {
+    notifyDeepSleepObserver.observe(&notifyDeepSleep); // Let us know when shutdown() is issued.
 
 // Enables Ambient Lighting by default if conditions are meet.
 #ifdef HAS_RGB_LED
 #ifdef ENABLE_AMBIENTLIGHTING
-        moduleConfig.ambient_lighting.led_state = true;
+    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
-        // 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;
+    // Uncomment to test module
+    // moduleConfig.ambient_lighting.led_state = true;
+    // moduleConfig.ambient_lighting.current = 10;
+    // 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;
 
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
-        _type = type;
-        if (_type == ScanI2C::DeviceType::NONE) {
-            LOG_DEBUG("AmbientLighting Disable due to no RGB leds found on I2C bus");
-            disable();
-            return;
-        }
+    _type = type;
+    if (_type == ScanI2C::DeviceType::NONE) {
+      LOG_DEBUG("AmbientLighting Disable due to no RGB leds found on I2C bus");
+      disable();
+      return;
+    }
 #endif
 #ifdef HAS_RGB_LED
-        if (!moduleConfig.ambient_lighting.led_state) {
-            LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF");
-            disable();
-            return;
-        }
-        LOG_DEBUG("AmbientLighting init");
+    if (!moduleConfig.ambient_lighting.led_state) {
+      LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF");
+      disable();
+      return;
+    }
+    LOG_DEBUG("AmbientLighting init");
 #ifdef HAS_NCP5623
-        if (_type == ScanI2C::NCP5623) {
-            rgb.begin();
+    if (_type == ScanI2C::NCP5623) {
+      rgb.begin();
 #endif
 #ifdef HAS_LP5562
-            if (_type == ScanI2C::LP5562) {
-                rgbw.begin();
+      if (_type == ScanI2C::LP5562) {
+        rgbw.begin();
 #endif
 #ifdef RGBLED_RED
-                pinMode(RGBLED_RED, OUTPUT);
-                pinMode(RGBLED_GREEN, OUTPUT);
-                pinMode(RGBLED_BLUE, OUTPUT);
+        pinMode(RGBLED_RED, OUTPUT);
+        pinMode(RGBLED_GREEN, OUTPUT);
+        pinMode(RGBLED_BLUE, OUTPUT);
 #endif
 #ifdef HAS_NEOPIXEL
-                pixels.begin(); // Initialise the pixel(s)
-                pixels.clear(); // Set all pixel colors to 'off'
-                pixels.setBrightness(moduleConfig.ambient_lighting.current);
+        pixels.begin(); // Initialise the pixel(s)
+        pixels.clear(); // Set all pixel colors to 'off'
+        pixels.setBrightness(moduleConfig.ambient_lighting.current);
 #endif
-                setLighting();
+        setLighting();
 #endif
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
-            }
+      }
 #endif
-        }
+    }
 
-      protected:
-        int32_t runOnce() override
-        {
+  protected:
+    int32_t runOnce() override {
 #ifdef HAS_RGB_LED
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
-            if ((_type == ScanI2C::NCP5623 || _type == ScanI2C::LP5562) && moduleConfig.ambient_lighting.led_state) {
+      if ((_type == ScanI2C::NCP5623 || _type == ScanI2C::LP5562) && moduleConfig.ambient_lighting.led_state) {
 #endif
-                setLighting();
-                return 30000; // 30 seconds to reset from any animations that may have been running from Ext. Notification
+        setLighting();
+        return 30000; // 30 seconds to reset from any animations that may have been running from Ext. Notification
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
-            }
+      }
 #endif
 #endif
-            return disable();
-        }
+      return disable();
+    }
 
-        // When shutdown() is issued, setLightingOff will be called.
-        CallbackObserver<AmbientLightingThread, void *> notifyDeepSleepObserver =
-            CallbackObserver<AmbientLightingThread, void *>(this, &AmbientLightingThread::setLightingOff);
+    // 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;
+  private:
+    ScanI2C::DeviceType _type = ScanI2C::DeviceType::NONE;
 
-        // Turn RGB lighting off, is used in junction to shutdown()
-        int setLightingOff(void *unused)
-        {
+    // 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("OFF: NCP5623 Ambient lighting");
+      rgb.setCurrent(0);
+      rgb.setRed(0);
+      rgb.setGreen(0);
+      rgb.setBlue(0);
+      LOG_INFO("OFF: NCP5623 Ambient lighting");
 #endif
 #ifdef HAS_LP5562
-            rgbw.setCurrent(0);
-            rgbw.setRed(0);
-            rgbw.setGreen(0);
-            rgbw.setBlue(0);
-            rgbw.setWhite(0);
-            LOG_INFO("OFF: LP5562 Ambient lighting");
+      rgbw.setCurrent(0);
+      rgbw.setRed(0);
+      rgbw.setGreen(0);
+      rgbw.setBlue(0);
+      rgbw.setWhite(0);
+      LOG_INFO("OFF: LP5562 Ambient lighting");
 #endif
 #ifdef HAS_NEOPIXEL
-            pixels.clear();
-            pixels.show();
-            LOG_INFO("OFF: NeoPixel Ambient lighting");
+      pixels.clear();
+      pixels.show();
+      LOG_INFO("OFF: NeoPixel Ambient lighting");
 #endif
 #ifdef RGBLED_CA
-            analogWrite(RGBLED_RED, 255 - 0);
-            analogWrite(RGBLED_GREEN, 255 - 0);
-            analogWrite(RGBLED_BLUE, 255 - 0);
-            LOG_INFO("OFF: Ambient light RGB Common Anode");
+      analogWrite(RGBLED_RED, 255 - 0);
+      analogWrite(RGBLED_GREEN, 255 - 0);
+      analogWrite(RGBLED_BLUE, 255 - 0);
+      LOG_INFO("OFF: Ambient light RGB Common Anode");
 #elif defined(RGBLED_RED)
-        analogWrite(RGBLED_RED, 0);
-        analogWrite(RGBLED_GREEN, 0);
-        analogWrite(RGBLED_BLUE, 0);
-        LOG_INFO("OFF: Ambient light RGB Common Cathode");
+    analogWrite(RGBLED_RED, 0);
+    analogWrite(RGBLED_GREEN, 0);
+    analogWrite(RGBLED_BLUE, 0);
+    LOG_INFO("OFF: Ambient light RGB Common Cathode");
 #endif
 #ifdef UNPHONE
-            unphone.rgb(0, 0, 0);
-            LOG_INFO("OFF: unPhone Ambient lighting");
+      unphone.rgb(0, 0, 0);
+      LOG_INFO("OFF: unPhone Ambient lighting");
 #endif
-            return 0;
-        }
+      return 0;
+    }
 
-        void setLighting()
-        {
+    void setLighting() {
 #ifdef HAS_NCP5623
-            rgb.setCurrent(moduleConfig.ambient_lighting.current);
-            rgb.setRed(moduleConfig.ambient_lighting.red);
-            rgb.setGreen(moduleConfig.ambient_lighting.green);
-            rgb.setBlue(moduleConfig.ambient_lighting.blue);
-            LOG_DEBUG("Init NCP5623 Ambient light w/ current=%d, red=%d, green=%d, blue=%d",
-                      moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+      rgb.setCurrent(moduleConfig.ambient_lighting.current);
+      rgb.setRed(moduleConfig.ambient_lighting.red);
+      rgb.setGreen(moduleConfig.ambient_lighting.green);
+      rgb.setBlue(moduleConfig.ambient_lighting.blue);
+      LOG_DEBUG("Init NCP5623 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.current,
+                moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef HAS_LP5562
-            rgbw.setCurrent(moduleConfig.ambient_lighting.current);
-            rgbw.setRed(moduleConfig.ambient_lighting.red);
-            rgbw.setGreen(moduleConfig.ambient_lighting.green);
-            rgbw.setBlue(moduleConfig.ambient_lighting.blue);
-            LOG_DEBUG("Init LP5562 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.current,
-                      moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+      rgbw.setCurrent(moduleConfig.ambient_lighting.current);
+      rgbw.setRed(moduleConfig.ambient_lighting.red);
+      rgbw.setGreen(moduleConfig.ambient_lighting.green);
+      rgbw.setBlue(moduleConfig.ambient_lighting.blue);
+      LOG_DEBUG("Init LP5562 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.current,
+                moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef HAS_NEOPIXEL
-            pixels.fill(pixels.Color(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
-                                     moduleConfig.ambient_lighting.blue),
-                        0, NEOPIXEL_COUNT);
+      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);
+      pixels.fill(BUTTON1_COLOR, BUTTON1_COLOR_INDEX, 1);
 #endif
 #if defined(BUTTON2_COLOR) && defined(BUTTON2_COLOR_INDEX)
-            pixels.fill(BUTTON2_COLOR, BUTTON2_COLOR_INDEX, 1);
+      pixels.fill(BUTTON2_COLOR, BUTTON2_COLOR_INDEX, 1);
 #endif
 #endif
-            pixels.show();
-            // LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%d, red=%d, green=%d, blue=%d",
-            //        moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-            //        moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+      pixels.show();
+      // LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%d, red=%d, green=%d, blue=%d",
+      //        moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
+      //        moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef RGBLED_CA
-            analogWrite(RGBLED_RED, 255 - moduleConfig.ambient_lighting.red);
-            analogWrite(RGBLED_GREEN, 255 - moduleConfig.ambient_lighting.green);
-            analogWrite(RGBLED_BLUE, 255 - moduleConfig.ambient_lighting.blue);
-            LOG_DEBUG("Init Ambient light RGB Common Anode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
-                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+      analogWrite(RGBLED_RED, 255 - moduleConfig.ambient_lighting.red);
+      analogWrite(RGBLED_GREEN, 255 - moduleConfig.ambient_lighting.green);
+      analogWrite(RGBLED_BLUE, 255 - moduleConfig.ambient_lighting.blue);
+      LOG_DEBUG("Init Ambient light RGB Common Anode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #elif defined(RGBLED_RED)
-        analogWrite(RGBLED_RED, moduleConfig.ambient_lighting.red);
-        analogWrite(RGBLED_GREEN, moduleConfig.ambient_lighting.green);
-        analogWrite(RGBLED_BLUE, moduleConfig.ambient_lighting.blue);
-        LOG_DEBUG("Init Ambient light RGB Common Cathode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
-                  moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+    analogWrite(RGBLED_RED, moduleConfig.ambient_lighting.red);
+    analogWrite(RGBLED_GREEN, moduleConfig.ambient_lighting.green);
+    analogWrite(RGBLED_BLUE, moduleConfig.ambient_lighting.blue);
+    LOG_DEBUG("Init Ambient light RGB Common Cathode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+              moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef UNPHONE
-            unphone.rgb(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
-                        moduleConfig.ambient_lighting.blue);
-            LOG_DEBUG("Init unPhone Ambient light w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
-                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+      unphone.rgb(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+      LOG_DEBUG("Init unPhone Ambient light w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                moduleConfig.ambient_lighting.blue);
 #endif
-        }
-    };
+    }
+  };
 
 } // namespace concurrency

src/AudioThread.h

@@ -18,93 +18,86 @@ extern ExtensionIOXL9555 io;
 
 #define AUDIO_THREAD_INTERVAL_MS 100
 
-class AudioThread : public concurrency::OSThread
-{
-  public:
-    AudioThread() : OSThread("Audio") { initOutput(); }
+class AudioThread : public concurrency::OSThread {
+public:
+  AudioThread() : OSThread("Audio") { initOutput(); }
 
-    void beginRttl(const void *data, uint32_t len)
-    {
+  void beginRttl(const void *data, uint32_t len) {
 #ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, HIGH);
+    io.digitalWrite(EXPANDS_AMP_EN, HIGH);
 #endif
-        setCPUFast(true);
-        rtttlFile = new AudioFileSourcePROGMEM(data, len);
-        i2sRtttl = new AudioGeneratorRTTTL();
-        i2sRtttl->begin(rtttlFile, audioOut);
+    setCPUFast(true);
+    rtttlFile = new AudioFileSourcePROGMEM(data, len);
+    i2sRtttl = new AudioGeneratorRTTTL();
+    i2sRtttl->begin(rtttlFile, audioOut);
+  }
+
+  // Also handles actually playing the RTTTL, needs to be called in loop
+  bool isPlaying() {
+    if (i2sRtttl != nullptr) {
+      return i2sRtttl->isRunning() && i2sRtttl->loop();
+    }
+    return false;
+  }
+
+  void stop() {
+    if (i2sRtttl != nullptr) {
+      i2sRtttl->stop();
+      delete i2sRtttl;
+      i2sRtttl = nullptr;
     }
 
-    // Also handles actually playing the RTTTL, needs to be called in loop
-    bool isPlaying()
-    {
-        if (i2sRtttl != nullptr) {
-            return i2sRtttl->isRunning() && i2sRtttl->loop();
-        }
-        return false;
+    if (rtttlFile != nullptr) {
+      delete rtttlFile;
+      rtttlFile = nullptr;
     }
 
-    void stop()
-    {
-        if (i2sRtttl != nullptr) {
-            i2sRtttl->stop();
-            delete i2sRtttl;
-            i2sRtttl = nullptr;
-        }
-
-        if (rtttlFile != nullptr) {
-            delete rtttlFile;
-            rtttlFile = nullptr;
-        }
-
-        setCPUFast(false);
+    setCPUFast(false);
 #ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, LOW);
+    io.digitalWrite(EXPANDS_AMP_EN, LOW);
 #endif
-    }
+  }
 
-    void readAloud(const char *text)
-    {
-        if (i2sRtttl != nullptr) {
-            i2sRtttl->stop();
-            delete i2sRtttl;
-            i2sRtttl = nullptr;
-        }
+  void readAloud(const char *text) {
+    if (i2sRtttl != nullptr) {
+      i2sRtttl->stop();
+      delete i2sRtttl;
+      i2sRtttl = nullptr;
+    }
 
 #ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, HIGH);
+    io.digitalWrite(EXPANDS_AMP_EN, HIGH);
 #endif
-        ESP8266SAM *sam = new ESP8266SAM;
-        sam->Say(audioOut, text);
-        delete sam;
-        setCPUFast(false);
+    ESP8266SAM *sam = new ESP8266SAM;
+    sam->Say(audioOut, text);
+    delete sam;
+    setCPUFast(false);
 #ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, LOW);
+    io.digitalWrite(EXPANDS_AMP_EN, LOW);
 #endif
-    }
+  }
 
-  protected:
-    int32_t runOnce() override
-    {
-        canSleep = true; // Assume we should not keep the board awake
+protected:
+  int32_t runOnce() override {
+    canSleep = true; // Assume we should not keep the board awake
 
-        // if (i2sRtttl != nullptr && i2sRtttl->isRunning()) {
-        //     i2sRtttl->loop();
-        // }
-        return AUDIO_THREAD_INTERVAL_MS;
-    }
+    // if (i2sRtttl != nullptr && i2sRtttl->isRunning()) {
+    //     i2sRtttl->loop();
+    // }
+    return AUDIO_THREAD_INTERVAL_MS;
+  }
 
-  private:
-    void initOutput()
-    {
-        audioOut = new AudioOutputI2S(1, AudioOutputI2S::EXTERNAL_I2S);
-        audioOut->SetPinout(DAC_I2S_BCK, DAC_I2S_WS, DAC_I2S_DOUT, DAC_I2S_MCLK);
-        audioOut->SetGain(0.2);
-    };
+private:
+  void initOutput() {
+    audioOut = new AudioOutputI2S(1, AudioOutputI2S::EXTERNAL_I2S);
+    audioOut->SetPinout(DAC_I2S_BCK, DAC_I2S_WS, DAC_I2S_DOUT, DAC_I2S_MCLK);
+    audioOut->SetGain(0.2);
+  };
 
-    AudioGeneratorRTTTL *i2sRtttl = nullptr;
-    AudioOutputI2S *audioOut = nullptr;
+  AudioGeneratorRTTTL *i2sRtttl = nullptr;
+  AudioOutputI2S *audioOut = nullptr;
 
-    AudioFileSourcePROGMEM *rtttlFile = nullptr;
+  AudioFileSourcePROGMEM *rtttlFile = nullptr;
 };
 
 #endif

src/BluetoothCommon.cpp

@@ -3,15 +3,9 @@
 
 // NRF52 wants these constants as byte arrays
 // Generated here https://yupana-engineering.com/online-uuid-to-c-array-converter - but in REVERSE BYTE ORDER
-const uint8_t MESH_SERVICE_UUID_16[16u] = {0xfd, 0xea, 0x73, 0xe2, 0xca, 0x5d, 0xa8, 0x9f,
-                                           0x1f, 0x46, 0xa8, 0x15, 0x18, 0xb2, 0xa1, 0x6b};
-const uint8_t TORADIO_UUID_16[16u] = {0xe7, 0x01, 0x44, 0x12, 0x66, 0x78, 0xdd, 0xa1,
-                                      0xad, 0x4d, 0x9e, 0x12, 0xd2, 0x76, 0x5c, 0xf7};
-const uint8_t FROMRADIO_UUID_16[16u] = {0x02, 0x00, 0x12, 0xac, 0x42, 0x02, 0x78, 0xb8,
-                                        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};
+const uint8_t MESH_SERVICE_UUID_16[16u] = {0xfd, 0xea, 0x73, 0xe2, 0xca, 0x5d, 0xa8, 0x9f, 0x1f, 0x46, 0xa8, 0x15, 0x18, 0xb2, 0xa1, 0x6b};
+const uint8_t TORADIO_UUID_16[16u] = {0xe7, 0x01, 0x44, 0x12, 0x66, 0x78, 0xdd, 0xa1, 0xad, 0x4d, 0x9e, 0x12, 0xd2, 0x76, 0x5c, 0xf7};
+const uint8_t FROMRADIO_UUID_16[16u] = {0x02, 0x00, 0x12, 0xac, 0x42, 0x02, 0x78, 0xb8, 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

@@ -21,12 +21,11 @@ extern const uint8_t MESH_SERVICE_UUID_16[], TORADIO_UUID_16[16u], FROMRADIO_UUI
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level);
 
-class BluetoothApi
-{
-  public:
-    virtual void setup();
-    virtual void shutdown();
-    virtual void clearBonds();
-    virtual bool isConnected();
-    virtual int getRssi() = 0;
+class BluetoothApi {
+public:
+  virtual void setup();
+  virtual void shutdown();
+  virtual void clearBonds();
+  virtual bool isConnected();
+  virtual int getRssi() = 0;
 };

src/BluetoothStatus.h

@@ -5,113 +5,106 @@
 #include "meshUtils.h"
 #include <Arduino.h>
 
-namespace meshtastic
-{
+namespace meshtastic {
 
 // Describes the state of the Bluetooth connection
 // Allows display to handle pairing events without each UI needing to explicitly hook the Bluefruit / NimBLE code
-class BluetoothStatus : public Status
-{
-  public:
-    enum class ConnectionState {
-        DISCONNECTED,
-        PAIRING,
-        CONNECTED,
-    };
+class BluetoothStatus : public Status {
+public:
+  enum class ConnectionState {
+    DISCONNECTED,
+    PAIRING,
+    CONNECTED,
+  };
 
-  private:
-    CallbackObserver<BluetoothStatus, const BluetoothStatus *> statusObserver =
-        CallbackObserver<BluetoothStatus, const BluetoothStatus *>(this, &BluetoothStatus::updateStatus);
+private:
+  CallbackObserver<BluetoothStatus, const BluetoothStatus *> statusObserver =
+      CallbackObserver<BluetoothStatus, const BluetoothStatus *>(this, &BluetoothStatus::updateStatus);
 
-    ConnectionState state = ConnectionState::DISCONNECTED;
-    std::string passkey; // Stored as string, because Bluefruit allows passkeys with a leading zero
+  ConnectionState state = ConnectionState::DISCONNECTED;
+  std::string passkey; // Stored as string, because Bluefruit allows passkeys with a leading zero
 
-  public:
-    BluetoothStatus() { statusType = STATUS_TYPE_BLUETOOTH; }
+public:
+  BluetoothStatus() { statusType = STATUS_TYPE_BLUETOOTH; }
 
-    // New BluetoothStatus: connected or disconnected
-    explicit BluetoothStatus(ConnectionState state)
-    {
-        assert(state != ConnectionState::PAIRING); // If pairing, use constructor which specifies passkey
-        statusType = STATUS_TYPE_BLUETOOTH;
-        this->state = state;
+  // New BluetoothStatus: connected or disconnected
+  explicit BluetoothStatus(ConnectionState state) {
+    assert(state != ConnectionState::PAIRING); // If pairing, use constructor which specifies passkey
+    statusType = STATUS_TYPE_BLUETOOTH;
+    this->state = state;
+  }
+
+  // New BluetoothStatus: pairing, with passkey
+  explicit BluetoothStatus(const std::string &passkey) : Status() {
+    statusType = STATUS_TYPE_BLUETOOTH;
+    this->state = ConnectionState::PAIRING;
+    this->passkey = passkey;
+  }
+
+  ConnectionState getConnectionState() const { return this->state; }
+
+  std::string getPasskey() const {
+    assert(state == ConnectionState::PAIRING);
+    return this->passkey;
+  }
+
+  void observe(Observable<const BluetoothStatus *> *source) { statusObserver.observe(source); }
+
+  bool matches(const BluetoothStatus *newStatus) const {
+    if (this->state == newStatus->getConnectionState()) {
+      // Same state: CONNECTED / DISCONNECTED
+      if (this->state != ConnectionState::PAIRING)
+        return true;
+      // Same state: PAIRING, and passkey matches
+      else if (this->getPasskey() == newStatus->getPasskey())
+        return true;
     }
 
-    // New BluetoothStatus: pairing, with passkey
-    explicit BluetoothStatus(const std::string &passkey) : Status()
-    {
-        statusType = STATUS_TYPE_BLUETOOTH;
-        this->state = ConnectionState::PAIRING;
-        this->passkey = passkey;
-    }
+    return false;
+  }
 
-    ConnectionState getConnectionState() const { return this->state; }
+  int updateStatus(const BluetoothStatus *newStatus) {
+    // Has the status changed?
+    if (!matches(newStatus)) {
+      // Copy the members
+      state = newStatus->getConnectionState();
+      if (state == ConnectionState::PAIRING)
+        passkey = newStatus->getPasskey();
 
-    std::string getPasskey() const
-    {
-        assert(state == ConnectionState::PAIRING);
-        return this->passkey;
-    }
+      // Tell anyone interested that we have an update
+      onNewStatus.notifyObservers(this);
 
-    void observe(Observable<const BluetoothStatus *> *source) { statusObserver.observe(source); }
-
-    bool matches(const BluetoothStatus *newStatus) const
-    {
-        if (this->state == newStatus->getConnectionState()) {
-            // Same state: CONNECTED / DISCONNECTED
-            if (this->state != ConnectionState::PAIRING)
-                return true;
-            // Same state: PAIRING, and passkey matches
-            else if (this->getPasskey() == newStatus->getPasskey())
-                return true;
-        }
-
-        return false;
-    }
-
-    int updateStatus(const BluetoothStatus *newStatus)
-    {
-        // Has the status changed?
-        if (!matches(newStatus)) {
-            // Copy the members
-            state = newStatus->getConnectionState();
-            if (state == ConnectionState::PAIRING)
-                passkey = newStatus->getPasskey();
-
-            // Tell anyone interested that we have an update
-            onNewStatus.notifyObservers(this);
-
-            // Debug only:
-            switch (state) {
-            case ConnectionState::PAIRING:
-                LOG_DEBUG("BluetoothStatus PAIRING, key=%s", passkey.c_str());
-                break;
-            case ConnectionState::CONNECTED:
-                LOG_DEBUG("BluetoothStatus CONNECTED");
+      // Debug only:
+      switch (state) {
+      case ConnectionState::PAIRING:
+        LOG_DEBUG("BluetoothStatus PAIRING, key=%s", passkey.c_str());
+        break;
+      case ConnectionState::CONNECTED:
+        LOG_DEBUG("BluetoothStatus CONNECTED");
 #ifdef BLE_LED
 #ifdef BLE_LED_INVERTED
-                digitalWrite(BLE_LED, LOW);
+        digitalWrite(BLE_LED, LOW);
 #else
-                digitalWrite(BLE_LED, HIGH);
+        digitalWrite(BLE_LED, HIGH);
 #endif
 #endif
-                break;
+        break;
 
-            case ConnectionState::DISCONNECTED:
-                LOG_DEBUG("BluetoothStatus DISCONNECTED");
+      case ConnectionState::DISCONNECTED:
+        LOG_DEBUG("BluetoothStatus DISCONNECTED");
 #ifdef BLE_LED
 #ifdef BLE_LED_INVERTED
-                digitalWrite(BLE_LED, HIGH);
+        digitalWrite(BLE_LED, HIGH);
 #else
-                digitalWrite(BLE_LED, LOW);
+        digitalWrite(BLE_LED, LOW);
 #endif
 #endif
-                break;
-            }
-        }
-
-        return 0;
+        break;
+      }
     }
+
+    return 0;
+  }
 };
 
 } // namespace meshtastic

src/DebugConfiguration.cpp

@@ -31,168 +31,150 @@ SOFTWARE.*/
 #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);
+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)
-{
-    this->_client = &client;
+Syslog::Syslog(UDP &client) {
+  this->_client = &client;
+  this->_server = NULL;
+  this->_port = 0;
+  this->_deviceHostname = SYSLOG_NILVALUE;
+  this->_appName = SYSLOG_NILVALUE;
+  this->_priDefault = LOGLEVEL_KERN;
+}
+
+Syslog &Syslog::server(const char *server, uint16_t port) {
+  if (this->_ip.fromString(server)) {
     this->_server = NULL;
-    this->_port = 0;
-    this->_deviceHostname = SYSLOG_NILVALUE;
-    this->_appName = SYSLOG_NILVALUE;
-    this->_priDefault = LOGLEVEL_KERN;
+  } else {
+    this->_server = server;
+  }
+  this->_port = port;
+  return *this;
 }
 
-Syslog &Syslog::server(const char *server, uint16_t port)
-{
-    if (this->_ip.fromString(server)) {
-        this->_server = NULL;
-    } else {
-        this->_server = server;
-    }
-    this->_port = port;
-    return *this;
+Syslog &Syslog::server(IPAddress ip, uint16_t port) {
+  this->_ip = ip;
+  this->_server = NULL;
+  this->_port = port;
+  return *this;
 }
 
-Syslog &Syslog::server(IPAddress ip, uint16_t port)
-{
-    this->_ip = ip;
-    this->_server = NULL;
-    this->_port = port;
-    return *this;
+Syslog &Syslog::deviceHostname(const char *deviceHostname) {
+  this->_deviceHostname = (deviceHostname == NULL) ? SYSLOG_NILVALUE : deviceHostname;
+  return *this;
 }
 
-Syslog &Syslog::deviceHostname(const char *deviceHostname)
-{
-    this->_deviceHostname = (deviceHostname == NULL) ? SYSLOG_NILVALUE : deviceHostname;
-    return *this;
+Syslog &Syslog::appName(const char *appName) {
+  this->_appName = (appName == NULL) ? SYSLOG_NILVALUE : appName;
+  return *this;
 }
 
-Syslog &Syslog::appName(const char *appName)
-{
-    this->_appName = (appName == NULL) ? SYSLOG_NILVALUE : appName;
-    return *this;
+Syslog &Syslog::defaultPriority(uint16_t pri) {
+  this->_priDefault = pri;
+  return *this;
 }
 
-Syslog &Syslog::defaultPriority(uint16_t pri)
-{
-    this->_priDefault = pri;
-    return *this;
+Syslog &Syslog::logMask(uint8_t priMask) {
+  this->_priMask = priMask;
+  return *this;
 }
 
-Syslog &Syslog::logMask(uint8_t priMask)
-{
-    this->_priMask = priMask;
-    return *this;
+void Syslog::enable() {
+  this->_client->begin(this->_port);
+  this->_enabled = true;
 }
 
-void Syslog::enable()
-{
-    this->_client->begin(this->_port);
-    this->_enabled = true;
+void Syslog::disable() {
+  this->_enabled = false;
+  this->_client->stop();
 }
 
-void Syslog::disable()
-{
-    this->_enabled = false;
-    this->_client->stop();
-}
+bool Syslog::isEnabled() { return this->_enabled; }
 
-bool Syslog::isEnabled()
-{
-    return this->_enabled;
-}
+bool Syslog::vlogf(uint16_t pri, const char *fmt, va_list args) { return this->vlogf(pri, this->_appName, fmt, args); }
 
-bool Syslog::vlogf(uint16_t pri, const char *fmt, va_list args)
-{
-    return this->vlogf(pri, this->_appName, fmt, args);
-}
+bool Syslog::vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) {
+  char *message;
+  size_t initialLen;
+  size_t len;
+  bool result;
 
-bool Syslog::vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args)
-{
-    char *message;
-    size_t initialLen;
-    size_t len;
-    bool result;
+  initialLen = strlen(fmt);
 
-    initialLen = strlen(fmt);
-
-    message = new char[initialLen + 1];
-
-    len = vsnprintf(message, initialLen + 1, fmt, args);
-    if (len > initialLen) {
-        delete[] message;
-        message = new char[len + 1];
-
-        vsnprintf(message, len + 1, fmt, args);
-    }
-
-    result = this->_sendLog(pri, appName, message);
+  message = new char[initialLen + 1];
 
+  len = vsnprintf(message, initialLen + 1, fmt, args);
+  if (len > initialLen) {
     delete[] message;
-    return result;
+    message = new char[len + 1];
+
+    vsnprintf(message, len + 1, fmt, args);
+  }
+
+  result = this->_sendLog(pri, appName, message);
+
+  delete[] message;
+  return result;
 }
 
-inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *message)
-{
-    int result;
+inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *message) {
+  int result;
 #ifdef ARCH_PORTDUINO
-    bool utf = !portduino_config.ascii_logs;
+  bool utf = !portduino_config.ascii_logs;
 #else
-    bool utf = true;
+  bool utf = true;
 #endif
 
-    if (!this->_enabled)
-        return false;
+  if (!this->_enabled)
+    return false;
 
-    if ((this->_server == NULL && this->_ip == INADDR_NONE) || this->_port == 0)
-        return false;
-
-    // Check priority against priMask values.
-    if ((LOG_MASK(LOG_PRI(pri)) & this->_priMask) == 0)
-        return true;
-
-    // Set default facility if none specified.
-    if ((pri & LOG_FACMASK) == 0)
-        pri = LOG_MAKEPRI(LOG_FAC(this->_priDefault), pri);
-
-    if (this->_server != NULL) {
-        result = this->_client->beginPacket(this->_server, this->_port);
-    } else {
-        result = this->_client->beginPacket(this->_ip, this->_port);
-    }
-
-    if (result != 1)
-        return false;
-
-    this->_client->print('<');
-    this->_client->print(pri);
-    this->_client->print(F(">1 - "));
-    this->_client->print(this->_deviceHostname);
-    this->_client->print(' ');
-    this->_client->print(appName);
-    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("]: "));
-    this->_client->print(message);
-    this->_client->endPacket();
+  if ((this->_server == NULL && this->_ip == INADDR_NONE) || this->_port == 0)
+    return false;
 
+  // Check priority against priMask values.
+  if ((LOG_MASK(LOG_PRI(pri)) & this->_priMask) == 0)
     return true;
+
+  // Set default facility if none specified.
+  if ((pri & LOG_FACMASK) == 0)
+    pri = LOG_MAKEPRI(LOG_FAC(this->_priDefault), pri);
+
+  if (this->_server != NULL) {
+    result = this->_client->beginPacket(this->_server, this->_port);
+  } else {
+    result = this->_client->beginPacket(this->_ip, this->_port);
+  }
+
+  if (result != 1)
+    return false;
+
+  this->_client->print('<');
+  this->_client->print(pri);
+  this->_client->print(F(">1 - "));
+  this->_client->print(this->_deviceHostname);
+  this->_client->print(' ');
+  this->_client->print(appName);
+  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("]: "));
+  this->_client->print(message);
+  this->_client->endPacket();
+
+  return true;
 }
 
 #endif

src/DebugConfiguration.h

@@ -74,13 +74,13 @@ extern MemGet memGet;
 
 // Macro-based heap debugging
 #define DEBUG_HEAP_BEFORE auto heapBefore = memGet.getFreeHeap();
-#define DEBUG_HEAP_AFTER(context, ptr)                                                                                           \
-    do {                                                                                                                         \
-        auto heapAfter = memGet.getFreeHeap();                                                                                   \
-        if (heapBefore != heapAfter) {                                                                                           \
-            LOG_HEAP("Alloc in %s pointer 0x%x, size: %u, free: %u", context, ptr, heapBefore - heapAfter, heapAfter);           \
-        }                                                                                                                        \
-    } while (0)
+#define DEBUG_HEAP_AFTER(context, ptr)                                                                                                               \
+  do {                                                                                                                                               \
+    auto heapAfter = memGet.getFreeHeap();                                                                                                           \
+    if (heapBefore != heapAfter) {                                                                                                                   \
+      LOG_HEAP("Alloc in %s pointer 0x%x, size: %u, free: %u", context, ptr, heapBefore - heapAfter, heapAfter);                                     \
+    }                                                                                                                                                \
+  } while (0)
 
 #else
 #define LOG_HEAP(...)
@@ -162,37 +162,36 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 
 #if HAS_NETWORKING
 
-class Syslog
-{
-  private:
-    UDP *_client;
-    IPAddress _ip;
-    const char *_server;
-    uint16_t _port;
-    const char *_deviceHostname;
-    const char *_appName;
-    uint16_t _priDefault;
-    uint8_t _priMask = 0xff;
-    bool _enabled = false;
+class Syslog {
+private:
+  UDP *_client;
+  IPAddress _ip;
+  const char *_server;
+  uint16_t _port;
+  const char *_deviceHostname;
+  const char *_appName;
+  uint16_t _priDefault;
+  uint8_t _priMask = 0xff;
+  bool _enabled = false;
 
-    bool _sendLog(uint16_t pri, const char *appName, const char *message);
+  bool _sendLog(uint16_t pri, const char *appName, const char *message);
 
-  public:
-    explicit Syslog(UDP &client);
+public:
+  explicit Syslog(UDP &client);
 
-    Syslog &server(const char *server, uint16_t port);
-    Syslog &server(IPAddress ip, uint16_t port);
-    Syslog &deviceHostname(const char *deviceHostname);
-    Syslog &appName(const char *appName);
-    Syslog &defaultPriority(uint16_t pri = LOGLEVEL_KERN);
-    Syslog &logMask(uint8_t priMask);
+  Syslog &server(const char *server, uint16_t port);
+  Syslog &server(IPAddress ip, uint16_t port);
+  Syslog &deviceHostname(const char *deviceHostname);
+  Syslog &appName(const char *appName);
+  Syslog &defaultPriority(uint16_t pri = LOGLEVEL_KERN);
+  Syslog &logMask(uint8_t priMask);
 
-    void enable();
-    void disable();
-    bool isEnabled();
+  void enable();
+  void disable();
+  bool isEnabled();
 
-    bool vlogf(uint16_t pri, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
-    bool vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
+  bool vlogf(uint16_t pri, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
+  bool vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
 };
 
 #endif // HAS_NETWORKING

src/DisplayFormatters.cpp

@@ -1,83 +1,83 @@
 #include "DisplayFormatters.h"
 
-const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName,
-                                                         bool usePreset)
-{
+const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName, bool usePreset) {
 
-    // If use_preset is false, always return "Custom"
-    if (!usePreset) {
-        return "Custom";
-    }
+  // If use_preset is false, always return "Custom"
+  if (!usePreset) {
+    return "Custom";
+  }
 
-    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;
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
-        return useShortName ? "ShortF" : "ShortFast";
-        break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
-        return useShortName ? "MedS" : "MediumSlow";
-        break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
-        return useShortName ? "MedF" : "MediumFast";
-        break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
-        return useShortName ? "LongS" : "LongSlow";
-        break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
-        return useShortName ? "LongF" : "LongFast";
-        break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
-        return useShortName ? "LongM" : "LongMod";
-        break;
-    default:
-        return useShortName ? "Custom" : "Invalid";
-        break;
-    }
+  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;
+  case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
+    return useShortName ? "ShortF" : "ShortFast";
+    break;
+  case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
+    return useShortName ? "MedS" : "MediumSlow";
+    break;
+  case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+    return useShortName ? "MedF" : "MediumFast";
+    break;
+  case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
+    return useShortName ? "LongS" : "LongSlow";
+    break;
+  case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
+    return useShortName ? "LongF" : "LongFast";
+    break;
+  case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
+    return useShortName ? "LongT" : "LongTurbo";
+    break;
+  case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
+    return useShortName ? "LongM" : "LongMod";
+    break;
+  default:
+    return useShortName ? "Custom" : "Invalid";
+    break;
+  }
 }
 
-const char *DisplayFormatters::getDeviceRole(meshtastic_Config_DeviceConfig_Role role)
-{
-    switch (role) {
-    case meshtastic_Config_DeviceConfig_Role_CLIENT:
-        return "Client";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE:
-        return "Client Mute";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN:
-        return "Client Hidden";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_CLIENT_BASE:
-        return "Client Base";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND:
-        return "Lost and Found";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_TRACKER:
-        return "Tracker";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_SENSOR:
-        return "Sensor";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_TAK:
-        return "TAK";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_TAK_TRACKER:
-        return "TAK Tracker";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_ROUTER:
-        return "Router";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_ROUTER_LATE:
-        return "Router Late";
-        break;
-    default:
-        return "Unknown";
-        break;
-    }
+const char *DisplayFormatters::getDeviceRole(meshtastic_Config_DeviceConfig_Role role) {
+  switch (role) {
+  case meshtastic_Config_DeviceConfig_Role_CLIENT:
+    return "Client";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE:
+    return "Client Mute";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN:
+    return "Client Hidden";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_CLIENT_BASE:
+    return "Client Base";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND:
+    return "Lost and Found";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_TRACKER:
+    return "Tracker";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_SENSOR:
+    return "Sensor";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_TAK:
+    return "TAK";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_TAK_TRACKER:
+    return "TAK Tracker";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_ROUTER:
+    return "Router";
+    break;
+  case meshtastic_Config_DeviceConfig_Role_ROUTER_LATE:
+    return "Router Late";
+    break;
+  default:
+    return "Unknown";
+    break;
+  }
 }

src/DisplayFormatters.h

@@ -1,10 +1,8 @@
 #pragma once
 #include "NodeDB.h"
 
-class DisplayFormatters
-{
-  public:
-    static const char *getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName,
-                                                 bool usePreset);
-    static const char *getDeviceRole(meshtastic_Config_DeviceConfig_Role role);
+class DisplayFormatters {
+public:
+  static const char *getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName, bool usePreset);
+  static const char *getDeviceRole(meshtastic_Config_DeviceConfig_Role role);
 };

src/FSCommon.cpp

@@ -1,11 +1,11 @@
 /**
  * @file FSCommon.cpp
- * @brief This file contains functions for common filesystem operations such as copying, renaming, listing and deleting files and
- * directories.
+ * @brief This file contains functions for common filesystem operations such as copying, renaming, listing and deleting
+ * files and directories.
  *
- * The functions in this file are used to perform common filesystem operations such as copying, renaming, listing and deleting
- * files and directories. These functions are used in the Meshtastic-device project to manage files and directories on the
- * device's filesystem.
+ * The functions in this file are used to perform common filesystem operations such as copying, renaming, listing and
+ * deleting files and directories. These functions are used in the Meshtastic-device project to manage files and
+ * directories on the device's filesystem.
  *
  */
 #include "FSCommon.h"
@@ -37,34 +37,33 @@ SPIClass SPI_HSPI(HSPI);
  * @param to The path of the destination file.
  * @return true if the file was successfully copied, false otherwise.
  */
-bool copyFile(const char *from, const char *to)
-{
+bool copyFile(const char *from, const char *to) {
 #ifdef FSCom
-    // take SPI Lock
-    concurrency::LockGuard g(spiLock);
-    unsigned char cbuffer[16];
+  // take SPI Lock
+  concurrency::LockGuard g(spiLock);
+  unsigned char cbuffer[16];
 
-    File f1 = FSCom.open(from, FILE_O_READ);
-    if (!f1) {
-        LOG_ERROR("Failed to open source file %s", from);
-        return false;
-    }
+  File f1 = FSCom.open(from, FILE_O_READ);
+  if (!f1) {
+    LOG_ERROR("Failed to open source file %s", from);
+    return false;
+  }
 
-    File f2 = FSCom.open(to, FILE_O_WRITE);
-    if (!f2) {
-        LOG_ERROR("Failed to open destination file %s", to);
-        return false;
-    }
+  File f2 = FSCom.open(to, FILE_O_WRITE);
+  if (!f2) {
+    LOG_ERROR("Failed to open destination file %s", to);
+    return false;
+  }
 
-    while (f1.available() > 0) {
-        byte i = f1.read(cbuffer, 16);
-        f2.write(cbuffer, i);
-    }
+  while (f1.available() > 0) {
+    byte i = f1.read(cbuffer, 16);
+    f2.write(cbuffer, i);
+  }
 
-    f2.flush();
-    f2.close();
-    f1.close();
-    return true;
+  f2.flush();
+  f2.close();
+  f1.close();
+  return true;
 #endif
 }
 
@@ -76,24 +75,23 @@ bool copyFile(const char *from, const char *to)
  *
  * @return True if the file was successfully renamed, false otherwise.
  */
-bool renameFile(const char *pathFrom, const char *pathTo)
-{
+bool renameFile(const char *pathFrom, const char *pathTo) {
 #ifdef FSCom
 
 #ifdef ARCH_ESP32
-    // take SPI Lock
-    spiLock->lock();
-    // rename was fixed for ESP32 IDF LittleFS in April
-    bool result = FSCom.rename(pathFrom, pathTo);
-    spiLock->unlock();
-    return result;
+  // take SPI Lock
+  spiLock->lock();
+  // rename was fixed for ESP32 IDF LittleFS in April
+  bool result = FSCom.rename(pathFrom, pathTo);
+  spiLock->unlock();
+  return result;
 #else
-    // copyFile does its own locking.
-    if (copyFile(pathFrom, pathTo) && FSCom.remove(pathFrom)) {
-        return true;
-    } else {
-        return false;
-    }
+  // copyFile does its own locking.
+  if (copyFile(pathFrom, pathTo) && FSCom.remove(pathFrom)) {
+    return true;
+  } else {
+    return false;
+  }
 #endif
 
 #endif
@@ -111,45 +109,44 @@ bool renameFile(const char *pathFrom, const char *pathTo)
  * @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 = {};
+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 = {"", static_cast<uint32_t>(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
+  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 = {"", static_cast<uint32_t>(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;
 }
 
 /**
@@ -160,100 +157,98 @@ std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
  * @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)
-{
+void listDir(const char *dirname, uint8_t levels, bool del) {
 #ifdef FSCom
 #if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-    char buffer[255];
+  char buffer[255];
 #endif
-    File root = FSCom.open(dirname, FILE_O_READ);
-    if (!root) {
-        return;
-    }
-    if (!root.isDirectory()) {
-        return;
-    }
+  File root = FSCom.open(dirname, FILE_O_READ);
+  if (!root) {
+    return;
+  }
+  if (!root.isDirectory()) {
+    return;
+  }
 
-    File file = root.openNextFile();
-    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) {
+  File file = root.openNextFile();
+  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
-                listDir(file.path(), levels - 1, del);
-                if (del) {
-                    LOG_DEBUG("Remove %s", file.path());
-                    strncpy(buffer, file.path(), sizeof(buffer));
-                    file.close();
-                    FSCom.rmdir(buffer);
-                } else {
-                    file.close();
-                }
-#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-                listDir(file.name(), levels - 1, del);
-                if (del) {
-                    LOG_DEBUG("Remove %s", file.name());
-                    strncpy(buffer, file.name(), sizeof(buffer));
-                    file.close();
-                    FSCom.rmdir(buffer);
-                } else {
-                    file.close();
-                }
-#else
-                LOG_DEBUG(" %s (directory)", file.name());
-                listDir(file.name(), levels - 1, del);
-                file.close();
-#endif
-            }
+        listDir(file.path(), levels - 1, del);
+        if (del) {
+          LOG_DEBUG("Remove %s", file.path());
+          strncpy(buffer, file.path(), sizeof(buffer));
+          file.close();
+          FSCom.rmdir(buffer);
         } else {
-#ifdef ARCH_ESP32
-            if (del) {
-                LOG_DEBUG("Delete %s", file.path());
-                strncpy(buffer, file.path(), sizeof(buffer));
-                file.close();
-                FSCom.remove(buffer);
-            } else {
-                LOG_DEBUG(" %s (%i Bytes)", file.path(), file.size());
-                file.close();
-            }
-#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-            if (del) {
-                LOG_DEBUG("Delete %s", file.name());
-                strncpy(buffer, file.name(), sizeof(buffer));
-                file.close();
-                FSCom.remove(buffer);
-            } else {
-                LOG_DEBUG(" %s (%i Bytes)", file.name(), file.size());
-                file.close();
-            }
-#else
-            LOG_DEBUG("   %s (%i Bytes)", file.name(), file.size());
-            file.close();
-#endif
+          file.close();
         }
-        file = root.openNextFile();
-    }
-#ifdef ARCH_ESP32
-    if (del) {
-        LOG_DEBUG("Remove %s", root.path());
-        strncpy(buffer, root.path(), sizeof(buffer));
-        root.close();
-        FSCom.rmdir(buffer);
-    } else {
-        root.close();
-    }
 #elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-    if (del) {
-        LOG_DEBUG("Remove %s", root.name());
-        strncpy(buffer, root.name(), sizeof(buffer));
-        root.close();
-        FSCom.rmdir(buffer);
-    } else {
-        root.close();
-    }
+        listDir(file.name(), levels - 1, del);
+        if (del) {
+          LOG_DEBUG("Remove %s", file.name());
+          strncpy(buffer, file.name(), sizeof(buffer));
+          file.close();
+          FSCom.rmdir(buffer);
+        } else {
+          file.close();
+        }
 #else
+        LOG_DEBUG(" %s (directory)", file.name());
+        listDir(file.name(), levels - 1, del);
+        file.close();
+#endif
+      }
+    } else {
+#ifdef ARCH_ESP32
+      if (del) {
+        LOG_DEBUG("Delete %s", file.path());
+        strncpy(buffer, file.path(), sizeof(buffer));
+        file.close();
+        FSCom.remove(buffer);
+      } else {
+        LOG_DEBUG(" %s (%i Bytes)", file.path(), file.size());
+        file.close();
+      }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+      if (del) {
+        LOG_DEBUG("Delete %s", file.name());
+        strncpy(buffer, file.name(), sizeof(buffer));
+        file.close();
+        FSCom.remove(buffer);
+      } else {
+        LOG_DEBUG(" %s (%i Bytes)", file.name(), file.size());
+        file.close();
+      }
+#else
+      LOG_DEBUG("   %s (%i Bytes)", file.name(), file.size());
+      file.close();
+#endif
+    }
+    file = root.openNextFile();
+  }
+#ifdef ARCH_ESP32
+  if (del) {
+    LOG_DEBUG("Remove %s", root.path());
+    strncpy(buffer, root.path(), sizeof(buffer));
     root.close();
+    FSCom.rmdir(buffer);
+  } else {
+    root.close();
+  }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+  if (del) {
+    LOG_DEBUG("Remove %s", root.name());
+    strncpy(buffer, root.name(), sizeof(buffer));
+    root.close();
+    FSCom.rmdir(buffer);
+  } else {
+    root.close();
+  }
+#else
+  root.close();
 #endif
 #endif
 }
@@ -265,15 +260,14 @@ void listDir(const char *dirname, uint8_t levels, bool del)
  *
  * @param dirname The name of the directory to remove.
  */
-void rmDir(const char *dirname)
-{
+void rmDir(const char *dirname) {
 #ifdef FSCom
 
 #if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-    listDir(dirname, 10, true);
+  listDir(dirname, 10, true);
 #elif defined(ARCH_NRF52)
-    // nRF52 implementation of LittleFS has a recursive delete function
-    FSCom.rmdir_r(dirname);
+  // nRF52 implementation of LittleFS has a recursive delete function
+  FSCom.rmdir_r(dirname);
 #endif
 
 #endif
@@ -284,55 +278,53 @@ void rmDir(const char *dirname)
  */
 __attribute__((weak, noinline)) void preFSBegin() {}
 
-void fsInit()
-{
+void fsInit() {
 #ifdef FSCom
-    concurrency::LockGuard g(spiLock);
-    preFSBegin();
-    if (!FSBegin()) {
-        LOG_ERROR("Filesystem mount failed");
-        // assert(0); This auto-formats the partition, so no need to fail here.
-    }
+  concurrency::LockGuard g(spiLock);
+  preFSBegin();
+  if (!FSBegin()) {
+    LOG_ERROR("Filesystem mount failed");
+    // assert(0); This auto-formats the partition, so no need to fail here.
+  }
 #if defined(ARCH_ESP32)
-    LOG_DEBUG("Filesystem files (%d/%d Bytes):", FSCom.usedBytes(), FSCom.totalBytes());
+  LOG_DEBUG("Filesystem files (%d/%d Bytes):", FSCom.usedBytes(), FSCom.totalBytes());
 #else
-    LOG_DEBUG("Filesystem files:");
+  LOG_DEBUG("Filesystem files:");
 #endif
-    listDir("/", 10);
+  listDir("/", 10);
 #endif
 }
 
 /**
  * Initializes the SD card and mounts the file system.
  */
-void setupSDCard()
-{
+void setupSDCard() {
 #if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI)
-    concurrency::LockGuard g(spiLock);
-    SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
-    if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {
-        LOG_DEBUG("No SD_MMC card detected");
-        return;
-    }
-    uint8_t cardType = SD.cardType();
-    if (cardType == CARD_NONE) {
-        LOG_DEBUG("No SD_MMC card attached");
-        return;
-    }
-    LOG_DEBUG("SD_MMC Card Type: ");
-    if (cardType == CARD_MMC) {
-        LOG_DEBUG("MMC");
-    } else if (cardType == CARD_SD) {
-        LOG_DEBUG("SDSC");
-    } else if (cardType == CARD_SDHC) {
-        LOG_DEBUG("SDHC");
-    } else {
-        LOG_DEBUG("UNKNOWN");
-    }
+  concurrency::LockGuard g(spiLock);
+  SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
+  if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {
+    LOG_DEBUG("No SD_MMC card detected");
+    return;
+  }
+  uint8_t cardType = SD.cardType();
+  if (cardType == CARD_NONE) {
+    LOG_DEBUG("No SD_MMC card attached");
+    return;
+  }
+  LOG_DEBUG("SD_MMC Card Type: ");
+  if (cardType == CARD_MMC) {
+    LOG_DEBUG("MMC");
+  } else if (cardType == CARD_SD) {
+    LOG_DEBUG("SDSC");
+  } else if (cardType == CARD_SDHC) {
+    LOG_DEBUG("SDHC");
+  } else {
+    LOG_DEBUG("UNKNOWN");
+  }
 
-    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
-    LOG_DEBUG("SD Card Size: %lu MB", (uint32_t)cardSize);
-    LOG_DEBUG("Total space: %lu MB", (uint32_t)(SD.totalBytes() / (1024 * 1024)));
-    LOG_DEBUG("Used space: %lu MB", (uint32_t)(SD.usedBytes() / (1024 * 1024)));
+  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
+  LOG_DEBUG("SD Card Size: %lu MB", (uint32_t)cardSize);
+  LOG_DEBUG("Total space: %lu MB", (uint32_t)(SD.totalBytes() / (1024 * 1024)));
+  LOG_DEBUG("Used space: %lu MB", (uint32_t)(SD.usedBytes() / (1024 * 1024)));
 #endif
 }

src/Fusion/FusionAhrs.c

@@ -43,18 +43,17 @@ static inline int Clamp(const int value, const int min, const int max);
  * @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);
+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);
 }
 
 /**
@@ -62,21 +61,20 @@ void FusionAhrsInitialise(FusionAhrs *const ahrs)
  * 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;
+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;
 }
 
 /**
@@ -84,28 +82,25 @@ void FusionAhrsReset(FusionAhrs *const ahrs)
  * @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;
+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;
 }
 
 /**
@@ -117,119 +112,113 @@ void FusionAhrsSetSettings(FusionAhrs *const ahrs, const FusionAhrsSettings *con
  * @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)
-{
+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;
+  // 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;
+  // 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;
     }
 
-    // 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;
-        }
+    // 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;
     }
 
-    // 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;
-        }
+    // 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);
 
-    // 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;
-        }
+    // 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));
+  // 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));
+  // 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)));
+  // Integrate rate of change of quaternion
+  ahrs->quaternion = FusionQuaternionAdd(
+      ahrs->quaternion, FusionQuaternionMultiplyVector(ahrs->quaternion, FusionVectorMultiplyScalar(adjustedHalfGyroscope, deltaTime)));
 
-    // Normalise quaternion
-    ahrs->quaternion = FusionQuaternionNormalise(ahrs->quaternion);
+  // Normalise quaternion
+  ahrs->quaternion = FusionQuaternionNormalise(ahrs->quaternion);
 #undef Q
 }
 
@@ -238,29 +227,28 @@ void FusionAhrsUpdate(FusionAhrs *const ahrs, const FusionVector gyroscope, cons
  * @param ahrs AHRS algorithm structure.
  * @return Direction of gravity scaled by 0.5.
  */
-static inline FusionVector HalfGravity(const FusionAhrs *const ahrs)
-{
+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
+  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
 }
 
@@ -269,36 +257,35 @@ static inline FusionVector HalfGravity(const FusionAhrs *const ahrs)
  * @param ahrs AHRS algorithm structure.
  * @return Direction of the magnetic field scaled by 0.5.
  */
-static inline FusionVector HalfMagnetic(const FusionAhrs *const ahrs)
-{
+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
+  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
 }
 
@@ -308,12 +295,11 @@ static inline FusionVector HalfMagnetic(const FusionAhrs *const ahrs)
  * @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);
+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);
 }
 
 /**
@@ -323,15 +309,14 @@ static inline FusionVector Feedback(const FusionVector sensor, const FusionVecto
  * @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;
+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;
 }
 
 /**
@@ -342,17 +327,15 @@ static inline int Clamp(const int value, const int min, const int max)
  * @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)
-{
+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);
+  // Update AHRS algorithm
+  FusionAhrsUpdate(ahrs, gyroscope, accelerometer, FUSION_VECTOR_ZERO, deltaTime);
 
-    // Zero heading during initialisation
-    if (ahrs->initialising) {
-        FusionAhrsSetHeading(ahrs, 0.0f);
-    }
+  // Zero heading during initialisation
+  if (ahrs->initialising) {
+    FusionAhrsSetHeading(ahrs, 0.0f);
+  }
 }
 
 /**
@@ -364,25 +347,24 @@ void FusionAhrsUpdateNoMagnetometer(FusionAhrs *const ahrs, const FusionVector 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)
-{
+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 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),
-                                       }};
+  // 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);
+  // Update AHRS algorithm
+  FusionAhrsUpdate(ahrs, gyroscope, accelerometer, magnetometer, deltaTime);
 #undef Q
 }
 
@@ -391,20 +373,14 @@ void FusionAhrsUpdateExternalHeading(FusionAhrs *const ahrs, const FusionVector
  * @param ahrs AHRS algorithm structure.
  * @return Quaternion describing the sensor relative to the Earth.
  */
-FusionQuaternion FusionAhrsGetQuaternion(const FusionAhrs *const ahrs)
-{
-    return ahrs->quaternion;
-}
+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;
-}
+void FusionAhrsSetQuaternion(FusionAhrs *const ahrs, const FusionQuaternion quaternion) { ahrs->quaternion = quaternion; }
 
 /**
  * @brief Returns the linear acceleration measurement equal to the accelerometer
@@ -412,28 +388,27 @@ void FusionAhrsSetQuaternion(FusionAhrs *const ahrs, const FusionQuaternion quat
  * @param ahrs AHRS algorithm structure.
  * @return Linear acceleration measurement in g.
  */
-FusionVector FusionAhrsGetLinearAcceleration(const FusionAhrs *const ahrs)
-{
+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
+  // 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
+  // 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
 }
 
@@ -443,36 +418,35 @@ FusionVector FusionAhrsGetLinearAcceleration(const FusionAhrs *const ahrs)
  * @param ahrs AHRS algorithm structure.
  * @return Earth acceleration measurement in g.
  */
-FusionVector FusionAhrsGetEarthAcceleration(const FusionAhrs *const ahrs)
-{
+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
+  // 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;
+  // 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
 }
@@ -482,22 +456,18 @@ FusionVector FusionAhrsGetEarthAcceleration(const FusionAhrs *const ahrs)
  * @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;
+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;
 }
 
 /**
@@ -505,15 +475,14 @@ FusionAhrsInternalStates FusionAhrsGetInternalStates(const FusionAhrs *const ahr
  * @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;
+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;
 }
 
 /**
@@ -523,18 +492,17 @@ FusionAhrsFlags FusionAhrsGetFlags(const FusionAhrs *const ahrs)
  * @param ahrs AHRS algorithm structure.
  * @param heading Heading angle in degrees.
  */
-void FusionAhrsSetHeading(FusionAhrs *const ahrs, const float heading)
-{
+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);
+  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
 }
 

src/Fusion/FusionAhrs.h

@@ -22,12 +22,12 @@
  * @brief AHRS algorithm settings.
  */
 typedef struct {
-    FusionConvention convention;
-    float gain;
-    float gyroscopeRange;
-    float accelerationRejection;
-    float magneticRejection;
-    unsigned int recoveryTriggerPeriod;
+  FusionConvention convention;
+  float gain;
+  float gyroscopeRange;
+  float accelerationRejection;
+  float magneticRejection;
+  unsigned int recoveryTriggerPeriod;
 } FusionAhrsSettings;
 
 /**
@@ -35,43 +35,43 @@ typedef struct {
  * 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;
+  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;
+  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;
+  bool initialising;
+  bool angularRateRecovery;
+  bool accelerationRecovery;
+  bool magneticRecovery;
 } FusionAhrsFlags;
 
 //------------------------------------------------------------------------------
@@ -83,14 +83,13 @@ 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 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 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);
+void FusionAhrsUpdateExternalHeading(FusionAhrs *const ahrs, const FusionVector gyroscope, const FusionVector accelerometer, const float heading,
+                                     const float deltaTime);
 
 FusionQuaternion FusionAhrsGetQuaternion(const FusionAhrs *const ahrs);
 

src/Fusion/FusionAxes.h

@@ -22,30 +22,30 @@
  * 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 */
+  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;
 
 //------------------------------------------------------------------------------
@@ -57,129 +57,128 @@ typedef enum {
  * @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
+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

src/Fusion/FusionCalibration.h

@@ -23,11 +23,9 @@
  * @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));
+static inline FusionVector FusionCalibrationInertial(const FusionVector uncalibrated, const FusionMatrix misalignment, const FusionVector sensitivity,
+                                                     const FusionVector offset) {
+  return FusionMatrixMultiplyVector(misalignment, FusionVectorHadamardProduct(FusionVectorSubtract(uncalibrated, offset), sensitivity));
 }
 
 /**
@@ -38,9 +36,8 @@ static inline FusionVector FusionCalibrationInertial(const FusionVector uncalibr
  * @return Calibrated measurement.
  */
 static inline FusionVector FusionCalibrationMagnetic(const FusionVector uncalibrated, const FusionMatrix softIronMatrix,
-                                                     const FusionVector hardIronOffset)
-{
-    return FusionMatrixMultiplyVector(softIronMatrix, FusionVectorSubtract(uncalibrated, hardIronOffset));
+                                                     const FusionVector hardIronOffset) {
+  return FusionMatrixMultiplyVector(softIronMatrix, FusionVectorSubtract(uncalibrated, hardIronOffset));
 }
 
 #endif

src/Fusion/FusionCompass.c

@@ -22,29 +22,27 @@
  * @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
+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
 }
 
 //------------------------------------------------------------------------------

src/Fusion/FusionCompass.h

@@ -17,8 +17,7 @@
 //------------------------------------------------------------------------------
 // Function declarations
 
-float FusionCompassCalculateHeading(const FusionConvention convention, const FusionVector accelerometer,
-                                    const FusionVector magnetometer);
+float FusionCompassCalculateHeading(const FusionConvention convention, const FusionVector accelerometer, const FusionVector magnetometer);
 
 #endif
 

src/Fusion/FusionConvention.h

@@ -14,9 +14,9 @@
  * @brief Earth axes convention.
  */
 typedef enum {
-    FusionConventionNwu, /* North-West-Up */
-    FusionConventionEnu, /* East-North-Up */
-    FusionConventionNed, /* North-East-Down */
+  FusionConventionNwu, /* North-West-Up */
+  FusionConventionEnu, /* East-North-Up */
+  FusionConventionNed, /* North-East-Down */
 } FusionConvention;
 
 #endif

src/Fusion/FusionMath.h

@@ -21,27 +21,27 @@
  * @brief 3D vector.
  */
 typedef union {
-    float array[3];
+  float array[3];
 
-    struct {
-        float x;
-        float y;
-        float z;
-    } axis;
+  struct {
+    float x;
+    float y;
+    float z;
+  } axis;
 } FusionVector;
 
 /**
  * @brief Quaternion.
  */
 typedef union {
-    float array[4];
+  float array[4];
 
-    struct {
-        float w;
-        float x;
-        float y;
-        float z;
-    } element;
+  struct {
+    float w;
+    float x;
+    float y;
+    float z;
+  } element;
 } FusionQuaternion;
 
 /**
@@ -49,19 +49,19 @@ typedef union {
  * See http://en.wikipedia.org/wiki/Row-major_order
  */
 typedef union {
-    float array[3][3];
+  float array[3][3];
 
-    struct {
-        float xx;
-        float xy;
-        float xz;
-        float yx;
-        float yy;
-        float yz;
-        float zx;
-        float zy;
-        float zz;
-    } element;
+  struct {
+    float xx;
+    float xy;
+    float xz;
+    float yx;
+    float yy;
+    float yz;
+    float zx;
+    float zy;
+    float zz;
+  } element;
 } FusionMatrix;
 
 /**
@@ -69,13 +69,13 @@ typedef union {
  * X, Y, and Z respectively.
  */
 typedef union {
-    float array[3];
+  float array[3];
 
-    struct {
-        float roll;
-        float pitch;
-        float yaw;
-    } angle;
+  struct {
+    float roll;
+    float pitch;
+    float yaw;
+  } angle;
 } FusionEuler;
 
 /**
@@ -124,20 +124,14 @@ typedef union {
  * @param degrees Degrees.
  * @return Radians.
  */
-static inline float FusionDegreesToRadians(const float degrees)
-{
-    return degrees * ((float)M_PI / 180.0f);
-}
+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);
-}
+static inline float FusionRadiansToDegrees(const float radians) { return radians * (180.0f / (float)M_PI); }
 
 //------------------------------------------------------------------------------
 // Inline functions - Arc sine
@@ -147,15 +141,14 @@ static inline float FusionRadiansToDegrees(const float radians)
  * @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);
+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);
 }
 
 //------------------------------------------------------------------------------
@@ -169,17 +162,16 @@ static inline float FusionAsin(const float value)
  * @param x Operand.
  * @return Reciprocal of the square root of x.
  */
-static inline float FusionFastInverseSqrt(const float x)
-{
+static inline float FusionFastInverseSqrt(const float x) {
 
-    typedef union {
-        float f;
-        int32_t i;
-    } Union32;
+  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);
+  Union32 union32 = {.f = x};
+  union32.i = 0x5F1F1412 - (union32.i >> 1);
+  return union32.f * (1.69000231f - 0.714158168f * x * union32.f * union32.f);
 }
 
 #endif
@@ -192,9 +184,8 @@ static inline float FusionFastInverseSqrt(const float x)
  * @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);
+static inline bool FusionVectorIsZero(const FusionVector vector) {
+  return (vector.axis.x == 0.0f) && (vector.axis.y == 0.0f) && (vector.axis.z == 0.0f);
 }
 
 /**
@@ -203,14 +194,13 @@ static inline bool FusionVectorIsZero(const FusionVector vector)
  * @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;
+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;
 }
 
 /**
@@ -219,14 +209,13 @@ static inline FusionVector FusionVectorAdd(const FusionVector vectorA, const Fus
  * @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;
+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;
 }
 
 /**
@@ -234,10 +223,7 @@ static inline FusionVector FusionVectorSubtract(const FusionVector vectorA, cons
  * @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;
-}
+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.
@@ -245,14 +231,13 @@ static inline float FusionVectorSum(const FusionVector 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;
+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;
 }
 
 /**
@@ -261,14 +246,13 @@ static inline FusionVector FusionVectorMultiplyScalar(const FusionVector vector,
  * @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;
+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;
 }
 
 /**
@@ -277,16 +261,15 @@ static inline FusionVector FusionVectorHadamardProduct(const FusionVector vector
  * @param vectorB Vector B.
  * @return Cross product.
  */
-static inline FusionVector FusionVectorCrossProduct(const FusionVector vectorA, const FusionVector vectorB)
-{
+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;
+  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
 }
@@ -297,9 +280,8 @@ static inline FusionVector FusionVectorCrossProduct(const FusionVector vectorA,
  * @param vectorB Vector B.
  * @return Dot product.
  */
-static inline float FusionVectorDotProduct(const FusionVector vectorA, const FusionVector vectorB)
-{
-    return FusionVectorSum(FusionVectorHadamardProduct(vectorA, vectorB));
+static inline float FusionVectorDotProduct(const FusionVector vectorA, const FusionVector vectorB) {
+  return FusionVectorSum(FusionVectorHadamardProduct(vectorA, vectorB));
 }
 
 /**
@@ -307,34 +289,27 @@ static inline float FusionVectorDotProduct(const FusionVector vectorA, const Fus
  * @param vector Vector.
  * @return Vector magnitude squared.
  */
-static inline float FusionVectorMagnitudeSquared(const FusionVector vector)
-{
-    return FusionVectorSum(FusionVectorHadamardProduct(vector, vector));
-}
+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));
-}
+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)
-{
+static inline FusionVector FusionVectorNormalise(const FusionVector vector) {
 #ifdef FUSION_USE_NORMAL_SQRT
-    const float magnitudeReciprocal = 1.0f / sqrtf(FusionVectorMagnitudeSquared(vector));
+  const float magnitudeReciprocal = 1.0f / sqrtf(FusionVectorMagnitudeSquared(vector));
 #else
-    const float magnitudeReciprocal = FusionFastInverseSqrt(FusionVectorMagnitudeSquared(vector));
+  const float magnitudeReciprocal = FusionFastInverseSqrt(FusionVectorMagnitudeSquared(vector));
 #endif
-    return FusionVectorMultiplyScalar(vector, magnitudeReciprocal);
+  return FusionVectorMultiplyScalar(vector, magnitudeReciprocal);
 }
 
 //------------------------------------------------------------------------------
@@ -346,15 +321,14 @@ static inline FusionVector FusionVectorNormalise(const FusionVector vector)
  * @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;
+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;
 }
 
 /**
@@ -363,17 +337,16 @@ static inline FusionQuaternion FusionQuaternionAdd(const FusionQuaternion quater
  * @param quaternionB Quaternion B (to be pre-multiplied).
  * @return Multiplication of two quaternions.
  */
-static inline FusionQuaternion FusionQuaternionMultiply(const FusionQuaternion quaternionA, const FusionQuaternion quaternionB)
-{
+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;
+  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
 }
@@ -387,17 +360,16 @@ static inline FusionQuaternion FusionQuaternionMultiply(const FusionQuaternion q
  * @param vector Vector.
  * @return Multiplication of a quaternion with a vector.
  */
-static inline FusionQuaternion FusionQuaternionMultiplyVector(const FusionQuaternion quaternion, const FusionVector 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;
+  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
 }
@@ -407,21 +379,20 @@ static inline FusionQuaternion FusionQuaternionMultiplyVector(const FusionQuater
  * @param quaternion Quaternion.
  * @return Normalised quaternion.
  */
-static inline FusionQuaternion FusionQuaternionNormalise(const FusionQuaternion 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);
+  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);
+  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;
+  const FusionQuaternion result = {.element = {
+                                       .w = Q.w * magnitudeReciprocal,
+                                       .x = Q.x * magnitudeReciprocal,
+                                       .y = Q.y * magnitudeReciprocal,
+                                       .z = Q.z * magnitudeReciprocal,
+                                   }};
+  return result;
 #undef Q
 }
 
@@ -434,15 +405,14 @@ static inline FusionQuaternion FusionQuaternionNormalise(const FusionQuaternion
  * @param vector Vector.
  * @return Multiplication of a matrix with a vector.
  */
-static inline FusionVector FusionMatrixMultiplyVector(const FusionMatrix matrix, const FusionVector 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;
+  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
 }
 
@@ -454,28 +424,27 @@ static inline FusionVector FusionMatrixMultiplyVector(const FusionMatrix matrix,
  * @param quaternion Quaternion.
  * @return Rotation matrix.
  */
-static inline FusionMatrix FusionQuaternionToMatrix(const FusionQuaternion quaternion)
-{
+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;
+  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
 }
 
@@ -484,16 +453,15 @@ static inline FusionMatrix FusionQuaternionToMatrix(const FusionQuaternion quate
  * @param quaternion Quaternion.
  * @return Euler angles in degrees.
  */
-static inline FusionEuler FusionQuaternionToEuler(const FusionQuaternion quaternion)
-{
+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;
+  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
 }
 

src/Fusion/FusionOffset.c

@@ -37,12 +37,11 @@
  * @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;
+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;
 }
 
 /**
@@ -52,28 +51,26 @@ void FusionOffsetInitialise(FusionOffset *const offset, const unsigned int sampl
  * @param gyroscope Gyroscope measurement in degrees per second.
  * @return Corrected gyroscope measurement in degrees per second.
  */
-FusionVector FusionOffsetUpdate(FusionOffset *const offset, FusionVector gyroscope)
-{
+FusionVector FusionOffsetUpdate(FusionOffset *const offset, FusionVector gyroscope) {
 
-    // Subtract offset from gyroscope measurement
-    gyroscope = FusionVectorSubtract(gyroscope, offset->gyroscopeOffset);
+  // 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));
+  // 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;
 }
 
 //------------------------------------------------------------------------------

src/Fusion/FusionOffset.h

@@ -21,10 +21,10 @@
  * internally and must not be accessed by the application.
  */
 typedef struct {
-    float filterCoefficient;
-    unsigned int timeout;
-    unsigned int timer;
-    FusionVector gyroscopeOffset;
+  float filterCoefficient;
+  unsigned int timeout;
+  unsigned int timer;
+  FusionVector gyroscopeOffset;
 } FusionOffset;
 
 //------------------------------------------------------------------------------

src/GPSStatus.h

@@ -4,136 +4,124 @@
 #include "configuration.h"
 #include <Arduino.h>
 
-namespace meshtastic
-{
+namespace meshtastic {
 
 /// Describes the state of the GPS system.
-class GPSStatus : public Status
-{
+class GPSStatus : public Status {
 
-  private:
-    CallbackObserver<GPSStatus, const GPSStatus *> statusObserver =
-        CallbackObserver<GPSStatus, const GPSStatus *>(this, &GPSStatus::updateStatus);
+private:
+  CallbackObserver<GPSStatus, const GPSStatus *> statusObserver = CallbackObserver<GPSStatus, const GPSStatus *>(this, &GPSStatus::updateStatus);
 
-    bool hasLock = false;     // default to false, until we complete our first read
-    bool isConnected = false; // Do we have a GPS we are talking to
+  bool hasLock = false;     // default to false, until we complete our first read
+  bool isConnected = false; // Do we have a GPS we are talking to
 
-    bool isPowerSaving = false; // Are we in power saving state
+  bool isPowerSaving = false; // Are we in power saving state
 
-    meshtastic_Position p = meshtastic_Position_init_default;
+  meshtastic_Position p = meshtastic_Position_init_default;
 
-    /// Time of last valid GPS fix (millis since boot)
-    uint32_t lastFixMillis = 0;
+  /// Time of last valid GPS fix (millis since boot)
+  uint32_t lastFixMillis = 0;
 
-  public:
-    GPSStatus() { statusType = STATUS_TYPE_GPS; }
+public:
+  GPSStatus() { statusType = STATUS_TYPE_GPS; }
 
-    // preferred method
-    GPSStatus(bool hasLock, bool isConnected, bool isPowerSaving, const meshtastic_Position &pos) : Status()
-    {
-        this->hasLock = hasLock;
-        this->isConnected = isConnected;
-        this->isPowerSaving = isPowerSaving;
+  // preferred method
+  GPSStatus(bool hasLock, bool isConnected, bool isPowerSaving, const meshtastic_Position &pos) : Status() {
+    this->hasLock = hasLock;
+    this->isConnected = isConnected;
+    this->isPowerSaving = isPowerSaving;
 
-        // all-in-one struct copy
-        this->p = pos;
+    // all-in-one struct copy
+    this->p = pos;
+  }
+
+  GPSStatus(const GPSStatus &);
+  GPSStatus &operator=(const GPSStatus &);
+
+  void observe(Observable<const GPSStatus *> *source) { statusObserver.observe(source); }
+
+  bool getHasLock() const { return hasLock; }
+
+  bool getIsConnected() const { return isConnected; }
+
+  bool getIsPowerSaving() const { return isPowerSaving; }
+
+  int32_t getLatitude() const {
+    if (config.position.fixed_position) {
+      meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+      return node->position.latitude_i;
+    } else {
+      return p.latitude_i;
     }
+  }
 
-    GPSStatus(const GPSStatus &);
-    GPSStatus &operator=(const GPSStatus &);
-
-    void observe(Observable<const GPSStatus *> *source) { statusObserver.observe(source); }
-
-    bool getHasLock() const { return hasLock; }
-
-    bool getIsConnected() const { return isConnected; }
-
-    bool getIsPowerSaving() const { return isPowerSaving; }
-
-    int32_t getLatitude() const
-    {
-        if (config.position.fixed_position) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node->position.latitude_i;
-        } else {
-            return p.latitude_i;
-        }
+  int32_t getLongitude() const {
+    if (config.position.fixed_position) {
+      meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+      return node->position.longitude_i;
+    } else {
+      return p.longitude_i;
     }
+  }
 
-    int32_t getLongitude() const
-    {
-        if (config.position.fixed_position) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node->position.longitude_i;
-        } else {
-            return p.longitude_i;
-        }
+  int32_t getAltitude() const {
+    if (config.position.fixed_position) {
+      meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+      return node->position.altitude;
+    } else {
+      return p.altitude;
     }
+  }
 
-    int32_t getAltitude() const
-    {
-        if (config.position.fixed_position) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node->position.altitude;
-        } else {
-            return p.altitude;
-        }
-    }
+  uint32_t getDOP() const { return p.PDOP; }
 
-    uint32_t getDOP() const { return p.PDOP; }
+  uint32_t getHeading() const { return p.ground_track; }
 
-    uint32_t getHeading() const { return p.ground_track; }
+  uint32_t getNumSatellites() const { return p.sats_in_view; }
 
-    uint32_t getNumSatellites() const { return p.sats_in_view; }
+  /// Return millis() when the last GPS fix occurred (0 = never)
+  uint32_t getLastFixMillis() const { return lastFixMillis; }
 
-    /// Return millis() when the last GPS fix occurred (0 = never)
-    uint32_t getLastFixMillis() const { return lastFixMillis; }
-
-    bool matches(const GPSStatus *newStatus) const
-    {
+  bool matches(const GPSStatus *newStatus) const {
 #ifdef GPS_DEBUG
-        LOG_DEBUG("GPSStatus.match() new pos@%x to old pos@%x", newStatus->p.timestamp, p.timestamp);
+    LOG_DEBUG("GPSStatus.match() new pos@%x to old pos@%x", newStatus->p.timestamp, p.timestamp);
 #endif
-        return (newStatus->hasLock != hasLock || newStatus->isConnected != isConnected ||
-                newStatus->isPowerSaving != isPowerSaving || newStatus->p.latitude_i != p.latitude_i ||
-                newStatus->p.longitude_i != p.longitude_i || newStatus->p.altitude != p.altitude ||
-                newStatus->p.altitude_hae != p.altitude_hae || newStatus->p.PDOP != p.PDOP ||
-                newStatus->p.ground_track != p.ground_track || newStatus->p.ground_speed != p.ground_speed ||
-                newStatus->p.sats_in_view != p.sats_in_view);
+    return (newStatus->hasLock != hasLock || newStatus->isConnected != isConnected || newStatus->isPowerSaving != isPowerSaving ||
+            newStatus->p.latitude_i != p.latitude_i || newStatus->p.longitude_i != p.longitude_i || newStatus->p.altitude != p.altitude ||
+            newStatus->p.altitude_hae != p.altitude_hae || newStatus->p.PDOP != p.PDOP || newStatus->p.ground_track != p.ground_track ||
+            newStatus->p.ground_speed != p.ground_speed || newStatus->p.sats_in_view != p.sats_in_view);
+  }
+
+  int updateStatus(const GPSStatus *newStatus) {
+    // Only update the status if values have actually changed
+    bool isDirty = matches(newStatus);
+
+    if (isDirty && p.timestamp && (newStatus->p.timestamp == p.timestamp)) {
+      // We can NEVER be in two locations at the same time! (also PR #886)
+      LOG_ERROR("BUG: Positional timestamp unchanged from prev solution");
     }
 
-    int updateStatus(const GPSStatus *newStatus)
-    {
-        // Only update the status if values have actually changed
-        bool isDirty = matches(newStatus);
+    initialized = true;
+    hasLock = newStatus->hasLock;
+    isConnected = newStatus->isConnected;
 
-        if (isDirty && p.timestamp && (newStatus->p.timestamp == p.timestamp)) {
-            // We can NEVER be in two locations at the same time! (also PR #886)
-            LOG_ERROR("BUG: Positional timestamp unchanged from prev solution");
-        }
+    p = newStatus->p;
 
-        initialized = true;
-        hasLock = newStatus->hasLock;
-        isConnected = newStatus->isConnected;
+    if (isDirty) {
+      if (hasLock) {
+        // Record time of last valid GPS fix
+        lastFixMillis = millis();
 
-        p = newStatus->p;
-
-        if (isDirty) {
-            if (hasLock) {
-                // Record time of last valid GPS fix
-                lastFixMillis = millis();
-
-                // 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", 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 {
-                LOG_DEBUG("No GPS lock");
-            }
-            onNewStatus.notifyObservers(this);
-        }
-        return 0;
+        // 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", 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 {
+        LOG_DEBUG("No GPS lock");
+      }
+      onNewStatus.notifyObservers(this);
     }
+    return 0;
+  }
 };
 
 } // namespace meshtastic

src/GpioLogic.cpp

@@ -1,102 +1,90 @@
 #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();
-    }
+void GpioVirtPin::set(bool value) {
+  if (value != this->value) {
+    this->value = value ? PinState::On : PinState::Off;
+    if (dependentPin)
+      dependentPin->update();
+  }
 }
 
-void GpioHwPin::set(bool value)
-{
-    pinMode(num, OUTPUT);
-    digitalWrite(num, value);
+void GpioHwPin::set(bool value) {
+  pinMode(num, OUTPUT);
+  digitalWrite(num, value);
 }
 
 GpioTransformer::GpioTransformer(GpioPin *outPin) : outPin(outPin) {}
 
-void GpioTransformer::set(bool value)
-{
-    outPin->set(value);
-}
+void GpioTransformer::set(bool value) { outPin->set(value); }
 
-GpioUnaryTransformer::GpioUnaryTransformer(GpioVirtPin *inPin, GpioPin *outPin) : GpioTransformer(outPin), inPin(inPin)
-{
-    assert(!inPin->dependentPin); // We only allow one dependent pin
-    inPin->dependentPin = this;
+GpioUnaryTransformer::GpioUnaryTransformer(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();
+  // 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 GpioUnaryTransformer::update()
-{
-    auto p = inPin->get();
-    if (p == GpioVirtPin::PinState::Unset)
-        return; // Not yet fully initialized
+void GpioUnaryTransformer::update() {
+  auto p = inPin->get();
+  if (p == GpioVirtPin::PinState::Unset)
+    return; // Not yet fully initialized
 
-    set(p);
+  set(p);
 }
 
 /**
  * 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
+void GpioNotTransformer::update() {
+  auto p = inPin->get();
+  if (p == GpioVirtPin::PinState::Unset)
+    return; // Not yet fully initialized
 
-    set(!p);
+  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;
+    : 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 initiated because
-    // order of operations for global constructors is not defined.
-    // update();
+  // Don't update at construction time, because various GpioPins might be global constructor based not yet initiated
+  // 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;
+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 (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);
-        }
+  // 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);
+  }
+  set(newValue);
 }
 
 GpioSplitter::GpioSplitter(GpioPin *outPin1, GpioPin *outPin2) : outPin1(outPin1), outPin2(outPin2) {}

src/GpioLogic.h

@@ -3,8 +3,9 @@
 #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.
+    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.
@@ -13,23 +14,21 @@
 /**
  * A logical GPIO pin (not necessary raw hardware).
  */
-class GpioPin
-{
-  public:
-    virtual void set(bool value) = 0;
+class GpioPin {
+public:
+  virtual void set(bool value) = 0;
 };
 
 /**
  * A physical GPIO hw pin.
  */
-class GpioHwPin : public GpioPin
-{
-    uint32_t num;
+class GpioHwPin : public GpioPin {
+  uint32_t num;
 
-  public:
-    explicit GpioHwPin(uint32_t num) : num(num) {}
+public:
+  explicit GpioHwPin(uint32_t num) : num(num) {}
 
-    void set(bool value);
+  void set(bool value);
 };
 
 class GpioTransformer;
@@ -39,122 +38,115 @@ class GpioBinaryTransformer;
 /**
  * A virtual GPIO pin.
  */
-class GpioVirtPin : public GpioPin
-{
-    friend class GpioBinaryTransformer;
-    friend class GpioUnaryTransformer;
+class GpioVirtPin : public GpioPin {
+  friend class GpioBinaryTransformer;
+  friend class GpioUnaryTransformer;
 
-  public:
-    enum PinState { On = true, Off = false, Unset = 2 };
+public:
+  enum PinState { On = true, Off = false, Unset = 2 };
 
-    void set(bool value);
-    PinState get() const { return value; }
+  void set(bool value);
+  PinState get() const { return value; }
 
-  private:
-    PinState value = PinState::Unset;
-    GpioTransformer *dependentPin = NULL;
+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)
+ * 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;
+class GpioTransformer {
+public:
+  /**
+   * Update the output pin based on the current state of the input pin.
+   */
+  virtual void update() = 0;
 
-  protected:
-    GpioTransformer(GpioPin *outPin);
+protected:
+  GpioTransformer(GpioPin *outPin);
 
-    void set(bool value);
+  void set(bool value);
 
-  private:
-    GpioPin *outPin;
+private:
+  GpioPin *outPin;
 };
 
 /**
  * A transformer that just drives a hw pin based on a virtual pin.
  */
-class GpioUnaryTransformer : public GpioTransformer
-{
-  public:
-    GpioUnaryTransformer(GpioVirtPin *inPin, GpioPin *outPin);
+class GpioUnaryTransformer : public GpioTransformer {
+public:
+  GpioUnaryTransformer(GpioVirtPin *inPin, GpioPin *outPin);
 
-  protected:
-    friend class GpioVirtPin;
+protected:
+  friend class GpioVirtPin;
 
-    /**
-     * Update the output pin based on the current state of the input pin.
-     */
-    virtual void update();
+  /**
+   * Update the output pin based on the current state of the input pin.
+   */
+  virtual void update();
 
-    GpioVirtPin *inPin;
+  GpioVirtPin *inPin;
 };
 
 /**
  * A transformer that performs a unary NOT operation from an input.
  */
-class GpioNotTransformer : public GpioUnaryTransformer
-{
-  public:
-    GpioNotTransformer(GpioVirtPin *inPin, GpioPin *outPin) : GpioUnaryTransformer(inPin, outPin) {}
+class GpioNotTransformer : public GpioUnaryTransformer {
+public:
+  GpioNotTransformer(GpioVirtPin *inPin, GpioPin *outPin) : GpioUnaryTransformer(inPin, outPin) {}
 
-  protected:
-    friend class GpioVirtPin;
+protected:
+  friend class GpioVirtPin;
 
-    /**
-     * Update the output pin based on the current state of the input pin.
-     */
-    void update();
+  /**
+   * Update the output pin based on the current state of the input pin.
+   */
+  void update();
 };
 
 /**
  * A transformer that combines multiple virtual pins to drive an output pin
  */
-class GpioBinaryTransformer : public GpioTransformer
-{
+class GpioBinaryTransformer : public GpioTransformer {
 
-  public:
-    enum Operation { And, Or, Xor };
+public:
+  enum Operation { And, Or, Xor };
 
-    GpioBinaryTransformer(GpioVirtPin *inPin1, GpioVirtPin *inPin2, GpioPin *outPin, Operation operation);
+  GpioBinaryTransformer(GpioVirtPin *inPin1, GpioVirtPin *inPin2, GpioPin *outPin, Operation operation);
 
-  protected:
-    friend class GpioVirtPin;
+protected:
+  friend class GpioVirtPin;
 
-    /**
-     * Update the output pin based on the current state of the input pins.
-     */
-    void update();
+  /**
+   * Update the output pin based on the current state of the input pins.
+   */
+  void update();
 
-  private:
-    GpioVirtPin *inPin1;
-    GpioVirtPin *inPin2;
-    Operation operation;
+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
-{
+class GpioSplitter : public GpioPin {
 
-  public:
-    GpioSplitter(GpioPin *outPin1, GpioPin *outPin2);
+public:
+  GpioSplitter(GpioPin *outPin1, GpioPin *outPin2);
 
-    void set(bool value)
-    {
-        outPin1->set(value);
-        outPin2->set(value);
-    }
+  void set(bool value) {
+    outPin1->set(value);
+    outPin2->set(value);
+  }
 
-  private:
-    GpioPin *outPin1;
-    GpioPin *outPin2;
+private:
+  GpioPin *outPin1;
+  GpioPin *outPin2;
 };

src/Led.cpp

@@ -23,16 +23,14 @@ static GpioPin &ledHwPin = ledRawHwPin;
 /**
  * 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);
-        }
+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
@@ -45,19 +43,17 @@ static GpioPin &ledFinalPin = ledHwPin;
 /**
  * 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);
+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;

src/MessageStore.cpp

@@ -0,0 +1,395 @@
+#include "configuration.h"
+#if HAS_SCREEN
+#include "FSCommon.h"
+#include "MessageStore.h"
+#include "NodeDB.h"
+#include "SPILock.h"
+#include "SafeFile.h"
+#include "gps/RTC.h"
+#include "graphics/draw/MessageRenderer.h"
+#include <cstring> // memcpy
+
+#ifndef MESSAGE_TEXT_POOL_SIZE
+#define MESSAGE_TEXT_POOL_SIZE (MAX_MESSAGES_SAVED * MAX_MESSAGE_SIZE)
+#endif
+
+// Global message text pool and state
+static char *g_messagePool = nullptr;
+static size_t g_poolWritePos = 0;
+
+// Reset pool (called on boot or clear)
+static inline void resetMessagePool() {
+  if (!g_messagePool) {
+    g_messagePool = static_cast<char *>(malloc(MESSAGE_TEXT_POOL_SIZE));
+    if (!g_messagePool) {
+      LOG_ERROR("MessageStore: Failed to allocate %d bytes for message pool", MESSAGE_TEXT_POOL_SIZE);
+      return;
+    }
+  }
+  g_poolWritePos = 0;
+  memset(g_messagePool, 0, MESSAGE_TEXT_POOL_SIZE);
+}
+
+// Allocate text in pool and return offset
+// If not enough space remains, wrap around (ring buffer style)
+static inline uint16_t storeTextInPool(const char *src, size_t len) {
+  if (len >= MAX_MESSAGE_SIZE)
+    len = MAX_MESSAGE_SIZE - 1;
+
+  // Wrap pool if out of space
+  if (g_poolWritePos + len + 1 >= MESSAGE_TEXT_POOL_SIZE) {
+    g_poolWritePos = 0;
+  }
+
+  uint16_t offset = g_poolWritePos;
+  memcpy(&g_messagePool[g_poolWritePos], src, len);
+  g_messagePool[g_poolWritePos + len] = '\0';
+  g_poolWritePos += (len + 1);
+  return offset;
+}
+
+// Retrieve a const pointer to message text by offset
+static inline const char *getTextFromPool(uint16_t offset) {
+  if (!g_messagePool || offset >= MESSAGE_TEXT_POOL_SIZE)
+    return "";
+  return &g_messagePool[offset];
+}
+
+// Helper: assign a timestamp (RTC if available, else boot-relative)
+static inline void assignTimestamp(StoredMessage &sm) {
+  uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+  if (nowSecs) {
+    sm.timestamp = nowSecs;
+    sm.isBootRelative = false;
+  } else {
+    sm.timestamp = millis() / 1000;
+    sm.isBootRelative = true;
+  }
+}
+
+// Generic push with cap (used by live + persisted queues)
+template <typename T> static inline void pushWithLimit(std::deque<T> &queue, const T &msg) {
+  if (queue.size() >= MAX_MESSAGES_SAVED)
+    queue.pop_front();
+  queue.push_back(msg);
+}
+
+template <typename T> static inline void pushWithLimit(std::deque<T> &queue, T &&msg) {
+  if (queue.size() >= MAX_MESSAGES_SAVED)
+    queue.pop_front();
+  queue.emplace_back(std::move(msg));
+}
+
+MessageStore::MessageStore(const std::string &label) {
+  filename = "/Messages_" + label + ".msgs";
+  resetMessagePool(); // initialize text pool on boot
+}
+
+// Live message handling (RAM only)
+void MessageStore::addLiveMessage(StoredMessage &&msg) { pushWithLimit(liveMessages, std::move(msg)); }
+void MessageStore::addLiveMessage(const StoredMessage &msg) { pushWithLimit(liveMessages, msg); }
+
+// Add from incoming/outgoing packet
+const StoredMessage &MessageStore::addFromPacket(const meshtastic_MeshPacket &packet) {
+  StoredMessage sm;
+  assignTimestamp(sm);
+  sm.channelIndex = packet.channel;
+
+  const char *payload = reinterpret_cast<const char *>(packet.decoded.payload.bytes);
+  size_t len = strnlen(payload, MAX_MESSAGE_SIZE - 1);
+  sm.textOffset = storeTextInPool(payload, len);
+  sm.textLength = len;
+
+  // Determine sender
+  uint32_t localNode = nodeDB->getNodeNum();
+  sm.sender = (packet.from == 0) ? localNode : packet.from;
+
+  sm.dest = packet.to;
+
+  bool isDM = (sm.dest != 0 && sm.dest != NODENUM_BROADCAST);
+
+  if (packet.from == 0) {
+    sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+    sm.ackStatus = AckStatus::NONE;
+  } else {
+    sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+    sm.ackStatus = AckStatus::ACKED;
+  }
+
+  addLiveMessage(sm);
+  return liveMessages.back();
+}
+
+// Outgoing/manual message
+void MessageStore::addFromString(uint32_t sender, uint8_t channelIndex, const std::string &text) {
+  StoredMessage sm;
+
+  // Always use our local time (helper handles RTC vs boot time)
+  assignTimestamp(sm);
+
+  sm.sender = sender;
+  sm.channelIndex = channelIndex;
+  sm.textOffset = storeTextInPool(text.c_str(), text.size());
+  sm.textLength = text.size();
+
+  // Use the provided destination
+  sm.dest = sender;
+  sm.type = MessageType::DM_TO_US;
+
+  // Outgoing messages always start with unknown ack status
+  sm.ackStatus = AckStatus::NONE;
+
+  addLiveMessage(sm);
+}
+
+#if ENABLE_MESSAGE_PERSISTENCE
+
+// Compact, fixed-size on-flash representation using offset + length
+struct __attribute__((packed)) StoredMessageRecord {
+  uint32_t timestamp;
+  uint32_t sender;
+  uint8_t channelIndex;
+  uint32_t dest;
+  uint8_t isBootRelative;
+  uint8_t ackStatus;           // static_cast<uint8_t>(AckStatus)
+  uint8_t type;                // static_cast<uint8_t>(MessageType)
+  uint16_t textLength;         // message length
+  char text[MAX_MESSAGE_SIZE]; // store actual text here
+};
+
+// Serialize one StoredMessage to flash
+static inline void writeMessageRecord(SafeFile &f, const StoredMessage &m) {
+  StoredMessageRecord rec = {};
+  rec.timestamp = m.timestamp;
+  rec.sender = m.sender;
+  rec.channelIndex = m.channelIndex;
+  rec.dest = m.dest;
+  rec.isBootRelative = m.isBootRelative;
+  rec.ackStatus = static_cast<uint8_t>(m.ackStatus);
+  rec.type = static_cast<uint8_t>(m.type);
+  rec.textLength = m.textLength;
+
+  // Copy the actual text into the record from RAM pool
+  const char *txt = getTextFromPool(m.textOffset);
+  strncpy(rec.text, txt, MAX_MESSAGE_SIZE - 1);
+  rec.text[MAX_MESSAGE_SIZE - 1] = '\0';
+
+  f.write(reinterpret_cast<const uint8_t *>(&rec), sizeof(rec));
+}
+
+// Deserialize one StoredMessage from flash; returns false on short read
+static inline bool readMessageRecord(File &f, StoredMessage &m) {
+  StoredMessageRecord rec = {};
+  if (f.readBytes(reinterpret_cast<char *>(&rec), sizeof(rec)) != sizeof(rec))
+    return false;
+
+  m.timestamp = rec.timestamp;
+  m.sender = rec.sender;
+  m.channelIndex = rec.channelIndex;
+  m.dest = rec.dest;
+  m.isBootRelative = rec.isBootRelative;
+  m.ackStatus = static_cast<AckStatus>(rec.ackStatus);
+  m.type = static_cast<MessageType>(rec.type);
+  m.textLength = rec.textLength;
+
+  // 💡 Re-store text into pool and update offset
+  m.textLength = strnlen(rec.text, MAX_MESSAGE_SIZE - 1);
+  m.textOffset = storeTextInPool(rec.text, m.textLength);
+
+  return true;
+}
+
+void MessageStore::saveToFlash() {
+#ifdef FSCom
+  // Ensure root exists
+  spiLock->lock();
+  FSCom.mkdir("/");
+  spiLock->unlock();
+
+  SafeFile f(filename.c_str(), false);
+
+  spiLock->lock();
+  uint8_t count = static_cast<uint8_t>(liveMessages.size());
+  if (count > MAX_MESSAGES_SAVED)
+    count = MAX_MESSAGES_SAVED;
+  f.write(&count, 1);
+
+  for (uint8_t i = 0; i < count; ++i) {
+    writeMessageRecord(f, liveMessages[i]);
+  }
+  spiLock->unlock();
+
+  f.close();
+#endif
+}
+
+void MessageStore::loadFromFlash() {
+  std::deque<StoredMessage>().swap(liveMessages);
+  resetMessagePool(); // reset pool when loading
+
+#ifdef FSCom
+  concurrency::LockGuard guard(spiLock);
+
+  if (!FSCom.exists(filename.c_str()))
+    return;
+
+  auto f = FSCom.open(filename.c_str(), FILE_O_READ);
+  if (!f)
+    return;
+
+  uint8_t count = 0;
+  f.readBytes(reinterpret_cast<char *>(&count), 1);
+  if (count > MAX_MESSAGES_SAVED)
+    count = MAX_MESSAGES_SAVED;
+
+  for (uint8_t i = 0; i < count; ++i) {
+    StoredMessage m;
+    if (!readMessageRecord(f, m))
+      break;
+    liveMessages.push_back(m);
+  }
+
+  f.close();
+#endif
+}
+
+#else
+// If persistence is disabled, these functions become no-ops
+void MessageStore::saveToFlash() {}
+void MessageStore::loadFromFlash() {}
+#endif
+
+// Clear all messages (RAM + persisted queue)
+void MessageStore::clearAllMessages() {
+  std::deque<StoredMessage>().swap(liveMessages);
+  resetMessagePool();
+
+#ifdef FSCom
+  SafeFile f(filename.c_str(), false);
+  uint8_t count = 0;
+  f.write(&count, 1); // write "0 messages"
+  f.close();
+#endif
+}
+
+// Internal helper: erase first or last message matching a predicate
+template <typename Predicate> static void eraseIf(std::deque<StoredMessage> &deque, Predicate pred, bool fromBack = false) {
+  if (fromBack) {
+    // Iterate from the back and erase all matches from the end
+    for (auto it = deque.rbegin(); it != deque.rend();) {
+      if (pred(*it)) {
+        it = std::deque<StoredMessage>::reverse_iterator(deque.erase(std::next(it).base()));
+      } else {
+        ++it;
+      }
+    }
+  } else {
+    // Manual forward search to erase all matches
+    for (auto it = deque.begin(); it != deque.end();) {
+      if (pred(*it)) {
+        it = deque.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+}
+
+// Delete oldest message (RAM + persisted queue)
+void MessageStore::deleteOldestMessage() {
+  eraseIf(liveMessages, [](StoredMessage &) { return true; });
+  saveToFlash();
+}
+
+// Delete oldest message in a specific channel
+void MessageStore::deleteOldestMessageInChannel(uint8_t channel) {
+  auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
+  eraseIf(liveMessages, pred);
+  saveToFlash();
+}
+
+void MessageStore::deleteAllMessagesInChannel(uint8_t channel) {
+  auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
+  eraseIf(liveMessages, pred, false /* delete ALL, not just first */);
+  saveToFlash();
+}
+
+void MessageStore::deleteAllMessagesWithPeer(uint32_t peer) {
+  uint32_t local = nodeDB->getNodeNum();
+  auto pred = [&](const StoredMessage &m) {
+    if (m.type != MessageType::DM_TO_US)
+      return false;
+    uint32_t other = (m.sender == local) ? m.dest : m.sender;
+    return other == peer;
+  };
+  eraseIf(liveMessages, pred, false);
+  saveToFlash();
+}
+
+// Delete oldest message in a direct chat with a node
+void MessageStore::deleteOldestMessageWithPeer(uint32_t peer) {
+  auto pred = [peer](const StoredMessage &m) {
+    if (m.type != MessageType::DM_TO_US)
+      return false;
+    uint32_t other = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
+    return other == peer;
+  };
+  eraseIf(liveMessages, pred);
+  saveToFlash();
+}
+
+std::deque<StoredMessage> MessageStore::getChannelMessages(uint8_t channel) const {
+  std::deque<StoredMessage> result;
+  for (const auto &m : liveMessages) {
+    if (m.type == MessageType::BROADCAST && m.channelIndex == channel) {
+      result.push_back(m);
+    }
+  }
+  return result;
+}
+
+std::deque<StoredMessage> MessageStore::getDirectMessages() const {
+  std::deque<StoredMessage> result;
+  for (const auto &m : liveMessages) {
+    if (m.type == MessageType::DM_TO_US) {
+      result.push_back(m);
+    }
+  }
+  return result;
+}
+
+// Upgrade boot-relative timestamps once RTC is valid
+// Only same-boot boot-relative messages are healed.
+// Persisted boot-relative messages from old boots stay ??? forever.
+void MessageStore::upgradeBootRelativeTimestamps() {
+  uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+  if (nowSecs == 0)
+    return; // Still no valid RTC
+
+  uint32_t bootNow = millis() / 1000;
+
+  auto fix = [&](std::deque<StoredMessage> &dq) {
+    for (auto &m : dq) {
+      if (m.isBootRelative && m.timestamp <= bootNow) {
+        uint32_t bootOffset = nowSecs - bootNow;
+        m.timestamp += bootOffset;
+        m.isBootRelative = false;
+      }
+    }
+  };
+  fix(liveMessages);
+}
+
+const char *MessageStore::getText(const StoredMessage &msg) {
+  // Wrapper around the internal helper
+  return getTextFromPool(msg.textOffset);
+}
+
+uint16_t MessageStore::storeText(const char *src, size_t len) {
+  // Wrapper around the internal helper
+  return storeTextInPool(src, len);
+}
+
+// Global definition
+MessageStore messageStore("default");
+#endif

src/MessageStore.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#if HAS_SCREEN
+
+// Disable debug logging entirely on release builds of HELTEC_MESH_SOLAR for space constraints
+#if defined(HELTEC_MESH_SOLAR)
+#define LOG_DEBUG(...)
+#endif
+
+// Enable or disable message persistence (flash storage)
+// Define -DENABLE_MESSAGE_PERSISTENCE=0 in build_flags to disable it entirely
+#ifndef ENABLE_MESSAGE_PERSISTENCE
+#define ENABLE_MESSAGE_PERSISTENCE 1
+#endif
+
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include <cstdint>
+#include <deque>
+#include <string>
+
+// How many messages are stored (RAM + flash).
+// Define -DMESSAGE_HISTORY_LIMIT=N in build_flags to control memory usage.
+#ifndef MESSAGE_HISTORY_LIMIT
+#define MESSAGE_HISTORY_LIMIT 20
+#endif
+
+// Internal alias used everywhere in code – do NOT redefine elsewhere.
+#define MAX_MESSAGES_SAVED MESSAGE_HISTORY_LIMIT
+
+// Maximum text payload size per message in bytes.
+// This still defines the max message length, but we no longer reserve this space per message.
+#define MAX_MESSAGE_SIZE 220
+
+// Total shared text pool size for all messages combined.
+// The text pool is RAM-only. Text is re-stored from flash into the pool on boot.
+#ifndef MESSAGE_TEXT_POOL_SIZE
+#define MESSAGE_TEXT_POOL_SIZE (MAX_MESSAGES_SAVED * MAX_MESSAGE_SIZE)
+#endif
+
+// Explicit message classification
+enum class MessageType : uint8_t {
+  BROADCAST = 0, // broadcast message
+  DM_TO_US = 1   // direct message addressed to this node
+};
+
+// Delivery status for messages we sent
+enum class AckStatus : uint8_t {
+  NONE = 0,    // just sent, waiting (no symbol shown)
+  ACKED = 1,   // got a valid ACK from destination
+  NACKED = 2,  // explicitly failed
+  TIMEOUT = 3, // no ACK after retry window
+  RELAYED = 4  // got an ACK from relay, not destination
+};
+
+struct StoredMessage {
+  uint32_t timestamp;   // When message was created (secs since boot or RTC)
+  uint32_t sender;      // NodeNum of sender
+  uint8_t channelIndex; // Channel index used
+  uint32_t dest;        // Destination node (broadcast or direct)
+  MessageType type;     // Derived from dest (explicit classification)
+  bool isBootRelative;  // true = millis()/1000 fallback; false = epoch/RTC absolute
+  AckStatus ackStatus;  // Delivery status (only meaningful for our own sent messages)
+
+  // Text storage metadata — rebuilt from flash at boot
+  uint16_t textOffset; // Offset into global text pool (valid only after loadFromFlash())
+  uint16_t textLength; // Length of text in bytes
+
+  // Default constructor initializes all fields safely
+  StoredMessage()
+      : timestamp(0), sender(0), channelIndex(0), dest(0xffffffff), type(MessageType::BROADCAST), isBootRelative(false), ackStatus(AckStatus::NONE),
+        textOffset(0), textLength(0) {}
+};
+
+class MessageStore {
+public:
+  explicit MessageStore(const std::string &label);
+
+  // Live RAM methods (always current, used by UI and runtime)
+  void addLiveMessage(StoredMessage &&msg);
+  void addLiveMessage(const StoredMessage &msg); // convenience overload
+  const std::deque<StoredMessage> &getLiveMessages() const { return liveMessages; }
+
+  // Add new messages from packets or manual input
+  const StoredMessage &addFromPacket(const meshtastic_MeshPacket &mp);                // Incoming/outgoing → RAM only
+  void addFromString(uint32_t sender, uint8_t channelIndex, const std::string &text); // Manual add
+
+  // Persistence methods (used only on boot/shutdown)
+  void saveToFlash();   // Save messages to flash
+  void loadFromFlash(); // Load messages from flash
+
+  // Clear all messages (RAM + persisted queue + text pool)
+  void clearAllMessages();
+
+  // Delete helpers
+  void deleteOldestMessage(); // remove oldest from RAM (and flash on save)
+  void deleteOldestMessageInChannel(uint8_t channel);
+  void deleteOldestMessageWithPeer(uint32_t peer);
+  void deleteAllMessagesInChannel(uint8_t channel);
+  void deleteAllMessagesWithPeer(uint32_t peer);
+
+  // Unified accessor (for UI code, defaults to RAM buffer)
+  const std::deque<StoredMessage> &getMessages() const { return liveMessages; }
+
+  // Helper filters for future use
+  std::deque<StoredMessage> getChannelMessages(uint8_t channel) const; // Only broadcast messages on a channel
+  std::deque<StoredMessage> getDirectMessages() const;                 // Only direct messages
+
+  // Upgrade boot-relative timestamps once RTC is valid
+  void upgradeBootRelativeTimestamps();
+
+  // Retrieve the C-string text for a stored message
+  static const char *getText(const StoredMessage &msg);
+
+  // Allocate text into pool (used by sender-side code)
+  static uint16_t storeText(const char *src, size_t len);
+
+  // Used when loading from flash to rebuild the text pool
+  static uint16_t rebuildTextFromFlash(const char *src, size_t len);
+
+private:
+  std::deque<StoredMessage> liveMessages; // Single in-RAM message buffer (also used for persistence)
+  std::string filename;                   // Flash filename for persistence
+};
+
+// Global instance (defined in MessageStore.cpp)
+extern MessageStore messageStore;
+
+#endif

src/NodeStatus.h

@@ -3,64 +3,56 @@
 #include "configuration.h"
 #include <Arduino.h>
 
-namespace meshtastic
-{
+namespace meshtastic {
 
 /// Describes the state of the NodeDB system.
-class NodeStatus : public Status
-{
+class NodeStatus : public Status {
 
-  private:
-    CallbackObserver<NodeStatus, const NodeStatus *> statusObserver =
-        CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);
+private:
+  CallbackObserver<NodeStatus, const NodeStatus *> statusObserver = CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);
 
-    uint16_t numOnline = 0;
-    uint16_t numTotal = 0;
+  uint16_t numOnline = 0;
+  uint16_t numTotal = 0;
 
-    uint16_t lastNumTotal = 0;
+  uint16_t lastNumTotal = 0;
 
-  public:
-    bool forceUpdate = false;
+public:
+  bool forceUpdate = false;
 
-    NodeStatus() { statusType = STATUS_TYPE_NODE; }
-    NodeStatus(uint16_t numOnline, uint16_t numTotal, bool forceUpdate = false) : Status()
+  NodeStatus() { statusType = STATUS_TYPE_NODE; }
+  NodeStatus(uint16_t numOnline, uint16_t numTotal, bool forceUpdate = false) : Status() {
+    this->forceUpdate = forceUpdate;
+    this->numOnline = numOnline;
+    this->numTotal = numTotal;
+  }
+  NodeStatus(const NodeStatus &);
+  NodeStatus &operator=(const NodeStatus &);
+
+  void observe(Observable<const NodeStatus *> *source) { statusObserver.observe(source); }
+
+  uint16_t getNumOnline() const { return numOnline; }
+
+  uint16_t getNumTotal() const { return numTotal; }
+
+  uint16_t getLastNumTotal() const { return lastNumTotal; }
+
+  bool matches(const NodeStatus *newStatus) const { return (newStatus->getNumOnline() != numOnline || newStatus->getNumTotal() != numTotal); }
+  int updateStatus(const NodeStatus *newStatus) {
+    // Only update the status if values have actually changed
+    lastNumTotal = numTotal;
+    bool isDirty;
     {
-        this->forceUpdate = forceUpdate;
-        this->numOnline = numOnline;
-        this->numTotal = numTotal;
+      isDirty = matches(newStatus);
+      initialized = true;
+      numOnline = newStatus->getNumOnline();
+      numTotal = newStatus->getNumTotal();
     }
-    NodeStatus(const NodeStatus &);
-    NodeStatus &operator=(const NodeStatus &);
-
-    void observe(Observable<const NodeStatus *> *source) { statusObserver.observe(source); }
-
-    uint16_t getNumOnline() const { return numOnline; }
-
-    uint16_t getNumTotal() const { return numTotal; }
-
-    uint16_t getLastNumTotal() const { return lastNumTotal; }
-
-    bool matches(const NodeStatus *newStatus) const
-    {
-        return (newStatus->getNumOnline() != numOnline || newStatus->getNumTotal() != numTotal);
-    }
-    int updateStatus(const NodeStatus *newStatus)
-    {
-        // Only update the status if values have actually changed
-        lastNumTotal = numTotal;
-        bool isDirty;
-        {
-            isDirty = matches(newStatus);
-            initialized = true;
-            numOnline = newStatus->getNumOnline();
-            numTotal = newStatus->getNumTotal();
-        }
-        if (isDirty || newStatus->forceUpdate) {
-            LOG_DEBUG("Node status update: %u online, %u total", numOnline, numTotal);
-            onNewStatus.notifyObservers(this);
-        }
-        return 0;
+    if (isDirty || newStatus->forceUpdate) {
+      LOG_DEBUG("Node status update: %u online, %u total", numOnline, numTotal);
+      onNewStatus.notifyObservers(this);
     }
+    return 0;
+  }
 };
 
 } // namespace meshtastic

src/Observer.h

@@ -8,99 +8,90 @@ template <class T> class Observable;
 /**
  * An observer which can be mixed in as a baseclass.  Implement onNotify as a method in your class.
  */
-template <class T> class Observer
-{
-    std::list<Observable<T> *> observables;
+template <class T> class Observer {
+  std::list<Observable<T> *> observables;
 
-  public:
-    virtual ~Observer();
+public:
+  virtual ~Observer();
 
-    /// Stop watching the observable
-    void unobserve(Observable<T> *o);
+  /// Stop watching the observable
+  void unobserve(Observable<T> *o);
 
-    /// Start watching a specified observable
-    void observe(Observable<T> *o);
+  /// Start watching a specified observable
+  void observe(Observable<T> *o);
 
-  private:
-    friend class Observable<T>;
+private:
+  friend class Observable<T>;
 
-  protected:
-    /**
-     * returns 0 if other observers should continue to be called
-     * returns !0 if the observe calls should be aborted and this result code returned for notifyObservers
-     **/
-    virtual int onNotify(T arg) = 0;
+protected:
+  /**
+   * returns 0 if other observers should continue to be called
+   * returns !0 if the observe calls should be aborted and this result code returned for notifyObservers
+   **/
+  virtual int onNotify(T arg) = 0;
 };
 
 /**
  * An observer that calls an arbitrary method
  */
-template <class Callback, class T> class CallbackObserver : public Observer<T>
-{
-    typedef int (Callback::*ObserverCallback)(T arg);
+template <class Callback, class T> class CallbackObserver : public Observer<T> {
+  typedef int (Callback::*ObserverCallback)(T arg);
 
-    Callback *objPtr;
-    ObserverCallback method;
+  Callback *objPtr;
+  ObserverCallback method;
 
-  public:
-    CallbackObserver(Callback *_objPtr, ObserverCallback _method) : objPtr(_objPtr), method(_method) {}
+public:
+  CallbackObserver(Callback *_objPtr, ObserverCallback _method) : objPtr(_objPtr), method(_method) {}
 
-  protected:
-    virtual int onNotify(T arg) override { return (objPtr->*method)(arg); }
+protected:
+  virtual int onNotify(T arg) override { return (objPtr->*method)(arg); }
 };
 
 /**
- * An observable class that will notify observers anytime notifyObservers is called.  Argument type T can be any type, but for
- * performance reasons a pointer or word sized object is recommended.
+ * An observable class that will notify observers anytime notifyObservers is called.  Argument type T can be any type,
+ * but for performance reasons a pointer or word sized object is recommended.
  */
-template <class T> class Observable
-{
-    std::list<Observer<T> *> observers;
+template <class T> class Observable {
+  std::list<Observer<T> *> observers;
 
-  public:
-    /**
-     * Tell all observers about a change, observers can process arg as they wish
-     *
-     * returns !0 if an observer chose to abort processing by returning this code
-     */
-    int notifyObservers(T arg)
-    {
-        for (typename std::list<Observer<T> *>::const_iterator iterator = observers.begin(); iterator != observers.end();
-             ++iterator) {
-            int result = (*iterator)->onNotify(arg);
-            if (result != 0)
-                return result;
-        }
-
-        return 0;
+public:
+  /**
+   * Tell all observers about a change, observers can process arg as they wish
+   *
+   * returns !0 if an observer chose to abort processing by returning this code
+   */
+  int notifyObservers(T arg) {
+    for (typename std::list<Observer<T> *>::const_iterator iterator = observers.begin(); iterator != observers.end(); ++iterator) {
+      int result = (*iterator)->onNotify(arg);
+      if (result != 0)
+        return result;
     }
 
-  private:
-    friend class Observer<T>;
+    return 0;
+  }
 
-    // Not called directly, instead call observer.observe
-    void addObserver(Observer<T> *o) { observers.push_back(o); }
+private:
+  friend class Observer<T>;
 
-    void removeObserver(Observer<T> *o) { observers.remove(o); }
+  // Not called directly, instead call observer.observe
+  void addObserver(Observer<T> *o) { observers.push_back(o); }
+
+  void removeObserver(Observer<T> *o) { observers.remove(o); }
 };
 
-template <class T> Observer<T>::~Observer()
-{
-    for (typename std::list<Observable<T> *>::const_iterator iterator = observables.begin(); iterator != observables.end();
-         ++iterator) {
-        (*iterator)->removeObserver(this);
-    }
-    observables.clear();
+template <class T> Observer<T>::~Observer() {
+  for (typename std::list<Observable<T> *>::const_iterator iterator = observables.begin(); iterator != observables.end(); ++iterator) {
+    (*iterator)->removeObserver(this);
+  }
+  observables.clear();
 }
 
-template <class T> void Observer<T>::unobserve(Observable<T> *o)
-{
-    o->removeObserver(this);
-    observables.remove(o);
+template <class T> void Observer<T>::unobserve(Observable<T> *o) {
+  o->removeObserver(this);
+  observables.remove(o);
 }
 
-template <class T> void Observer<T>::observe(Observable<T> *o)
-{
-    observables.push_back(o);
-    o->addObserver(this);
+template <class T> void Observer<T>::observe(Observable<T> *o) {
+  observables.push_back(o);
+  o->addObserver(this);
 }

src/PowerFSM.cpp

@@ -31,222 +31,202 @@ FakeFsm powerFSM;
 void PowerFSM_setup(){};
 #else
 /// Should we behave as if we have AC power now?
-static bool isPowered()
-{
+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) && !defined(NRF_APM)
-    return true;
+  return true;
 #endif
 
-    bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
+  bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
 
-    // If we are not a router and we already have AC power go to POWER state after init, otherwise go to ON
-    // We assume routers might be powered all the time, but from a low current (solar) source
-    bool isPowerSavingMode = config.power.is_power_saving || isRouter;
+  // If we are not a router and we already have AC power go to POWER state after init, otherwise go to ON
+  // We assume routers might be powered all the time, but from a low current (solar) source
+  bool isPowerSavingMode = config.power.is_power_saving || isRouter;
 
-    /* To determine if we're externally powered, assumptions
-        1) If we're powered up and there's no battery, we must be getting power externally. (because we'd be dead otherwise)
+  /* To determine if we're externally powered, assumptions
+      1) If we're powered up and there's no battery, we must be getting power externally. (because we'd be dead
+     otherwise)
 
-        2) If we detect USB power from the power management chip, we must be getting power externally.
+      2) If we detect USB power from the power management chip, we must be getting power externally.
 
-        3) On some boards we don't have the power management chip (like AXPxxxx) so we use EXT_PWR_DETECT GPIO pin to detect
-       external power source (see `isVbusIn()` in `Power.cpp`)
-    */
-    return !isPowerSavingMode && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
+      3) On some boards we don't have the power management chip (like AXPxxxx) so we use EXT_PWR_DETECT GPIO pin to
+     detect external power source (see `isVbusIn()` in `Power.cpp`)
+  */
+  return !isPowerSavingMode && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
 }
 
-static void sdsEnter()
-{
-    LOG_POWERFSM("State: SDS");
-    // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
-    doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false, false);
+static void sdsEnter() {
+  LOG_POWERFSM("State: SDS");
+  // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
+  doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false, false);
 }
 
-static void lowBattSDSEnter()
-{
-    LOG_POWERFSM("State: Lower batt SDS");
-    doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false, true);
+static void lowBattSDSEnter() {
+  LOG_POWERFSM("State: Lower batt SDS");
+  doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false, true);
 }
 extern Power *power;
 
-static void shutdownEnter()
-{
-    LOG_POWERFSM("State: SHUTDOWN");
-    shutdownAtMsec = millis();
+static void shutdownEnter() {
+  LOG_POWERFSM("State: SHUTDOWN");
+  shutdownAtMsec = millis();
 }
 
 #include "error.h"
 
 static uint32_t secsSlept;
 
-static void lsEnter()
-{
-    LOG_POWERFSM("lsEnter begin, ls_secs=%u", config.power.ls_secs);
-    if (screen)
-        screen->setOn(false);
-    secsSlept = 0; // How long have we been sleeping this time
+static void lsEnter() {
+  LOG_POWERFSM("lsEnter begin, ls_secs=%u", config.power.ls_secs);
+  if (screen)
+    screen->setOn(false);
+  secsSlept = 0; // How long have we been sleeping this time
 
-    // LOG_INFO("lsEnter end");
+  // LOG_INFO("lsEnter end");
 }
 
-static void lsIdle()
-{
-    // LOG_INFO("lsIdle begin ls_secs=%u", getPref_ls_secs());
+static void lsIdle() {
+  // LOG_INFO("lsIdle begin ls_secs=%u", getPref_ls_secs());
 
 #ifdef ARCH_ESP32
 
-    // Do we have more sleeping to do?
-    if (secsSlept < config.power.ls_secs) {
-        // If some other service would stall sleep, don't let sleep happen yet
-        if (doPreflightSleep()) {
-            // Briefly come out of sleep long enough to blink the led once every few seconds
-            uint32_t sleepTime = SLEEP_TIME;
+  // Do we have more sleeping to do?
+  if (secsSlept < config.power.ls_secs) {
+    // If some other service would stall sleep, don't let sleep happen yet
+    if (doPreflightSleep()) {
+      // Briefly come out of sleep long enough to blink the led once every few seconds
+      uint32_t sleepTime = SLEEP_TIME;
 
-            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);
+      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
+      switch (wakeCause2) {
+      case ESP_SLEEP_WAKEUP_TIMER:
+        // Normal case: timer expired, we should just go back to sleep ASAP
 
-                ledBlink.set(true);             // briefly turn on led
-                wakeCause2 = doLightSleep(100); // leave led on for 1ms
+        ledBlink.set(true);             // briefly turn on led
+        wakeCause2 = doLightSleep(100); // leave led on for 1ms
 
-                secsSlept += sleepTime;
-                // LOG_INFO("Sleep, flash led!");
-                break;
+        secsSlept += sleepTime;
+        // LOG_INFO("Sleep, flash led!");
+        break;
 
-            case ESP_SLEEP_WAKEUP_UART:
-                // Not currently used (because uart triggers in hw have problems)
-                powerFSM.trigger(EVENT_SERIAL_CONNECTED);
-                break;
+      case ESP_SLEEP_WAKEUP_UART:
+        // Not currently used (because uart triggers in hw have problems)
+        powerFSM.trigger(EVENT_SERIAL_CONNECTED);
+        break;
 
-            default:
-                // We woke for some other reason (button press, device IRQ interrupt)
+      default:
+        // We woke for some other reason (button press, device IRQ interrupt)
 
 #ifdef BUTTON_PIN
-                bool pressed = !digitalRead(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN);
+        bool pressed = !digitalRead(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN);
 #else
-                bool pressed = false;
+        bool pressed = false;
 #endif
-                if (pressed) { // If we woke because of press, instead generate a PRESS event.
-                    powerFSM.trigger(EVENT_PRESS);
-                } else {
-                    // Otherwise let the NB state handle the IRQ (and that state will handle stuff like IRQs etc)
-                    // we lie and say "wake timer" because the interrupt will be handled by the regular IRQ code
-                    powerFSM.trigger(EVENT_WAKE_TIMER);
-                }
-                break;
-            }
+        if (pressed) { // If we woke because of press, instead generate a PRESS event.
+          powerFSM.trigger(EVENT_PRESS);
         } else {
-            // Someone says we can't sleep now, so just save some power by sleeping the CPU for 100ms or so
-            delay(100);
+          // Otherwise let the NB state handle the IRQ (and that state will handle stuff like IRQs etc)
+          // we lie and say "wake timer" because the interrupt will be handled by the regular IRQ code
+          powerFSM.trigger(EVENT_WAKE_TIMER);
         }
+        break;
+      }
     } else {
-        // Time to stop sleeping!
-        ledBlink.set(false);
-        LOG_INFO("Reached ls_secs, service loop()");
-        powerFSM.trigger(EVENT_WAKE_TIMER);
+      // Someone says we can't sleep now, so just save some power by sleeping the CPU for 100ms or so
+      delay(100);
     }
+  } else {
+    // Time to stop sleeping!
+    ledBlink.set(false);
+    LOG_INFO("Reached ls_secs, service loop()");
+    powerFSM.trigger(EVENT_WAKE_TIMER);
+  }
 #endif
 }
 
-static void lsExit()
-{
-    LOG_POWERFSM("State: lsExit");
-}
+static void lsExit() { LOG_POWERFSM("State: lsExit"); }
 
-static void nbEnter()
-{
-    LOG_POWERFSM("State: nbEnter");
-    if (screen)
-        screen->setOn(false);
+static void nbEnter() {
+  LOG_POWERFSM("State: nbEnter");
+  if (screen)
+    screen->setOn(false);
 #ifdef ARCH_ESP32
-    // Only ESP32 should turn off bluetooth
-    setBluetoothEnable(false);
+  // Only ESP32 should turn off bluetooth
+  setBluetoothEnable(false);
 #endif
 
-    // FIXME - check if we already have packets for phone and immediately trigger EVENT_PACKETS_FOR_PHONE
+  // FIXME - check if we already have packets for phone and immediately trigger EVENT_PACKETS_FOR_PHONE
 }
 
-static void darkEnter()
-{
-    LOG_POWERFSM("State: darkEnter");
-    setBluetoothEnable(true);
+static void darkEnter() {
+  LOG_POWERFSM("State: darkEnter");
+  setBluetoothEnable(true);
+  if (screen)
+    screen->setOn(false);
+}
+
+static void serialEnter() {
+  LOG_POWERFSM("State: serialEnter");
+  setBluetoothEnable(false);
+  if (screen) {
+    screen->setOn(true);
+  }
+}
+
+static void serialExit() {
+  LOG_POWERFSM("State: serialExit");
+  // Turn bluetooth back on when we leave serial stream API
+  setBluetoothEnable(true);
+}
+
+static void powerEnter() {
+  LOG_POWERFSM("State: powerEnter");
+  if (!isPowered()) {
+    // If we got here, we are in the wrong state - we should be in powered, let that state handle things
+    LOG_INFO("Loss of power in Powered");
+    powerFSM.trigger(EVENT_POWER_DISCONNECTED);
+  } else {
     if (screen)
-        screen->setOn(false);
-}
-
-static void serialEnter()
-{
-    LOG_POWERFSM("State: serialEnter");
-    setBluetoothEnable(false);
-    if (screen) {
-        screen->setOn(true);
-    }
-}
-
-static void serialExit()
-{
-    LOG_POWERFSM("State: serialExit");
-    // Turn bluetooth back on when we leave serial stream API
+      screen->setOn(true);
     setBluetoothEnable(true);
+    // within enter() the function getState() returns the state we came from
+  }
 }
 
-static void powerEnter()
-{
-    LOG_POWERFSM("State: powerEnter");
-    if (!isPowered()) {
-        // If we got here, we are in the wrong state - we should be in powered, let that state handle things
-        LOG_INFO("Loss of power in Powered");
-        powerFSM.trigger(EVENT_POWER_DISCONNECTED);
-    } else {
-        if (screen)
-            screen->setOn(true);
-        setBluetoothEnable(true);
-        // within enter() the function getState() returns the state we came from
-    }
+static void powerIdle() {
+  // LOG_POWERFSM("State: powerIdle"); // very chatty
+  if (!isPowered()) {
+    // If we got here, we are in the wrong state
+    LOG_INFO("Loss of power in Powered");
+    powerFSM.trigger(EVENT_POWER_DISCONNECTED);
+  }
 }
 
-static void powerIdle()
-{
-    // LOG_POWERFSM("State: powerIdle"); // very chatty
-    if (!isPowered()) {
-        // If we got here, we are in the wrong state
-        LOG_INFO("Loss of power in Powered");
-        powerFSM.trigger(EVENT_POWER_DISCONNECTED);
-    }
+static void powerExit() {
+  LOG_POWERFSM("State: powerExit");
+  setBluetoothEnable(true);
 }
 
-static void powerExit()
-{
-    LOG_POWERFSM("State: powerExit");
-    setBluetoothEnable(true);
+static void onEnter() {
+  LOG_POWERFSM("State: onEnter");
+  if (screen)
+    screen->setOn(true);
+  setBluetoothEnable(true);
 }
 
-static void onEnter()
-{
-    LOG_POWERFSM("State: onEnter");
-    if (screen)
-        screen->setOn(true);
-    setBluetoothEnable(true);
+static void onIdle() {
+  LOG_POWERFSM("State: onIdle");
+  if (isPowered()) {
+    // If we got here, we are in the wrong state - we should be in powered, let that state handle things
+    powerFSM.trigger(EVENT_POWER_CONNECTED);
+  }
 }
 
-static void onIdle()
-{
-    LOG_POWERFSM("State: onIdle");
-    if (isPowered()) {
-        // If we got here, we are in the wrong state - we should be in powered, let that state handle things
-        powerFSM.trigger(EVENT_POWER_CONNECTED);
-    }
-}
-
-static void bootEnter()
-{
-    LOG_POWERFSM("State: bootEnter");
-}
+static void bootEnter() { LOG_POWERFSM("State: bootEnter"); }
 
 State stateSHUTDOWN(shutdownEnter, NULL, NULL, "SHUTDOWN");
 State stateSDS(sdsEnter, NULL, NULL, "SDS");
@@ -260,147 +240,141 @@ State stateON(onEnter, onIdle, NULL, "ON");
 State statePOWER(powerEnter, powerIdle, powerExit, "POWER");
 Fsm powerFSM(&stateBOOT);
 
-void PowerFSM_setup()
-{
-    bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
-    bool hasPower = isPowered();
+void PowerFSM_setup() {
+  bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
+  bool hasPower = isPowered();
 
-    LOG_INFO("PowerFSM init, USB power=%d", hasPower ? 1 : 0);
-    powerFSM.add_timed_transition(&stateBOOT, hasPower ? &statePOWER : &stateON, 3 * 1000, NULL, "boot timeout");
+  LOG_INFO("PowerFSM init, USB power=%d", hasPower ? 1 : 0);
+  powerFSM.add_timed_transition(&stateBOOT, hasPower ? &statePOWER : &stateON, 3 * 1000, NULL, "boot timeout");
 
-    // wake timer expired or a packet arrived
-    // if we are a router node, we go to NB (no need for bluetooth) otherwise we go to DARK (so we can send message to phone)
+  // wake timer expired or a packet arrived
+  // if we are a router node, we go to NB (no need for bluetooth) otherwise we go to DARK (so we can send message to
+  // phone)
 #ifdef ARCH_ESP32
-    powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_WAKE_TIMER, NULL, "Wake timer");
+  powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_WAKE_TIMER, NULL, "Wake timer");
 #else // Don't go into a no-bluetooth state on low power platforms
-    powerFSM.add_transition(&stateLS, &stateDARK, EVENT_WAKE_TIMER, NULL, "Wake timer");
+  powerFSM.add_transition(&stateLS, &stateDARK, EVENT_WAKE_TIMER, NULL, "Wake timer");
 #endif
 
-    // We need this transition, because we might not transition if we were waiting to enter light-sleep, because when we wake from
-    // light sleep we _always_ transition to NB or dark and
-    powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_PACKET_FOR_PHONE, NULL,
-                            "Received packet, exiting light sleep");
-    powerFSM.add_transition(&stateNB, &stateNB, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, resetting win wake");
+  // We need this transition, because we might not transition if we were waiting to enter light-sleep, because when we
+  // wake from light sleep we _always_ transition to NB or dark and
+  powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, exiting light sleep");
+  powerFSM.add_transition(&stateNB, &stateNB, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, resetting win wake");
 
-    // Handle press events - note: we ignore button presses when in API mode
-    powerFSM.add_transition(&stateLS, &stateON, EVENT_PRESS, NULL, "Press");
-    powerFSM.add_transition(&stateNB, &stateON, EVENT_PRESS, NULL, "Press");
-    powerFSM.add_transition(&stateDARK, isPowered() ? &statePOWER : &stateON, EVENT_PRESS, NULL, "Press");
-    powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_PRESS, NULL, "Press");
-    powerFSM.add_transition(&stateON, &stateON, EVENT_PRESS, NULL, "Press"); // reenter On to restart our timers
-    powerFSM.add_transition(&stateSERIAL, &stateSERIAL, EVENT_PRESS, NULL,
-                            "Press"); // Allow button to work while in serial API
+  // Handle press events - note: we ignore button presses when in API mode
+  powerFSM.add_transition(&stateLS, &stateON, EVENT_PRESS, NULL, "Press");
+  powerFSM.add_transition(&stateNB, &stateON, EVENT_PRESS, NULL, "Press");
+  powerFSM.add_transition(&stateDARK, isPowered() ? &statePOWER : &stateON, EVENT_PRESS, NULL, "Press");
+  powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_PRESS, NULL, "Press");
+  powerFSM.add_transition(&stateON, &stateON, EVENT_PRESS, NULL, "Press"); // reenter On to restart our timers
+  powerFSM.add_transition(&stateSERIAL, &stateSERIAL, EVENT_PRESS, NULL,
+                          "Press"); // Allow button to work while in serial API
 
-    // Handle critically low power battery by forcing deep sleep
-    powerFSM.add_transition(&stateBOOT, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
-    powerFSM.add_transition(&stateLS, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
-    powerFSM.add_transition(&stateNB, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
-    powerFSM.add_transition(&stateDARK, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
-    powerFSM.add_transition(&stateON, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
-    powerFSM.add_transition(&stateSERIAL, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
+  // Handle critically low power battery by forcing deep sleep
+  powerFSM.add_transition(&stateBOOT, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
+  powerFSM.add_transition(&stateLS, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
+  powerFSM.add_transition(&stateNB, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
+  powerFSM.add_transition(&stateDARK, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
+  powerFSM.add_transition(&stateON, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
+  powerFSM.add_transition(&stateSERIAL, &stateLowBattSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
 
-    // Handle being told to power off
-    powerFSM.add_transition(&stateBOOT, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
-    powerFSM.add_transition(&stateLS, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
-    powerFSM.add_transition(&stateNB, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
-    powerFSM.add_transition(&stateDARK, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
-    powerFSM.add_transition(&stateON, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
-    powerFSM.add_transition(&stateSERIAL, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
+  // Handle being told to power off
+  powerFSM.add_transition(&stateBOOT, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
+  powerFSM.add_transition(&stateLS, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
+  powerFSM.add_transition(&stateNB, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
+  powerFSM.add_transition(&stateDARK, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
+  powerFSM.add_transition(&stateON, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
+  powerFSM.add_transition(&stateSERIAL, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
 
-    // Inputbroker
-    powerFSM.add_transition(&stateLS, &stateON, EVENT_INPUT, NULL, "Input Device");
-    powerFSM.add_transition(&stateNB, &stateON, EVENT_INPUT, NULL, "Input Device");
-    powerFSM.add_transition(&stateDARK, &stateON, EVENT_INPUT, NULL, "Input Device");
-    powerFSM.add_transition(&stateON, &stateON, EVENT_INPUT, NULL, "Input Device");       // restarts the sleep timer
-    powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_INPUT, NULL, "Input Device"); // restarts the sleep timer
+  // Inputbroker
+  powerFSM.add_transition(&stateLS, &stateON, EVENT_INPUT, NULL, "Input Device");
+  powerFSM.add_transition(&stateNB, &stateON, EVENT_INPUT, NULL, "Input Device");
+  powerFSM.add_transition(&stateDARK, &stateON, EVENT_INPUT, NULL, "Input Device");
+  powerFSM.add_transition(&stateON, &stateON, EVENT_INPUT, NULL, "Input Device");       // restarts the sleep timer
+  powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_INPUT, NULL, "Input Device"); // restarts the sleep timer
 
-    powerFSM.add_transition(&stateDARK, &stateON, EVENT_BLUETOOTH_PAIR, NULL, "Bluetooth pairing");
-    powerFSM.add_transition(&stateON, &stateON, EVENT_BLUETOOTH_PAIR, NULL, "Bluetooth pairing");
+  powerFSM.add_transition(&stateDARK, &stateON, EVENT_BLUETOOTH_PAIR, NULL, "Bluetooth pairing");
+  powerFSM.add_transition(&stateON, &stateON, EVENT_BLUETOOTH_PAIR, NULL, "Bluetooth pairing");
 
-    // if we are a router we don't turn the screen on for these things
-    if (!isRouter) {
-        // if any packet destined for phone arrives, turn on bluetooth at least
-        powerFSM.add_transition(&stateNB, &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Packet for phone");
+  // if we are a router we don't turn the screen on for these things
+  if (!isRouter) {
+    // if any packet destined for phone arrives, turn on bluetooth at least
+    powerFSM.add_transition(&stateNB, &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Packet for phone");
 
-        // Show the received text message
-        powerFSM.add_transition(&stateLS, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
-        powerFSM.add_transition(&stateNB, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
-        powerFSM.add_transition(&stateDARK, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
-        powerFSM.add_transition(&stateON, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text"); // restarts the sleep timer
-    }
+    // Show the received text message
+    powerFSM.add_transition(&stateLS, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
+    powerFSM.add_transition(&stateNB, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
+    powerFSM.add_transition(&stateDARK, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
+    powerFSM.add_transition(&stateON, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text"); // restarts the sleep timer
+  }
 
-    // If we are not in statePOWER but get a serial connection, suppress sleep (and keep the screen on) while connected
-    powerFSM.add_transition(&stateLS, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
-    powerFSM.add_transition(&stateNB, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
-    powerFSM.add_transition(&stateDARK, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
-    powerFSM.add_transition(&stateON, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
-    powerFSM.add_transition(&statePOWER, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
+  // If we are not in statePOWER but get a serial connection, suppress sleep (and keep the screen on) while connected
+  powerFSM.add_transition(&stateLS, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
+  powerFSM.add_transition(&stateNB, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
+  powerFSM.add_transition(&stateDARK, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
+  powerFSM.add_transition(&stateON, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
+  powerFSM.add_transition(&statePOWER, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
 
-    // If we get power connected, go to the power connect state
-    powerFSM.add_transition(&stateLS, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-    powerFSM.add_transition(&stateNB, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-    powerFSM.add_transition(&stateDARK, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-    powerFSM.add_transition(&stateON, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+  // If we get power connected, go to the power connect state
+  powerFSM.add_transition(&stateLS, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+  powerFSM.add_transition(&stateNB, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+  powerFSM.add_transition(&stateDARK, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+  powerFSM.add_transition(&stateON, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
 
-    powerFSM.add_transition(&statePOWER, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
-    // powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
+  powerFSM.add_transition(&statePOWER, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
+  // powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
 
-    // the only way to leave state serial is for the client to disconnect (or we timeout and force disconnect them)
-    // when we leave, go to ON (which might not be the correct state if we have power connected, we will fix that in onEnter)
-    powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_SERIAL_DISCONNECTED, NULL, "serial disconnect");
+  // the only way to leave state serial is for the client to disconnect (or we timeout and force disconnect them)
+  // when we leave, go to ON (which might not be the correct state if we have power connected, we will fix that in
+  // onEnter)
+  powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_SERIAL_DISCONNECTED, NULL, "serial disconnect");
 
-    powerFSM.add_transition(&stateDARK, &stateDARK, EVENT_CONTACT_FROM_PHONE, NULL, "Contact from phone");
+  powerFSM.add_transition(&stateDARK, &stateDARK, EVENT_CONTACT_FROM_PHONE, NULL, "Contact from phone");
 
 #ifdef USE_EINK
-    // Allow E-Ink devices to suppress the screensaver, if screen timeout set to 0
-    if (config.display.screen_on_secs > 0)
+  // Allow E-Ink devices to suppress the screensaver, if screen timeout set to 0
+  if (config.display.screen_on_secs > 0)
 #endif
-    {
-        powerFSM.add_timed_transition(&stateON, &stateDARK,
-                                      Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
-                                      NULL, "Screen-on timeout");
-        powerFSM.add_timed_transition(&statePOWER, &stateDARK,
-                                      Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
-                                      NULL, "Screen-on timeout");
-    }
+  {
+    powerFSM.add_timed_transition(&stateON, &stateDARK, Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
+                                  NULL, "Screen-on timeout");
+    powerFSM.add_timed_transition(&statePOWER, &stateDARK, Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
+                                  NULL, "Screen-on timeout");
+  }
 
 // We never enter light-sleep or NB states on NRF52 (because the CPU uses so little power normally)
 #ifdef ARCH_ESP32
-    // See: https://github.com/meshtastic/firmware/issues/1071
-    // Don't add power saving transitions if we are a power saving tracker or sensor or have Wifi enabled. Sleep will be initiated
-    // through the modules
+  // See: https://github.com/meshtastic/firmware/issues/1071
+  // Don't add power saving transitions if we are a power saving tracker or sensor or have Wifi enabled. Sleep will be
+  // initiated through the modules
 
 #if HAS_WIFI && !defined(MESHTASTIC_EXCLUDE_WIFI)
-    bool isTrackerOrSensor = config.device.role == meshtastic_Config_DeviceConfig_Role_TRACKER ||
-                             config.device.role == meshtastic_Config_DeviceConfig_Role_TAK_TRACKER ||
-                             config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR;
+  bool isTrackerOrSensor = config.device.role == meshtastic_Config_DeviceConfig_Role_TRACKER ||
+                           config.device.role == meshtastic_Config_DeviceConfig_Role_TAK_TRACKER ||
+                           config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR;
 
-    if ((isRouter || config.power.is_power_saving) && !isWifiAvailable() && !isTrackerOrSensor) {
-        powerFSM.add_timed_transition(&stateNB, &stateLS,
-                                      Default::getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
-                                      "Min wake timeout");
+  if ((isRouter || config.power.is_power_saving) && !isWifiAvailable() && !isTrackerOrSensor) {
+    powerFSM.add_timed_transition(&stateNB, &stateLS, Default::getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
+                                  "Min wake timeout");
 
-        // If ESP32 and using power-saving, timer mover from DARK to light-sleep
-        // Also serves purpose of the old DARK to DARK transition(?) See https://github.com/meshtastic/firmware/issues/3517
-        powerFSM.add_timed_transition(
-            &stateDARK, &stateLS,
-            Default::getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs), NULL,
-            "Bluetooth timeout");
-    } else {
-        // If ESP32, but not using power-saving, check periodically if config has drifted out of stateDark
-        powerFSM.add_timed_transition(&stateDARK, &stateDARK,
-                                      Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
-                                      NULL, "Screen-on timeout");
-    }
+    // If ESP32 and using power-saving, timer mover from DARK to light-sleep
+    // Also serves purpose of the old DARK to DARK transition(?) See https://github.com/meshtastic/firmware/issues/3517
+    powerFSM.add_timed_transition(&stateDARK, &stateLS,
+                                  Default::getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs), NULL,
+                                  "Bluetooth timeout");
+  } else {
+    // If ESP32, but not using power-saving, check periodically if config has drifted out of stateDark
+    powerFSM.add_timed_transition(&stateDARK, &stateDARK, Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
+                                  NULL, "Screen-on timeout");
+  }
 #endif // HAS_WIFI || !defined(MESHTASTIC_EXCLUDE_WIFI)
 
 #else // (not) ARCH_ESP32
-    // If not ESP32, light-sleep not used. Check periodically if config has drifted out of stateDark
-    powerFSM.add_timed_transition(&stateDARK, &stateDARK,
-                                  Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
-                                  "Screen-on timeout");
+  // If not ESP32, light-sleep not used. Check periodically if config has drifted out of stateDark
+  powerFSM.add_timed_transition(&stateDARK, &stateDARK, Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs),
+                                NULL, "Screen-on timeout");
 #endif
 
-    powerFSM.run_machine(); // run one iteration of the state machine, so we run our on enter tasks for the initial DARK state
+  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

@@ -17,7 +17,8 @@
 #define EVENT_RECEIVED_MSG 5
 // #define EVENT_BOOT 6 // now done with a timed transition
 #define EVENT_BLUETOOTH_PAIR 7
-// #define EVENT_NODEDB_UPDATED 8     // Now defunct: NodeDB has a big enough change that we think you should turn on the screen
+// #define EVENT_NODEDB_UPDATED 8     // Now defunct: NodeDB has a big enough change that we think you should turn on
+// the screen
 #define EVENT_CONTACT_FROM_PHONE 9 // the phone just talked to us over bluetooth
 #define EVENT_LOW_BATTERY 10       // Battery is critically low, go to sleep
 #define EVENT_SERIAL_CONNECTED 11
@@ -29,21 +30,19 @@
 #define EVENT_INPUT 17           // input broker wants something, we need to wake up and enable screen
 
 #if MESHTASTIC_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; };
+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;
+private:
+  bool serialConnected = false;
 };
 extern FakeFsm powerFSM;
 void PowerFSM_setup();

src/PowerFSMThread.h

@@ -6,40 +6,36 @@
 #include "main.h"
 #include "power.h"
 
-namespace concurrency
-{
+namespace concurrency {
 /// Wrapper to convert our powerFSM stuff into a 'thread'
-class PowerFSMThread : public OSThread
-{
-  public:
-    // callback returns the period for the next callback invocation (or 0 if we should no longer be called)
-    PowerFSMThread() : OSThread("PowerFSM") {}
+class PowerFSMThread : public OSThread {
+public:
+  // callback returns the period for the next callback invocation (or 0 if we should no longer be called)
+  PowerFSMThread() : OSThread("PowerFSM") {}
 
-  protected:
-    int32_t runOnce() override
-    {
+protected:
+  int32_t runOnce() override {
 #if !MESHTASTIC_EXCLUDE_POWER_FSM
-        powerFSM.run_machine();
+    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
-        /// cpu for serial rx - FIXME)
-        const State *state = powerFSM.getState();
-        canSleep = (state != &statePOWER) && (state != &stateSERIAL);
+    /// If we are in power state we force the CPU to wake every 10ms to check for serial characters (we don't yet wake
+    /// cpu for serial rx - FIXME)
+    const State *state = powerFSM.getState();
+    canSleep = (state != &statePOWER) && (state != &stateSERIAL);
 
-        if (powerStatus->getHasUSB()) {
-            timeLastPowered = millis();
-        } else if (config.power.on_battery_shutdown_after_secs > 0 && config.power.on_battery_shutdown_after_secs != UINT32_MAX &&
-                   millis() > (timeLastPowered +
-                               Default::getConfiguredOrDefaultMs(
-                                   config.power.on_battery_shutdown_after_secs))) { // shutdown after 30 minutes unpowered
-            powerFSM.trigger(EVENT_SHUTDOWN);
-        }
-
-        return 100;
-#else
-        return INT32_MAX;
-#endif
+    if (powerStatus->getHasUSB()) {
+      timeLastPowered = millis();
+    } else if (config.power.on_battery_shutdown_after_secs > 0 && config.power.on_battery_shutdown_after_secs != UINT32_MAX &&
+               millis() > (timeLastPowered +
+                           Default::getConfiguredOrDefaultMs(config.power.on_battery_shutdown_after_secs))) { // shutdown after 30 minutes unpowered
+      powerFSM.trigger(EVENT_SHUTDOWN);
     }
+
+    return 100;
+#else
+    return INT32_MAX;
+#endif
+  }
 };
 
 } // namespace concurrency

src/PowerMon.cpp

@@ -2,46 +2,39 @@
 #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);
+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)
-{
+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);
-    }
+  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)
-{
+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);
-    }
+  auto oldstates = states;
+  states &= ~state;
+  if (oldstates != states && is_power_enabled(state)) {
+    emitLog(reason);
+  }
 #endif
 }
 
-void PowerMon::emitLog(const char *reason)
-{
+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", (uint32_t)states, reason);
+  // 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", (uint32_t)states, reason);
 #endif
 }
 
 PowerMon *powerMon;
 
-void powerMonInit()
-{
-    powerMon = new PowerMon();
-}
+void powerMonInit() { powerMon = new PowerMon(); }

src/PowerMon.h

@@ -13,30 +13,29 @@
  *
  * For more information see the PowerMon docs.
  */
-class PowerMon
-{
-    uint64_t states = 0UL;
+class PowerMon {
+  uint64_t states = 0UL;
 
-    friend class PowerStressModule;
+  friend class PowerStressModule;
 
-    /**
-     * If stress testing we always want all events logged
-     */
-    bool force_enabled = false;
+  /**
+   * If stress testing we always want all events logged
+   */
+  bool force_enabled = false;
 
-  public:
-    PowerMon() {}
+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 = "");
+  // 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);
+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);
+  // 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;

src/PowerStatus.h

@@ -3,8 +3,7 @@
 #include "configuration.h"
 #include <Arduino.h>
 
-namespace meshtastic
-{
+namespace meshtastic {
 
 /**
  * A boolean where we have a third state of Unknown
@@ -12,90 +11,84 @@ namespace meshtastic
 enum OptionalBool { OptFalse = 0, OptTrue = 1, OptUnknown = 2 };
 
 /// Describes the state of the Power system.
-class PowerStatus : public Status
-{
+class PowerStatus : public Status {
 
-  private:
-    CallbackObserver<PowerStatus, const PowerStatus *> statusObserver =
-        CallbackObserver<PowerStatus, const PowerStatus *>(this, &PowerStatus::updateStatus);
+private:
+  CallbackObserver<PowerStatus, const PowerStatus *> statusObserver =
+      CallbackObserver<PowerStatus, const PowerStatus *>(this, &PowerStatus::updateStatus);
 
-    /// Whether we have a battery connected
-    OptionalBool hasBattery = OptUnknown;
-    /// Battery voltage in mV, valid if haveBattery is true
-    int batteryVoltageMv = 0;
-    /// Battery charge percentage, either read directly or estimated
-    int8_t batteryChargePercent = 0;
-    /// Whether USB is connected
-    OptionalBool hasUSB = OptUnknown;
-    /// Whether we are charging the battery
-    OptionalBool isCharging = OptUnknown;
+  /// Whether we have a battery connected
+  OptionalBool hasBattery = OptUnknown;
+  /// Battery voltage in mV, valid if haveBattery is true
+  int batteryVoltageMv = 0;
+  /// Battery charge percentage, either read directly or estimated
+  int8_t batteryChargePercent = 0;
+  /// Whether USB is connected
+  OptionalBool hasUSB = OptUnknown;
+  /// Whether we are charging the battery
+  OptionalBool isCharging = OptUnknown;
 
-  public:
-    PowerStatus() { statusType = STATUS_TYPE_POWER; }
-    PowerStatus(OptionalBool hasBattery, OptionalBool hasUSB, OptionalBool isCharging, int batteryVoltageMv = -1,
-                int8_t batteryChargePercent = 0)
-        : Status()
-    {
-        this->hasBattery = hasBattery;
-        this->hasUSB = hasUSB;
-        this->isCharging = isCharging;
-        this->batteryVoltageMv = batteryVoltageMv;
-        this->batteryChargePercent = batteryChargePercent;
-    }
-    PowerStatus(const PowerStatus &);
-    PowerStatus &operator=(const PowerStatus &);
+public:
+  PowerStatus() { statusType = STATUS_TYPE_POWER; }
+  PowerStatus(OptionalBool hasBattery, OptionalBool hasUSB, OptionalBool isCharging, int batteryVoltageMv = -1, int8_t batteryChargePercent = 0)
+      : Status() {
+    this->hasBattery = hasBattery;
+    this->hasUSB = hasUSB;
+    this->isCharging = isCharging;
+    this->batteryVoltageMv = batteryVoltageMv;
+    this->batteryChargePercent = batteryChargePercent;
+  }
+  PowerStatus(const PowerStatus &);
+  PowerStatus &operator=(const PowerStatus &);
 
-    void observe(Observable<const PowerStatus *> *source) { statusObserver.observe(source); }
+  void observe(Observable<const PowerStatus *> *source) { statusObserver.observe(source); }
 
-    bool getHasBattery() const { return hasBattery == OptTrue; }
+  bool getHasBattery() const { return hasBattery == OptTrue; }
 
-    bool getHasUSB() const { return hasUSB == OptTrue; }
+  bool getHasUSB() const { return hasUSB == OptTrue; }
 
-    /// Can we even know if this board has USB power or not
-    bool knowsUSB() const { return hasUSB != OptUnknown; }
+  /// Can we even know if this board has USB power or not
+  bool knowsUSB() const { return hasUSB != OptUnknown; }
 
-    bool getIsCharging() const { return isCharging == OptTrue; }
+  bool getIsCharging() const { return isCharging == OptTrue; }
 
-    int getBatteryVoltageMv() const { return batteryVoltageMv; }
+  int getBatteryVoltageMv() const { return batteryVoltageMv; }
 
-    /**
-     * Note: for boards with battery pin or PMU, 0% battery means 'unknown/this board doesn't have a battery installed'
-     */
+  /**
+   * Note: for boards with battery pin or PMU, 0% battery means 'unknown/this board doesn't have a battery installed'
+   */
 #if defined(HAS_PMU) || defined(BATTERY_PIN)
-    uint8_t getBatteryChargePercent() const { return getHasBattery() ? batteryChargePercent : 0; }
+  uint8_t getBatteryChargePercent() const { return getHasBattery() ? batteryChargePercent : 0; }
 #endif
 
-    /**
-     * Note: for boards without battery pin and PMU, 101% battery means 'the board is using external power'
-     */
+  /**
+   * Note: for boards without battery pin and PMU, 101% battery means 'the board is using external power'
+   */
 #if !defined(HAS_PMU) && !defined(BATTERY_PIN)
-    uint8_t getBatteryChargePercent() const { return getHasBattery() ? batteryChargePercent : 101; }
+  uint8_t getBatteryChargePercent() const { return getHasBattery() ? batteryChargePercent : 101; }
 #endif
 
-    bool matches(const PowerStatus *newStatus) const
+  bool matches(const PowerStatus *newStatus) const {
+    return (newStatus->getHasBattery() != hasBattery || newStatus->getHasUSB() != hasUSB || newStatus->getBatteryVoltageMv() != batteryVoltageMv);
+  }
+  int updateStatus(const PowerStatus *newStatus) {
+    // Only update the status if values have actually changed
+    bool isDirty;
     {
-        return (newStatus->getHasBattery() != hasBattery || newStatus->getHasUSB() != hasUSB ||
-                newStatus->getBatteryVoltageMv() != batteryVoltageMv);
+      isDirty = matches(newStatus);
+      initialized = true;
+      hasBattery = newStatus->hasBattery;
+      batteryVoltageMv = newStatus->getBatteryVoltageMv();
+      batteryChargePercent = newStatus->getBatteryChargePercent();
+      hasUSB = newStatus->hasUSB;
+      isCharging = newStatus->isCharging;
     }
-    int updateStatus(const PowerStatus *newStatus)
-    {
-        // Only update the status if values have actually changed
-        bool isDirty;
-        {
-            isDirty = matches(newStatus);
-            initialized = true;
-            hasBattery = newStatus->hasBattery;
-            batteryVoltageMv = newStatus->getBatteryVoltageMv();
-            batteryChargePercent = newStatus->getBatteryChargePercent();
-            hasUSB = newStatus->hasUSB;
-            isCharging = newStatus->isCharging;
-        }
-        if (isDirty) {
-            // LOG_DEBUG("Battery %dmV %d%%", batteryVoltageMv, batteryChargePercent);
-            onNewStatus.notifyObservers(this);
-        }
-        return 0;
+    if (isDirty) {
+      // LOG_DEBUG("Battery %dmV %d%%", batteryVoltageMv, batteryChargePercent);
+      onNewStatus.notifyObservers(this);
     }
+    return 0;
+  }
 };
 
 } // namespace meshtastic

src/RedirectablePrint.cpp

@@ -20,386 +20,376 @@
 #if HAS_NETWORKING
 extern Syslog syslog;
 #endif
-void RedirectablePrint::rpInit()
-{
+void RedirectablePrint::rpInit() {
 #ifdef HAS_FREE_RTOS
-    inDebugPrint = xSemaphoreCreateMutexStatic(&this->_MutexStorageSpace);
+  inDebugPrint = xSemaphoreCreateMutexStatic(&this->_MutexStorageSpace);
 #endif
 }
 
-void RedirectablePrint::setDestination(Print *_dest)
-{
-    assert(_dest);
-    dest = _dest;
+void RedirectablePrint::setDestination(Print *_dest) {
+  assert(_dest);
+  dest = _dest;
 }
 
-size_t RedirectablePrint::write(uint8_t c)
-{
-    // Always send the characters to our segger JTAG debugger
+size_t RedirectablePrint::write(uint8_t c) {
+  // Always send the characters to our segger JTAG debugger
 #ifdef USE_SEGGER
-    SEGGER_RTT_PutChar(SEGGER_STDOUT_CH, c);
+  SEGGER_RTT_PutChar(SEGGER_STDOUT_CH, c);
 #endif
-    // 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);
+  // 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)
+  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 *logLevel, const char *format, va_list arg)
-{
-    va_list copy;
+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];
+  static char printBuf[512];
 #else
-    static char printBuf[160];
+  static char printBuf[160];
 #endif
 
 #ifdef ARCH_PORTDUINO
-    bool color = !portduino_config.ascii_logs;
+  bool color = !portduino_config.ascii_logs;
 #else
-    bool color = true;
+  bool color = true;
 #endif
 
-    va_copy(copy, arg);
-    size_t len = vsnprintf(printBuf, sizeof(printBuf), format, copy);
-    va_end(copy);
+  va_copy(copy, arg);
+  size_t len = vsnprintf(printBuf, sizeof(printBuf), format, copy);
+  va_end(copy);
 
-    // If the resulting string is longer than sizeof(printBuf)-1 characters, the remaining characters are still counted for the
-    // return value
+  // If the resulting string is longer than sizeof(printBuf)-1 characters, the remaining characters are still counted
+  // for the return value
 
-    if (len > sizeof(printBuf) - 1) {
-        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", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
-            Print::write("\u001b[32m", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
-            Print::write("\u001b[33m", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
-            Print::write("\u001b[31m", 5);
-    }
-    len = Print::write(printBuf, len);
-    if (color && logLevel != nullptr) {
-        Print::write("\u001b[0m", 4);
-    }
-    return len;
+  if (len > sizeof(printBuf) - 1) {
+    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", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+      Print::write("\u001b[32m", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+      Print::write("\u001b[33m", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
+      Print::write("\u001b[31m", 5);
+  }
+  len = Print::write(printBuf, len);
+  if (color && logLevel != nullptr) {
+    Print::write("\u001b[0m", 4);
+  }
+  return len;
 }
 
-void RedirectablePrint::log_to_serial(const char *logLevel, const char *format, va_list arg)
-{
-    size_t r = 0;
+void RedirectablePrint::log_to_serial(const char *logLevel, const char *format, va_list arg) {
+  size_t r = 0;
 
 #ifdef ARCH_PORTDUINO
-    bool color = !portduino_config.ascii_logs;
+  bool color = !portduino_config.ascii_logs;
 #else
-    bool color = true;
+  bool color = true;
 #endif
 
-    // include the header
+  // include the header
+  if (color) {
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+      Print::write("\u001b[34m", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+      Print::write("\u001b[32m", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+      Print::write("\u001b[33m", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
+      Print::write("\u001b[31m", 5);
+    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0)
+      Print::write("\u001b[35m", 5);
+  }
+
+  uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // display local time on logfile
+  if (rtc_sec > 0) {
+    long hms = rtc_sec % SEC_PER_DAY;
+    // hms += tz.tz_dsttime * SEC_PER_HOUR;
+    // hms -= tz.tz_minuteswest * SEC_PER_MIN;
+    // mod `hms` to ensure in positive range of [0...SEC_PER_DAY)
+    hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
+
+    // Tear apart hms into h:m:s
+    int hour = hms / SEC_PER_HOUR;
+    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
+    ::printf("%s ", logLevel);
     if (color) {
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
-            Print::write("\u001b[34m", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
-            Print::write("\u001b[32m", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
-            Print::write("\u001b[33m", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
-            Print::write("\u001b[31m", 5);
-        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0)
-            Print::write("\u001b[35m", 5);
+      ::printf("\u001b[0m");
     }
-
-    uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // display local time on logfile
-    if (rtc_sec > 0) {
-        long hms = rtc_sec % SEC_PER_DAY;
-        // hms += tz.tz_dsttime * SEC_PER_HOUR;
-        // hms -= tz.tz_minuteswest * SEC_PER_MIN;
-        // mod `hms` to ensure in positive range of [0...SEC_PER_DAY)
-        hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
-
-        // Tear apart hms into h:m:s
-        int hour = hms / SEC_PER_HOUR;
-        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
-        ::printf("%s ", logLevel);
-        if (color) {
-            ::printf("\u001b[0m");
-        }
-        ::printf("| %02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
+    ::printf("| %02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
 #else
-        printf("%s ", logLevel);
-        if (color) {
-            printf("\u001b[0m");
-        }
-        printf("| %02d:%02d:%02d %u ", 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
-        ::printf("%s ", logLevel);
-        if (color) {
-            ::printf("\u001b[0m");
-        }
-        ::printf("| ??:??:?? %u ", millis() / 1000);
+    ::printf("%s ", logLevel);
+    if (color) {
+      ::printf("\u001b[0m");
+    }
+    ::printf("| ??:??:?? %u ", millis() / 1000);
 #else
-        printf("%s ", logLevel);
-        if (color) {
-            printf("\u001b[0m");
-        }
-        printf("| ??:??:?? %u ", millis() / 1000);
+    printf("%s ", logLevel);
+    if (color) {
+      printf("\u001b[0m");
+    }
+    printf("| ??:??:?? %u ", millis() / 1000);
 #endif
-    }
-    auto thread = concurrency::OSThread::currentThread;
-    if (thread) {
-        print("[");
-        // printf("%p ", thread);
-        // assert(thread->ThreadName.length());
-        print(thread->ThreadName);
-        print("] ");
-    }
+  }
+  auto thread = concurrency::OSThread::currentThread;
+  if (thread) {
+    print("[");
+    // printf("%p ", thread);
+    // assert(thread->ThreadName.length());
+    print(thread->ThreadName);
+    print("] ");
+  }
 
 #ifdef DEBUG_HEAP
-    // Add heap free space bytes prefix before every log message
+  // Add heap free space bytes prefix before every log message
 #ifdef ARCH_PORTDUINO
-    ::printf("[heap %u] ", memGet.getFreeHeap());
+  ::printf("[heap %u] ", memGet.getFreeHeap());
 #else
-    printf("[heap %u] ", memGet.getFreeHeap());
+  printf("[heap %u] ", memGet.getFreeHeap());
 #endif
 #endif // DEBUG_HEAP
 
-    r += vprintf(logLevel, format, arg);
+  r += vprintf(logLevel, format, arg);
 }
 
-void RedirectablePrint::log_to_syslog(const char *logLevel, const char *format, va_list arg)
-{
+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;
-        switch (logLevel[0]) {
-        case 'D':
-            ll = SYSLOG_DEBUG;
-            break;
-        case 'I':
-            ll = SYSLOG_INFO;
-            break;
-        case 'W':
-            ll = SYSLOG_WARN;
-            break;
-        case 'E':
-            ll = SYSLOG_ERR;
-            break;
-        case 'C':
-            ll = SYSLOG_CRIT;
-            break;
-        default:
-            ll = 0;
-        }
-        auto thread = concurrency::OSThread::currentThread;
-        if (thread) {
-            syslog.vlogf(ll, thread->ThreadName.c_str(), format, arg);
-        } else {
-            syslog.vlogf(ll, format, arg);
-        }
-    }
-#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
+  // if syslog is in use, collect the log messages and send them to syslog
+  if (syslog.isEnabled()) {
+    int ll = 0;
     switch (logLevel[0]) {
     case 'D':
-        ll = meshtastic_LogRecord_Level_DEBUG;
-        break;
+      ll = SYSLOG_DEBUG;
+      break;
     case 'I':
-        ll = meshtastic_LogRecord_Level_INFO;
-        break;
+      ll = SYSLOG_INFO;
+      break;
     case 'W':
-        ll = meshtastic_LogRecord_Level_WARNING;
-        break;
+      ll = SYSLOG_WARN;
+      break;
     case 'E':
-        ll = meshtastic_LogRecord_Level_ERROR;
-        break;
+      ll = SYSLOG_ERR;
+      break;
     case 'C':
-        ll = meshtastic_LogRecord_Level_CRITICAL;
-        break;
+      ll = SYSLOG_CRIT;
+      break;
+    default:
+      ll = 0;
     }
-    return ll;
+    auto thread = concurrency::OSThread::currentThread;
+    if (thread) {
+      syslog.vlogf(ll, thread->ThreadName.c_str(), format, arg);
+    } else {
+      syslog.vlogf(ll, format, arg);
+    }
+  }
+#endif
 }
 
-void RedirectablePrint::log(const char *logLevel, const char *format, ...)
-{
+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);
 
-    // append \n to format
-    size_t len = strlen(format);
-    char *newFormat = new char[len + 2];
-    strcpy(newFormat, format);
-    newFormat[len] = '\n';
-    newFormat[len + 1] = '\0';
+      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, ...) {
+
+  // append \n to format
+  size_t len = strlen(format);
+  char *newFormat = new char[len + 2];
+  strcpy(newFormat, format);
+  newFormat[len] = '\n';
+  newFormat[len + 1] = '\0';
 
 #if ARCH_PORTDUINO
-    // level trace is special, two possible ways to handle it.
-    if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
-        if (portduino_config.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 (portduino_config.logoutputlevel < level_trace && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
-            delete[] newFormat;
-            return;
-        }
+  // level trace is special, two possible ways to handle it.
+  if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
+    if (portduino_config.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 (portduino_config.logoutputlevel < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
-        delete[] newFormat;
-        return;
-    } else if (portduino_config.logoutputlevel < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0) {
-        delete[] newFormat;
-        return;
-    } else if (portduino_config.logoutputlevel < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0) {
-        delete[] newFormat;
-        return;
+    if (portduino_config.logoutputlevel < level_trace && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
+      delete[] newFormat;
+      return;
     }
-#endif
-    if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
-        delete[] newFormat;
-        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, newFormat, arg);
-        log_to_syslog(logLevel, newFormat, arg);
-        log_to_ble(logLevel, newFormat, arg);
-
-        va_end(arg);
-#ifdef HAS_FREE_RTOS
-        xSemaphoreGive(inDebugPrint);
-#else
-        inDebugPrint = false;
-#endif
-    }
-
+  }
+  if (portduino_config.logoutputlevel < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
     delete[] newFormat;
     return;
+  } else if (portduino_config.logoutputlevel < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0) {
+    delete[] newFormat;
+    return;
+  } else if (portduino_config.logoutputlevel < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0) {
+    delete[] newFormat;
+    return;
+  }
+#endif
+  if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
+    delete[] newFormat;
+    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, newFormat, arg);
+    log_to_syslog(logLevel, newFormat, arg);
+    log_to_ble(logLevel, newFormat, arg);
+
+    va_end(arg);
+#ifdef HAS_FREE_RTOS
+    xSemaphoreGive(inDebugPrint);
+#else
+    inDebugPrint = false;
+#endif
+  }
+
+  delete[] newFormat;
+  return;
 }
 
-void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16_t len)
-{
-    const char alphabet[17] = "0123456789abcdef";
-    log(logLevel, "    +------------------------------------------------+ +----------------+");
-    log(logLevel, "    |.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .a .b .c .d .e .f | |      ASCII     |");
-    for (uint16_t i = 0; i < len; i += 16) {
-        if (i % 128 == 0)
-            log(logLevel, "    +------------------------------------------------+ +----------------+");
-        char s[] = "     |                                                | |                |\n";
-        uint8_t ix = 5, iy = 56;
-        for (uint8_t j = 0; j < 16; j++) {
-            if (i + j < len) {
-                uint8_t c = buf[i + j];
-                s[ix++] = alphabet[(c >> 4) & 0x0F];
-                s[ix++] = alphabet[c & 0x0F];
-                ix++;
-                if (c > 31 && c < 128)
-                    s[iy++] = c;
-                else
-                    s[iy++] = '.';
-            }
-        }
-        uint8_t index = i / 16;
-        sprintf(s, "%03x", index);
-        s[3] = '.';
-        log(logLevel, s);
-    }
-    log(logLevel, "    +------------------------------------------------+ +----------------+");
-}
-
-std::string RedirectablePrint::mt_sprintf(const std::string fmt_str, ...)
-{
-    int n = ((int)fmt_str.size()) * 2; /* Reserve two times as much as the length of the fmt_str */
-    std::unique_ptr<char[]> formatted;
-    va_list ap;
-    while (1) {
-        formatted.reset(new char[n]); /* Wrap the plain char array into the unique_ptr */
-        strcpy(&formatted[0], fmt_str.c_str());
-        va_start(ap, fmt_str);
-        int final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
-        va_end(ap);
-        if (final_n < 0 || final_n >= n)
-            n += abs(final_n - n + 1);
+void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16_t len) {
+  const char alphabet[17] = "0123456789abcdef";
+  log(logLevel, "    +------------------------------------------------+ +----------------+");
+  log(logLevel, "    |.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .a .b .c .d .e .f | |      ASCII     |");
+  for (uint16_t i = 0; i < len; i += 16) {
+    if (i % 128 == 0)
+      log(logLevel, "    +------------------------------------------------+ +----------------+");
+    char s[] = "     |                                                | |                |\n";
+    uint8_t ix = 5, iy = 56;
+    for (uint8_t j = 0; j < 16; j++) {
+      if (i + j < len) {
+        uint8_t c = buf[i + j];
+        s[ix++] = alphabet[(c >> 4) & 0x0F];
+        s[ix++] = alphabet[c & 0x0F];
+        ix++;
+        if (c > 31 && c < 128)
+          s[iy++] = c;
         else
-            break;
+          s[iy++] = '.';
+      }
     }
-    return std::string(formatted.get());
+    uint8_t index = i / 16;
+    sprintf(s, "%03x", index);
+    s[3] = '.';
+    log(logLevel, s);
+  }
+  log(logLevel, "    +------------------------------------------------+ +----------------+");
+}
+
+std::string RedirectablePrint::mt_sprintf(const std::string fmt_str, ...) {
+  int n = ((int)fmt_str.size()) * 2; /* Reserve two times as much as the length of the fmt_str */
+  std::unique_ptr<char[]> formatted;
+  va_list ap;
+  while (1) {
+    formatted.reset(new char[n]); /* Wrap the plain char array into the unique_ptr */
+    strcpy(&formatted[0], fmt_str.c_str());
+    va_start(ap, fmt_str);
+    int final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
+    va_end(ap);
+    if (final_n < 0 || final_n >= n)
+      n += abs(final_n - n + 1);
+    else
+      break;
+  }
+  return std::string(formatted.get());
 }

src/RedirectablePrint.h

@@ -11,49 +11,48 @@
  * This class is mostly useful to allow debug printing to be redirected away from Serial
  * to some other transport if we switch Serial usage (on the fly) to some other purpose.
  */
-class RedirectablePrint : public Print
-{
-    Print *dest;
+class RedirectablePrint : public Print {
+  Print *dest;
 
 #ifdef HAS_FREE_RTOS
-    SemaphoreHandle_t inDebugPrint = nullptr;
-    StaticSemaphore_t _MutexStorageSpace;
+  SemaphoreHandle_t inDebugPrint = nullptr;
+  StaticSemaphore_t _MutexStorageSpace;
 #else
-    volatile bool inDebugPrint = false;
+  volatile bool inDebugPrint = false;
 #endif
-  public:
-    explicit RedirectablePrint(Print *_dest) : dest(_dest) {}
+public:
+  explicit RedirectablePrint(Print *_dest) : dest(_dest) {}
 
-    /**
-     * Set a new destination
-     */
-    void rpInit();
-    void setDestination(Print *dest);
+  /**
+   * Set a new destination
+   */
+  void rpInit();
+  void setDestination(Print *dest);
 
-    virtual size_t write(uint8_t c);
+  virtual size_t write(uint8_t c);
 
-    /**
-     * Debug logging print message
-     *
-     * If the provide format string ends with a newline we assume it is the final print of a single
-     * 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.
-     */
-    void log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
+  /**
+   * Debug logging print message
+   *
+   * If the provide format string ends with a newline we assume it is the final print of a single
+   * 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.
+   */
+  void log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
 
-    /** like printf but va_list based */
-    size_t vprintf(const char *logLevel, const char *format, va_list arg);
+  /** like printf but va_list based */
+  size_t vprintf(const char *logLevel, const char *format, va_list arg);
 
-    void hexDump(const char *logLevel, unsigned char *buf, uint16_t len);
+  void hexDump(const char *logLevel, unsigned char *buf, uint16_t len);
 
-    std::string mt_sprintf(const std::string fmt_str, ...);
+  std::string mt_sprintf(const std::string fmt_str, ...);
 
-  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);
-    meshtastic_LogRecord_Level getLogLevel(const char *logLevel);
+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);
+  meshtastic_LogRecord_Level getLogLevel(const char *logLevel);
 
-  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);
+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);
 };

src/SPILock.cpp

@@ -5,8 +5,7 @@
 
 concurrency::Lock *spiLock;
 
-void initSPI()
-{
-    assert(!spiLock);
-    spiLock = new concurrency::Lock();
+void initSPI() {
+  assert(!spiLock);
+  spiLock = new concurrency::Lock();
 }

src/SafeFile.cpp

@@ -3,54 +3,48 @@
 #ifdef FSCom
 
 // Only way to work on both esp32 and nrf52
-static File openFile(const char *filename, bool fullAtomic)
-{
-    concurrency::LockGuard g(spiLock);
-    LOG_DEBUG("Opening %s, fullAtomic=%d", filename, fullAtomic);
+static File openFile(const char *filename, bool fullAtomic) {
+  concurrency::LockGuard g(spiLock);
+  LOG_DEBUG("Opening %s, fullAtomic=%d", filename, fullAtomic);
 #ifdef ARCH_NRF52
-    FSCom.remove(filename);
-    return FSCom.open(filename, FILE_O_WRITE);
+  FSCom.remove(filename);
+  return FSCom.open(filename, FILE_O_WRITE);
 #endif
-    if (!fullAtomic) {
-        FSCom.remove(filename); // Nuke the old file to make space (ignore if it !exists)
-    }
+  if (!fullAtomic) {
+    FSCom.remove(filename); // Nuke the old file to make space (ignore if it !exists)
+  }
 
-    String filenameTmp = filename;
-    filenameTmp += ".tmp";
+  String filenameTmp = filename;
+  filenameTmp += ".tmp";
 
-    // FIXME: If we are doing a full atomic write, we may need to remove the old tmp file now
-    // if (fullAtomic) {
-    //     FSCom.remove(filename);
-    // }
+  // FIXME: If we are doing a full atomic write, we may need to remove the old tmp file now
+  // if (fullAtomic) {
+  //     FSCom.remove(filename);
+  // }
 
-    // clear any previous LFS errors
-    return FSCom.open(filenameTmp.c_str(), FILE_O_WRITE);
+  // clear any previous LFS errors
+  return FSCom.open(filenameTmp.c_str(), FILE_O_WRITE);
 }
 
-SafeFile::SafeFile(const char *_filename, bool fullAtomic)
-    : filename(_filename), f(openFile(_filename, fullAtomic)), fullAtomic(fullAtomic)
-{
+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(uint8_t ch)
-{
-    if (!f)
-        return 0;
+size_t SafeFile::write(const uint8_t *buffer, size_t size) {
+  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)
+  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)
 }
 
 /**
@@ -58,66 +52,64 @@ size_t SafeFile::write(const uint8_t *buffer, size_t size)
  *
  * @return false for failure
  */
-bool SafeFile::close()
-{
-    if (!f)
-        return false;
+bool SafeFile::close() {
+  if (!f)
+    return false;
 
-    spiLock->lock();
-    f.close();
-    spiLock->unlock();
+  spiLock->lock();
+  f.close();
+  spiLock->unlock();
 
 #ifdef ARCH_NRF52
-    return true;
+  return true;
 #endif
-    if (!testReadback())
-        return false;
+  if (!testReadback())
+    return false;
 
-    { // Scope for lock
-        concurrency::LockGuard g(spiLock);
-        // 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");
-            return false;
-        }
+  { // Scope for lock
+    concurrency::LockGuard g(spiLock);
+    // 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");
+      return false;
     }
+  }
 
-    String filenameTmp = filename;
-    filenameTmp += ".tmp";
-    if (!renameFile(filenameTmp.c_str(), filename.c_str())) {
-        LOG_ERROR("Error: can't rename new pref file");
-        return false;
-    }
+  String filenameTmp = filename;
+  filenameTmp += ".tmp";
+  if (!renameFile(filenameTmp.c_str(), filename.c_str())) {
+    LOG_ERROR("Error: can't rename new pref file");
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
 /// Read our (closed) tempfile back in and compare the hash
-bool SafeFile::testReadback()
-{
-    concurrency::LockGuard g(spiLock);
+bool SafeFile::testReadback() {
+  concurrency::LockGuard g(spiLock);
 
-    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");
-        return 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");
+    return false;
+  }
 
-    int c = 0;
-    uint8_t test_hash = 0;
-    while ((c = f2.read()) >= 0) {
-        test_hash ^= (uint8_t)c;
-    }
-    f2.close();
+  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");
-        return false;
-    }
+  if (test_hash != hash) {
+    LOG_ERROR("Readback failed hash mismatch");
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
 #endif

src/SafeFile.h

@@ -10,41 +10,41 @@
  * 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.
+ * 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.
+ * - 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:
-    explicit SafeFile(char const *filepath, bool fullAtomic = false);
+class SafeFile : public Print {
+public:
+  explicit SafeFile(char const *filepath, bool fullAtomic = false);
 
-    virtual size_t write(uint8_t);
-    virtual size_t write(const uint8_t *buffer, size_t size);
+  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();
+  /**
+   * 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();
+private:
+  /// Read our (closed) tempfile back in and compare the hash
+  bool testReadback();
 
-    String filename;
-    File f;
-    bool fullAtomic;
-    uint8_t hash = 0;
+  String filename;
+  File f;
+  bool fullAtomic;
+  uint8_t hash = 0;
 };
 
 #endif

src/SerialConsole.cpp

@@ -28,121 +28,105 @@
 
 SerialConsole *console;
 
-void consoleInit()
-{
-    auto sc = new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
+void consoleInit() {
+  auto sc = new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
 
 #if defined(SERIAL_HAS_ON_RECEIVE)
-    // onReceive does only exist for HardwareSerial not for USB CDC serial
-    Port.onReceive([sc]() { sc->rxInt(); });
+  // onReceive does only exist for HardwareSerial not for USB CDC serial
+  Port.onReceive([sc]() { sc->rxInt(); });
 #endif
-    DEBUG_PORT.rpInit(); // Simply sets up semaphore
+  DEBUG_PORT.rpInit(); // Simply sets up semaphore
 }
 
-void consolePrintf(const char *format, ...)
-{
-    va_list arg;
-    va_start(arg, format);
-    console->vprintf(nullptr, format, arg);
-    va_end(arg);
-    console->flush();
+void consolePrintf(const char *format, ...) {
+  va_list arg;
+  va_start(arg, format);
+  console->vprintf(nullptr, format, arg);
+  va_end(arg);
+  console->flush();
 }
 
-SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), concurrency::OSThread("SerialConsole")
-{
-    api_type = TYPE_SERIAL;
-    assert(!console);
-    console = this;
-    canWrite = false; // We don't send packets to our port until it has talked to us first
+SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), concurrency::OSThread("SerialConsole") {
+  api_type = TYPE_SERIAL;
+  assert(!console);
+  console = this;
+  canWrite = false; // We don't send packets to our port until it has talked to us first
 
 #ifdef RP2040_SLOW_CLOCK
-    Port.setTX(SERIAL2_TX);
-    Port.setRX(SERIAL2_RX);
+  Port.setTX(SERIAL2_TX);
+  Port.setRX(SERIAL2_RX);
 #endif
-    Port.begin(SERIAL_BAUD);
-#if defined(ARCH_NRF52) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3) || defined(ARCH_RP2040) ||   \
+  Port.begin(SERIAL_BAUD);
+#if defined(ARCH_NRF52) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3) || defined(ARCH_RP2040) ||                       \
     defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6)
-    time_t timeout = millis();
-    while (!Port) {
-        if (Throttle::isWithinTimespanMs(timeout, FIVE_SECONDS_MS)) {
-            delay(100);
-        } else {
-            break;
-        }
+  time_t timeout = millis();
+  while (!Port) {
+    if (Throttle::isWithinTimespanMs(timeout, FIVE_SECONDS_MS)) {
+      delay(100);
+    } else {
+      break;
     }
+  }
 #endif
 #if !ARCH_PORTDUINO
-    emitRebooted();
+  emitRebooted();
 #endif
 }
 
-int32_t SerialConsole::runOnce()
-{
+int32_t SerialConsole::runOnce() {
 #ifdef HELTEC_MESH_SOLAR
-    // After enabling the mesh solar serial port module configuration, command processing is handled by the serial port module.
-    if (moduleConfig.serial.enabled && moduleConfig.serial.override_console_serial_port &&
-        moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG) {
-        return 250;
-    }
+  // After enabling the mesh solar serial port module configuration, command processing is handled by the serial port
+  // module.
+  if (moduleConfig.serial.enabled && moduleConfig.serial.override_console_serial_port &&
+      moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG) {
+    return 250;
+  }
 #endif
 
-    int32_t delay = runOncePart();
+  int32_t delay = runOncePart();
 #if defined(SERIAL_HAS_ON_RECEIVE) || defined(CONFIG_IDF_TARGET_ESP32S2)
-    return Port.available() ? delay : INT32_MAX;
+  return Port.available() ? delay : INT32_MAX;
 #elif defined(IS_USB_SERIAL)
-    return HWCDC::isPlugged() ? delay : (1000 * 20);
+  return HWCDC::isPlugged() ? delay : (1000 * 20);
 #else
-    return delay;
+  return delay;
 #endif
 }
 
-void SerialConsole::flush()
-{
-    Port.flush();
-}
+void SerialConsole::flush() { Port.flush(); }
 
 // trigger tx of serial data
-void SerialConsole::onNowHasData(uint32_t fromRadioNum)
-{
-    setIntervalFromNow(0);
-}
+void SerialConsole::onNowHasData(uint32_t fromRadioNum) { setIntervalFromNow(0); }
 
 // trigger rx of serial data
-void SerialConsole::rxInt()
-{
-    setIntervalFromNow(0);
-}
+void SerialConsole::rxInt() { setIntervalFromNow(0); }
 
-// For the serial port we can't really detect if any client is on the other side, so instead just look for recent messages
-bool SerialConsole::checkIsConnected()
-{
-    return Throttle::isWithinTimespanMs(lastContactMsec, SERIAL_CONNECTION_TIMEOUT);
-}
+// For the serial port we can't really detect if any client is on the other side, so instead just look for recent
+// messages
+bool SerialConsole::checkIsConnected() { return Throttle::isWithinTimespanMs(lastContactMsec, SERIAL_CONNECTION_TIMEOUT); }
 
 /**
  * we override this to notice when we've received a protobuf over the serial
  * stream.  Then we shut off debug serial output.
  */
-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.security.serial_enabled) {
-        // Switch to protobufs for log messages
-        usingProtobufs = true;
-        canWrite = true;
+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.security.serial_enabled) {
+    // Switch to protobufs for log messages
+    usingProtobufs = true;
+    canWrite = true;
 
-        return StreamAPI::handleToRadio(buf, len);
-    } else {
-        return false;
-    }
+    return StreamAPI::handleToRadio(buf, len);
+  } else {
+    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 = RedirectablePrint::getLogLevel(logLevel);
-        auto thread = concurrency::OSThread::currentThread;
-        emitLogRecord(ll, thread ? thread->ThreadName.c_str() : "", format, arg);
-    } else
-        RedirectablePrint::log_to_serial(logLevel, format, arg);
+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 = RedirectablePrint::getLogLevel(logLevel);
+    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

@@ -6,42 +6,40 @@
  * Provides both debug printing and, if the client starts sending protobufs to us, switches to send/receive protobufs
  * (and starts dropping debug printing - FIXME, eventually those prints should be encapsulated in protobufs).
  */
-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;
+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();
+public:
+  SerialConsole();
 
-    /**
-     * we override this to notice when we've received a protobuf over the serial stream.  Then we shunt off
-     * debug serial output.
-     */
-    virtual bool handleToRadio(const uint8_t *buf, size_t len) override;
+  /**
+   * we override this to notice when we've received a protobuf over the serial stream.  Then we shunt off
+   * debug serial output.
+   */
+  virtual bool handleToRadio(const uint8_t *buf, size_t len) override;
 
-    virtual size_t write(uint8_t c) override
-    {
-        if (c == '\n') // prefix any newlines with carriage return
-            RedirectablePrint::write('\r');
-        return RedirectablePrint::write(c);
-    }
+  virtual size_t write(uint8_t c) override {
+    if (c == '\n') // prefix any newlines with carriage return
+      RedirectablePrint::write('\r');
+    return RedirectablePrint::write(c);
+  }
 
-    virtual int32_t runOnce() override;
+  virtual int32_t runOnce() override;
 
-    void flush();
-    void rxInt();
+  void flush();
+  void rxInt();
 
-  protected:
-    /// Check the current underlying physical link to see if the client is currently connected
-    virtual bool checkIsConnected() override;
+protected:
+  /// Check the current underlying physical link to see if the client is currently connected
+  virtual bool checkIsConnected() override;
 
-    virtual void onNowHasData(uint32_t fromRadioNum) override;
+  virtual void onNowHasData(uint32_t fromRadioNum) 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);
+  /// 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/Status.h

@@ -9,49 +9,45 @@
 #define STATUS_TYPE_NODE 3
 #define STATUS_TYPE_BLUETOOTH 4
 
-namespace meshtastic
-{
+namespace meshtastic {
 
 // A base class for observable status
-class Status
-{
-  protected:
-    // Allows us to observe an Observable
-    CallbackObserver<Status, const Status *> statusObserver =
-        CallbackObserver<Status, const Status *>(this, &Status::updateStatus);
-    bool initialized = false;
-    // Workaround for no typeid support
-    int statusType = 0;
+class Status {
+protected:
+  // Allows us to observe an Observable
+  CallbackObserver<Status, const Status *> statusObserver = CallbackObserver<Status, const Status *>(this, &Status::updateStatus);
+  bool initialized = false;
+  // Workaround for no typeid support
+  int statusType = 0;
 
-  public:
-    // Allows us to generate observable events
-    Observable<const Status *> onNewStatus;
+public:
+  // Allows us to generate observable events
+  Observable<const Status *> onNewStatus;
 
-    // Enable polymorphism ?
-    virtual ~Status() = default;
+  // Enable polymorphism ?
+  virtual ~Status() = default;
 
-    Status()
-    {
-        if (!statusType) {
-            statusType = STATUS_TYPE_BASE;
-        }
+  Status() {
+    if (!statusType) {
+      statusType = STATUS_TYPE_BASE;
     }
+  }
 
-    // Prevent object copy/move
-    Status(const Status &) = delete;
-    Status &operator=(const Status &) = delete;
+  // Prevent object copy/move
+  Status(const Status &) = delete;
+  Status &operator=(const Status &) = delete;
 
-    // Start observing a source of data
-    void observe(Observable<const Status *> *source) { statusObserver.observe(source); }
+  // Start observing a source of data
+  void observe(Observable<const Status *> *source) { statusObserver.observe(source); }
 
-    // Determines whether or not existing data matches the data in another Status instance
-    bool matches(const Status *otherStatus) const { return true; }
+  // Determines whether or not existing data matches the data in another Status instance
+  bool matches(const Status *otherStatus) const { return true; }
 
-    bool isInitialized() const { return initialized; }
+  bool isInitialized() const { return initialized; }
 
-    int getStatusType() const { return statusType; }
+  int getStatusType() const { return statusType; }
 
-    // Called when the Observable we're observing generates a new notification
-    int updateStatus(const Status *newStatus) { return 0; }
+  // Called when the Observable we're observing generates a new notification
+  int updateStatus(const Status *newStatus) { return 0; }
 };
 }; // namespace meshtastic

src/airtime.cpp

@@ -9,202 +9,175 @@ AirTime *airTime = NULL;
 uint32_t air_period_tx[PERIODS_TO_LOG];
 uint32_t air_period_rx[PERIODS_TO_LOG];
 
-void AirTime::logAirtime(reportTypes reportType, uint32_t airtime_ms)
-{
+void AirTime::logAirtime(reportTypes reportType, uint32_t airtime_ms) {
 
-    if (reportType == TX_LOG) {
-        LOG_DEBUG("Packet TX: %ums", airtime_ms);
-        this->airtimes.periodTX[0] = this->airtimes.periodTX[0] + airtime_ms;
-        air_period_tx[0] = air_period_tx[0] + airtime_ms;
+  if (reportType == TX_LOG) {
+    LOG_DEBUG("Packet TX: %ums", airtime_ms);
+    this->airtimes.periodTX[0] = this->airtimes.periodTX[0] + airtime_ms;
+    air_period_tx[0] = air_period_tx[0] + airtime_ms;
 
-        this->utilizationTX[this->getPeriodUtilHour()] = this->utilizationTX[this->getPeriodUtilHour()] + airtime_ms;
-    } else if (reportType == RX_LOG) {
-        LOG_DEBUG("Packet RX: %ums", airtime_ms);
-        this->airtimes.periodRX[0] = this->airtimes.periodRX[0] + airtime_ms;
-        air_period_rx[0] = air_period_rx[0] + airtime_ms;
-    } else if (reportType == RX_ALL_LOG) {
-        LOG_DEBUG("Packet RX (noise?) : %ums", airtime_ms);
-        this->airtimes.periodRX_ALL[0] = this->airtimes.periodRX_ALL[0] + airtime_ms;
+    this->utilizationTX[this->getPeriodUtilHour()] = this->utilizationTX[this->getPeriodUtilHour()] + airtime_ms;
+  } else if (reportType == RX_LOG) {
+    LOG_DEBUG("Packet RX: %ums", airtime_ms);
+    this->airtimes.periodRX[0] = this->airtimes.periodRX[0] + airtime_ms;
+    air_period_rx[0] = air_period_rx[0] + airtime_ms;
+  } else if (reportType == RX_ALL_LOG) {
+    LOG_DEBUG("Packet RX (noise?) : %ums", airtime_ms);
+    this->airtimes.periodRX_ALL[0] = this->airtimes.periodRX_ALL[0] + airtime_ms;
+  }
+
+  // Log all airtime type for channel utilization
+  this->channelUtilization[this->getPeriodUtilMinute()] = channelUtilization[this->getPeriodUtilMinute()] + airtime_ms;
+}
+
+uint8_t AirTime::currentPeriodIndex() { return ((getSecondsSinceBoot() / SECONDS_PER_PERIOD) % PERIODS_TO_LOG); }
+
+uint8_t AirTime::getPeriodUtilMinute() { return (getSecondsSinceBoot() / 10) % CHANNEL_UTILIZATION_PERIODS; }
+
+uint8_t AirTime::getPeriodUtilHour() { return (getSecondsSinceBoot() / 60) % MINUTES_IN_HOUR; }
+
+void AirTime::airtimeRotatePeriod() {
+
+  if (this->airtimes.lastPeriodIndex != this->currentPeriodIndex()) {
+    LOG_DEBUG("Rotate airtimes to a new period = %u", this->currentPeriodIndex());
+
+    for (int i = PERIODS_TO_LOG - 2; i >= 0; --i) {
+      this->airtimes.periodTX[i + 1] = this->airtimes.periodTX[i];
+      this->airtimes.periodRX[i + 1] = this->airtimes.periodRX[i];
+      this->airtimes.periodRX_ALL[i + 1] = this->airtimes.periodRX_ALL[i];
+
+      air_period_tx[i + 1] = this->airtimes.periodTX[i];
+      air_period_rx[i + 1] = this->airtimes.periodRX[i];
     }
 
-    // Log all airtime type for channel utilization
-    this->channelUtilization[this->getPeriodUtilMinute()] = channelUtilization[this->getPeriodUtilMinute()] + airtime_ms;
+    this->airtimes.periodTX[0] = 0;
+    this->airtimes.periodRX[0] = 0;
+    this->airtimes.periodRX_ALL[0] = 0;
+
+    air_period_tx[0] = 0;
+    air_period_rx[0] = 0;
+
+    this->airtimes.lastPeriodIndex = this->currentPeriodIndex();
+  }
 }
 
-uint8_t AirTime::currentPeriodIndex()
-{
-    return ((getSecondsSinceBoot() / SECONDS_PER_PERIOD) % PERIODS_TO_LOG);
+uint32_t *AirTime::airtimeReport(reportTypes reportType) {
+
+  if (reportType == TX_LOG) {
+    return this->airtimes.periodTX;
+  } else if (reportType == RX_LOG) {
+    return this->airtimes.periodRX;
+  } else if (reportType == RX_ALL_LOG) {
+    return this->airtimes.periodRX_ALL;
+  }
+  return 0;
 }
 
-uint8_t AirTime::getPeriodUtilMinute()
-{
-    return (getSecondsSinceBoot() / 10) % CHANNEL_UTILIZATION_PERIODS;
+uint8_t AirTime::getPeriodsToLog() { return PERIODS_TO_LOG; }
+
+uint32_t AirTime::getSecondsPerPeriod() { return SECONDS_PER_PERIOD; }
+
+uint32_t AirTime::getSecondsSinceBoot() { return this->secSinceBoot; }
+
+float AirTime::channelUtilizationPercent() {
+  uint32_t sum = 0;
+  for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
+    sum += this->channelUtilization[i];
+  }
+
+  return (float(sum) / float(CHANNEL_UTILIZATION_PERIODS * 10 * 1000)) * 100;
 }
 
-uint8_t AirTime::getPeriodUtilHour()
-{
-    return (getSecondsSinceBoot() / 60) % MINUTES_IN_HOUR;
+float AirTime::utilizationTXPercent() {
+  uint32_t sum = 0;
+  for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) {
+    sum += this->utilizationTX[i];
+  }
+
+  return (float(sum) / float(MS_IN_HOUR)) * 100;
 }
 
-void AirTime::airtimeRotatePeriod()
-{
-
-    if (this->airtimes.lastPeriodIndex != this->currentPeriodIndex()) {
-        LOG_DEBUG("Rotate airtimes to a new period = %u", this->currentPeriodIndex());
-
-        for (int i = PERIODS_TO_LOG - 2; i >= 0; --i) {
-            this->airtimes.periodTX[i + 1] = this->airtimes.periodTX[i];
-            this->airtimes.periodRX[i + 1] = this->airtimes.periodRX[i];
-            this->airtimes.periodRX_ALL[i + 1] = this->airtimes.periodRX_ALL[i];
-
-            air_period_tx[i + 1] = this->airtimes.periodTX[i];
-            air_period_rx[i + 1] = this->airtimes.periodRX[i];
-        }
-
-        this->airtimes.periodTX[0] = 0;
-        this->airtimes.periodRX[0] = 0;
-        this->airtimes.periodRX_ALL[0] = 0;
-
-        air_period_tx[0] = 0;
-        air_period_rx[0] = 0;
-
-        this->airtimes.lastPeriodIndex = this->currentPeriodIndex();
-    }
-}
-
-uint32_t *AirTime::airtimeReport(reportTypes reportType)
-{
-
-    if (reportType == TX_LOG) {
-        return this->airtimes.periodTX;
-    } else if (reportType == RX_LOG) {
-        return this->airtimes.periodRX;
-    } else if (reportType == RX_ALL_LOG) {
-        return this->airtimes.periodRX_ALL;
-    }
-    return 0;
-}
-
-uint8_t AirTime::getPeriodsToLog()
-{
-    return PERIODS_TO_LOG;
-}
-
-uint32_t AirTime::getSecondsPerPeriod()
-{
-    return SECONDS_PER_PERIOD;
-}
-
-uint32_t AirTime::getSecondsSinceBoot()
-{
-    return this->secSinceBoot;
-}
-
-float AirTime::channelUtilizationPercent()
-{
-    uint32_t sum = 0;
-    for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
-        sum += this->channelUtilization[i];
-    }
-
-    return (float(sum) / float(CHANNEL_UTILIZATION_PERIODS * 10 * 1000)) * 100;
-}
-
-float AirTime::utilizationTXPercent()
-{
-    uint32_t sum = 0;
-    for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) {
-        sum += this->utilizationTX[i];
-    }
-
-    return (float(sum) / float(MS_IN_HOUR)) * 100;
-}
-
-bool AirTime::isTxAllowedChannelUtil(bool polite)
-{
-    uint8_t percentage = (polite ? polite_channel_util_percent : max_channel_util_percent);
-    if (channelUtilizationPercent() < percentage) {
-        return true;
-    } else {
-        LOG_WARN("Ch. util >%d%%. Skip send", percentage);
-        return false;
-    }
-}
-
-bool AirTime::isTxAllowedAirUtil()
-{
-    if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
-        if (utilizationTXPercent() < myRegion->dutyCycle * polite_duty_cycle_percent / 100) {
-            return true;
-        } else {
-            LOG_WARN("TX air util. >%f%%. Skip send", myRegion->dutyCycle * polite_duty_cycle_percent / 100);
-            return false;
-        }
-    }
+bool AirTime::isTxAllowedChannelUtil(bool polite) {
+  uint8_t percentage = (polite ? polite_channel_util_percent : max_channel_util_percent);
+  if (channelUtilizationPercent() < percentage) {
     return true;
+  } else {
+    LOG_WARN("Ch. util >%d%%. Skip send", percentage);
+    return false;
+  }
+}
+
+bool AirTime::isTxAllowedAirUtil() {
+  if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
+    if (utilizationTXPercent() < myRegion->dutyCycle * polite_duty_cycle_percent / 100) {
+      return true;
+    } else {
+      LOG_WARN("TX air util. >%f%%. Skip send", myRegion->dutyCycle * polite_duty_cycle_percent / 100);
+      return false;
+    }
+  }
+  return true;
 }
 
 // Get the amount of minutes we have to be silent before we can send again
-uint8_t AirTime::getSilentMinutes(float txPercent, float dutyCycle)
-{
-    float newTxPercent = txPercent;
-    for (int8_t i = MINUTES_IN_HOUR - 1; i >= 0; --i) {
-        newTxPercent -= ((float)this->utilizationTX[i] / (MS_IN_MINUTE * MINUTES_IN_HOUR / 100));
-        if (newTxPercent < dutyCycle)
-            return MINUTES_IN_HOUR - 1 - i;
-    }
+uint8_t AirTime::getSilentMinutes(float txPercent, float dutyCycle) {
+  float newTxPercent = txPercent;
+  for (int8_t i = MINUTES_IN_HOUR - 1; i >= 0; --i) {
+    newTxPercent -= ((float)this->utilizationTX[i] / (MS_IN_MINUTE * MINUTES_IN_HOUR / 100));
+    if (newTxPercent < dutyCycle)
+      return MINUTES_IN_HOUR - 1 - i;
+  }
 
-    return MINUTES_IN_HOUR;
+  return MINUTES_IN_HOUR;
 }
 
 AirTime::AirTime() : concurrency::OSThread("AirTime"), airtimes({}) {}
 
-int32_t AirTime::runOnce()
-{
-    secSinceBoot++;
+int32_t AirTime::runOnce() {
+  secSinceBoot++;
 
-    uint8_t utilPeriod = this->getPeriodUtilMinute();
-    uint8_t utilPeriodTX = this->getPeriodUtilHour();
+  uint8_t utilPeriod = this->getPeriodUtilMinute();
+  uint8_t utilPeriodTX = this->getPeriodUtilHour();
 
-    if (firstTime) {
+  if (firstTime) {
 
-        // Init utilizationTX window to all 0
-        for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) {
-            this->utilizationTX[i] = 0;
-        }
-
-        // Init channelUtilization window to all 0
-        for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
-            this->channelUtilization[i] = 0;
-        }
-
-        // Init airtime windows to all 0
-        for (int i = 0; i < PERIODS_TO_LOG; i++) {
-            this->airtimes.periodTX[i] = 0;
-            this->airtimes.periodRX[i] = 0;
-            this->airtimes.periodRX_ALL[i] = 0;
-
-            // air_period_tx[i] = 0;
-            // air_period_rx[i] = 0;
-        }
-
-        firstTime = false;
-        lastUtilPeriod = utilPeriod;
-    } else {
-        this->airtimeRotatePeriod();
-
-        // Reset the channelUtilization window when we roll over
-        if (lastUtilPeriod != utilPeriod) {
-            lastUtilPeriod = utilPeriod;
-
-            this->channelUtilization[utilPeriod] = 0;
-        }
-
-        if (lastUtilPeriodTX != utilPeriodTX) {
-            lastUtilPeriodTX = utilPeriodTX;
-
-            this->utilizationTX[utilPeriodTX] = 0;
-        }
+    // Init utilizationTX window to all 0
+    for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) {
+      this->utilizationTX[i] = 0;
     }
-    return (1000 * 1);
+
+    // Init channelUtilization window to all 0
+    for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
+      this->channelUtilization[i] = 0;
+    }
+
+    // Init airtime windows to all 0
+    for (int i = 0; i < PERIODS_TO_LOG; i++) {
+      this->airtimes.periodTX[i] = 0;
+      this->airtimes.periodRX[i] = 0;
+      this->airtimes.periodRX_ALL[i] = 0;
+
+      // air_period_tx[i] = 0;
+      // air_period_rx[i] = 0;
+    }
+
+    firstTime = false;
+    lastUtilPeriod = utilPeriod;
+  } else {
+    this->airtimeRotatePeriod();
+
+    // Reset the channelUtilization window when we roll over
+    if (lastUtilPeriod != utilPeriod) {
+      lastUtilPeriod = utilPeriod;
+
+      this->channelUtilization[utilPeriod] = 0;
+    }
+
+    if (lastUtilPeriodTX != utilPeriodTX) {
+      lastUtilPeriodTX = utilPeriodTX;
+
+      this->utilizationTX[utilPeriodTX] = 0;
+    }
+  }
+  return (1000 * 1);
 }

src/airtime.h

@@ -39,51 +39,50 @@ void logAirtime(reportTypes reportType, uint32_t airtime_ms);
 
 uint32_t *airtimeReport(reportTypes reportType);
 
-class AirTime : private concurrency::OSThread
-{
+class AirTime : private concurrency::OSThread {
 
-  public:
-    AirTime();
+public:
+  AirTime();
 
-    void logAirtime(reportTypes reportType, uint32_t airtime_ms);
-    float channelUtilizationPercent();
-    float utilizationTXPercent();
+  void logAirtime(reportTypes reportType, uint32_t airtime_ms);
+  float channelUtilizationPercent();
+  float utilizationTXPercent();
 
-    float UtilizationPercentTX();
-    uint32_t channelUtilization[CHANNEL_UTILIZATION_PERIODS] = {0};
-    uint32_t utilizationTX[MINUTES_IN_HOUR] = {0};
+  float UtilizationPercentTX();
+  uint32_t channelUtilization[CHANNEL_UTILIZATION_PERIODS] = {0};
+  uint32_t utilizationTX[MINUTES_IN_HOUR] = {0};
 
-    void airtimeRotatePeriod();
-    uint8_t getPeriodsToLog();
-    uint32_t getSecondsPerPeriod();
-    uint32_t getSecondsSinceBoot();
-    uint32_t *airtimeReport(reportTypes reportType);
-    uint8_t getSilentMinutes(float txPercent, float dutyCycle);
-    bool isTxAllowedChannelUtil(bool polite = false);
-    bool isTxAllowedAirUtil();
+  void airtimeRotatePeriod();
+  uint8_t getPeriodsToLog();
+  uint32_t getSecondsPerPeriod();
+  uint32_t getSecondsSinceBoot();
+  uint32_t *airtimeReport(reportTypes reportType);
+  uint8_t getSilentMinutes(float txPercent, float dutyCycle);
+  bool isTxAllowedChannelUtil(bool polite = false);
+  bool isTxAllowedAirUtil();
 
-  private:
-    bool firstTime = true;
-    uint8_t lastUtilPeriod = 0;
-    uint8_t lastUtilPeriodTX = 0;
-    uint32_t secSinceBoot = 0;
-    uint8_t max_channel_util_percent = 40;
-    uint8_t polite_channel_util_percent = 25;
-    uint8_t polite_duty_cycle_percent = 50; // half of Duty Cycle allowance is ok for metadata
+private:
+  bool firstTime = true;
+  uint8_t lastUtilPeriod = 0;
+  uint8_t lastUtilPeriodTX = 0;
+  uint32_t secSinceBoot = 0;
+  uint8_t max_channel_util_percent = 40;
+  uint8_t polite_channel_util_percent = 25;
+  uint8_t polite_duty_cycle_percent = 50; // half of Duty Cycle allowance is ok for metadata
 
-    struct airtimeStruct {
-        uint32_t periodTX[PERIODS_TO_LOG];     // AirTime transmitted
-        uint32_t periodRX[PERIODS_TO_LOG];     // AirTime received and repeated (Only valid mesh packets)
-        uint32_t periodRX_ALL[PERIODS_TO_LOG]; // AirTime received regardless of valid mesh packet. Could include noise.
-        uint8_t lastPeriodIndex;
-    } airtimes;
+  struct airtimeStruct {
+    uint32_t periodTX[PERIODS_TO_LOG];     // AirTime transmitted
+    uint32_t periodRX[PERIODS_TO_LOG];     // AirTime received and repeated (Only valid mesh packets)
+    uint32_t periodRX_ALL[PERIODS_TO_LOG]; // AirTime received regardless of valid mesh packet. Could include noise.
+    uint8_t lastPeriodIndex;
+  } airtimes;
 
-    uint8_t getPeriodUtilMinute();
-    uint8_t getPeriodUtilHour();
-    uint8_t currentPeriodIndex();
+  uint8_t getPeriodUtilMinute();
+  uint8_t getPeriodUtilHour();
+  uint8_t currentPeriodIndex();
 
-  protected:
-    virtual int32_t runOnce() override;
+protected:
+  virtual int32_t runOnce() override;
 };
 
 extern AirTime *airTime;

src/buzz/BuzzerFeedbackThread.cpp

@@ -5,57 +5,58 @@
 
 BuzzerFeedbackThread *buzzerFeedbackThread;
 
-BuzzerFeedbackThread::BuzzerFeedbackThread()
-{
-    if (inputBroker)
-        inputObserver.observe(inputBroker);
+BuzzerFeedbackThread::BuzzerFeedbackThread() {
+  if (inputBroker)
+    inputObserver.observe(inputBroker);
 }
 
-int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
-{
-    // Only provide feedback if buzzer is enabled for notifications
-    if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY) {
-        return 0; // Let other handlers process the event
+int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event) {
+  // Only provide feedback if buzzer is enabled for notifications
+  if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
+      config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY ||
+      config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY) {
+    return 0; // Let other handlers process the event
+  }
+
+  // Handle different input events with appropriate buzzer feedback
+  switch (event->inputEvent) {
+  case INPUT_BROKER_USER_PRESS:
+  case INPUT_BROKER_ALT_PRESS:
+    playClick(); // Low delay feedback
+    break;
+
+  case INPUT_BROKER_SELECT:
+  case INPUT_BROKER_SELECT_LONG:
+    playBeep(); // Confirmation feedback
+    break;
+
+  case INPUT_BROKER_UP:
+  case INPUT_BROKER_UP_LONG:
+  case INPUT_BROKER_DOWN:
+  case INPUT_BROKER_DOWN_LONG:
+  case INPUT_BROKER_LEFT:
+  case INPUT_BROKER_RIGHT:
+    playChirp(); // Navigation feedback
+    break;
+
+  case INPUT_BROKER_CANCEL:
+  case INPUT_BROKER_BACK:
+    playBoop(); // Cancel/back feedback
+    break;
+
+  case INPUT_BROKER_SEND_PING:
+    playComboTune(); // Ping sent feedback
+    break;
+
+  default:
+    // For other events, check if it's a printable character
+    if (event->kbchar >= 32 && event->kbchar <= 126) {
+      // Typing feedback - very short boop
+      // Removing this for now, too chatty
+      // playChirp();
     }
+    break;
+  }
 
-    // Handle different input events with appropriate buzzer feedback
-    switch (event->inputEvent) {
-    case INPUT_BROKER_USER_PRESS:
-    case INPUT_BROKER_ALT_PRESS:
-    case INPUT_BROKER_SELECT:
-    case INPUT_BROKER_SELECT_LONG:
-        playBeep(); // Confirmation feedback
-        break;
-
-    case INPUT_BROKER_UP:
-    case INPUT_BROKER_UP_LONG:
-    case INPUT_BROKER_DOWN:
-    case INPUT_BROKER_DOWN_LONG:
-    case INPUT_BROKER_LEFT:
-    case INPUT_BROKER_RIGHT:
-        playChirp(); // Navigation feedback
-        break;
-
-    case INPUT_BROKER_CANCEL:
-    case INPUT_BROKER_BACK:
-        playBoop(); // Cancel/back feedback
-        break;
-
-    case INPUT_BROKER_SEND_PING:
-        playComboTune(); // Ping sent feedback
-        break;
-
-    default:
-        // For other events, check if it's a printable character
-        if (event->kbchar >= 32 && event->kbchar <= 126) {
-            // Typing feedback - very short boop
-            // Removing this for now, too chatty
-            // playChirp();
-        }
-        break;
-    }
-
-    return 0; // Allow other handlers to process the event
-}
+  return 0; // Allow other handlers to process the event
+}

src/buzz/BuzzerFeedbackThread.h

@@ -4,14 +4,13 @@
 #include "concurrency/OSThread.h"
 #include "input/InputBroker.h"
 
-class BuzzerFeedbackThread
-{
-    CallbackObserver<BuzzerFeedbackThread, const InputEvent *> inputObserver =
-        CallbackObserver<BuzzerFeedbackThread, const InputEvent *>(this, &BuzzerFeedbackThread::handleInputEvent);
+class BuzzerFeedbackThread {
+  CallbackObserver<BuzzerFeedbackThread, const InputEvent *> inputObserver =
+      CallbackObserver<BuzzerFeedbackThread, const InputEvent *>(this, &BuzzerFeedbackThread::handleInputEvent);
 
-  public:
-    BuzzerFeedbackThread();
-    int handleInputEvent(const InputEvent *event);
+public:
+  BuzzerFeedbackThread();
+  int handleInputEvent(const InputEvent *event);
 };
 
 extern BuzzerFeedbackThread *buzzerFeedbackThread;

src/buzz/buzz.cpp

@@ -11,8 +11,8 @@ extern "C" void delay(uint32_t dwMs);
 #endif
 
 struct ToneDuration {
-    int frequency_khz;
-    int duration_ms;
+  int frequency_khz;
+  int duration_ms;
 };
 
 // Some common frequencies.
@@ -42,98 +42,92 @@ const int DURATION_1_2 = 500;  // 1/2 note
 const int DURATION_3_4 = 750;  // 3/4 note
 const int DURATION_1_1 = 1000; // 1/1 note
 
-void playTones(const ToneDuration *tone_durations, int size)
-{
-    if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY) {
-        // Buzzer is disabled or not set to system tones
-        return;
-    }
+void playTones(const ToneDuration *tone_durations, int size) {
+  if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
+      config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY) {
+    // Buzzer is disabled or not set to system tones
+    return;
+  }
 #ifdef PIN_BUZZER
-    if (!config.device.buzzer_gpio)
-        config.device.buzzer_gpio = PIN_BUZZER;
+  if (!config.device.buzzer_gpio)
+    config.device.buzzer_gpio = PIN_BUZZER;
 #endif
-    if (config.device.buzzer_gpio) {
-        for (int i = 0; i < size; i++) {
-            const auto &tone_duration = tone_durations[i];
-            tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
-            // to distinguish the notes, set a minimum time between them.
-            delay(1.3 * tone_duration.duration_ms);
-        }
+  if (config.device.buzzer_gpio) {
+    for (int i = 0; i < size; i++) {
+      const auto &tone_duration = tone_durations[i];
+      tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
+      // to distinguish the notes, set a minimum time between them.
+      delay(1.3 * tone_duration.duration_ms);
     }
+  }
 }
 
-void playBeep()
-{
-    ToneDuration melody[] = {{NOTE_B3, DURATION_1_8}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playBeep() {
+  ToneDuration melody[] = {{NOTE_B3, DURATION_1_8}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playLongBeep()
-{
-    ToneDuration melody[] = {{NOTE_B3, DURATION_1_1}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playLongBeep() {
+  ToneDuration melody[] = {{NOTE_B3, DURATION_1_1}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playGPSEnableBeep()
-{
+void playGPSEnableBeep() {
 #if defined(R1_NEO) || defined(MUZI_BASE)
-    ToneDuration melody[] = {
-        {NOTE_F5, DURATION_1_2}, {NOTE_G6, DURATION_1_8}, {NOTE_E7, DURATION_1_4}, {NOTE_SILENT, DURATION_1_2}};
+  ToneDuration melody[] = {{NOTE_F5, DURATION_1_2}, {NOTE_G6, DURATION_1_8}, {NOTE_E7, DURATION_1_4}, {NOTE_SILENT, DURATION_1_2}};
 #else
-    ToneDuration melody[] = {{NOTE_C3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_CS4, DURATION_1_4}};
+  ToneDuration melody[] = {{NOTE_C3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_CS4, DURATION_1_4}};
 #endif
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playGPSDisableBeep()
-{
+void playGPSDisableBeep() {
 #if defined(R1_NEO) || defined(MUZI_BASE)
-    ToneDuration melody[] = {{NOTE_B4, DURATION_1_16}, {NOTE_B4, DURATION_1_16},   {NOTE_SILENT, DURATION_1_8},
-                             {NOTE_F3, DURATION_1_16}, {NOTE_F3, DURATION_1_16},   {NOTE_SILENT, DURATION_1_8},
-                             {NOTE_C3, DURATION_1_1},  {NOTE_SILENT, DURATION_1_1}};
+  ToneDuration melody[] = {{NOTE_B4, DURATION_1_16}, {NOTE_B4, DURATION_1_16},    {NOTE_SILENT, DURATION_1_8}, {NOTE_F3, DURATION_1_16},
+                           {NOTE_F3, DURATION_1_16}, {NOTE_SILENT, DURATION_1_8}, {NOTE_C3, DURATION_1_1},     {NOTE_SILENT, DURATION_1_1}};
 #else
-    ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_C3, DURATION_1_4}};
+  ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}, {NOTE_C3, DURATION_1_4}};
 #endif
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playStartMelody()
-{
-    ToneDuration melody[] = {{NOTE_FS3, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_CS4, DURATION_1_4}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playStartMelody() {
+  ToneDuration melody[] = {{NOTE_FS3, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_CS4, DURATION_1_4}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playShutdownMelody()
-{
-    ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}};
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playShutdownMelody() {
+  ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playChirp()
-{
-    // A short, friendly "chirp" sound for key presses
-    ToneDuration melody[] = {{NOTE_AS3, 20}}; // Very short AS3 note
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playChirp() {
+  // A short, friendly "chirp" sound for key presses
+  ToneDuration melody[] = {{NOTE_AS3, 20}}; // Short AS3 note
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playBoop()
-{
-    // A short, friendly "boop" sound for button presses
-    ToneDuration melody[] = {{NOTE_A3, 50}}; // Very short A3 note
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playClick() {
+  // A very short "click" sound with minimum delay; ideal for rotary encoder events
+  ToneDuration melody[] = {{NOTE_AS3, 1}}; // Very Short AS3
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playLongPressLeadUp()
-{
-    // An ascending lead-up sequence for long press - builds anticipation
-    ToneDuration melody[] = {
-        {NOTE_C3, 100}, // Start low
-        {NOTE_E3, 100}, // Step up
-        {NOTE_G3, 100}, // Keep climbing
-        {NOTE_B3, 150}  // Peak with longer note for emphasis
-    };
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playBoop() {
+  // A short, friendly "boop" sound for button presses
+  ToneDuration melody[] = {{NOTE_A3, 50}}; // Very short A3 note
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+}
+
+void playLongPressLeadUp() {
+  // An ascending lead-up sequence for long press - builds anticipation
+  ToneDuration melody[] = {
+      {NOTE_C3, 100}, // Start low
+      {NOTE_E3, 100}, // Step up
+      {NOTE_G3, 100}, // Keep climbing
+      {NOTE_B3, 150}  // Peak with longer note for emphasis
+  };
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
 // Static state for progressive lead-up notes
@@ -146,39 +140,34 @@ static const ToneDuration leadUpNotes[] = {
 };
 static const int leadUpNotesCount = sizeof(leadUpNotes) / sizeof(ToneDuration);
 
-bool playNextLeadUpNote()
-{
-    if (leadUpNoteIndex >= leadUpNotesCount) {
-        return false; // All notes have been played
-    }
+bool playNextLeadUpNote() {
+  if (leadUpNoteIndex >= leadUpNotesCount) {
+    return false; // All notes have been played
+  }
 
-    // Use playTones to handle buzzer logic consistently
-    const auto &note = leadUpNotes[leadUpNoteIndex];
-    playTones(&note, 1); // Play single note using existing playTones function
+  // Use playTones to handle buzzer logic consistently
+  const auto &note = leadUpNotes[leadUpNoteIndex];
+  playTones(&note, 1); // Play single note using existing playTones function
 
-    leadUpNoteIndex++;
+  leadUpNoteIndex++;
 
-    if (leadUpNoteIndex >= leadUpNotesCount) {
-        return false; // this was the final note
-    }
-    return true; // Note was played (playTones handles buzzer availability internally)
+  if (leadUpNoteIndex >= leadUpNotesCount) {
+    return false; // this was the final note
+  }
+  return true; // Note was played (playTones handles buzzer availability internally)
 }
 
-void resetLeadUpSequence()
-{
-    leadUpNoteIndex = 0;
-}
+void resetLeadUpSequence() { leadUpNoteIndex = 0; }
 
-void playComboTune()
-{
-    // Quick high-pitched notes with trills
-    ToneDuration melody[] = {
-        {NOTE_G3, 80},  // Quick chirp
-        {NOTE_B3, 60},  // Higher chirp
-        {NOTE_CS4, 80}, // Even higher
-        {NOTE_G3, 60},  // Quick trill down
-        {NOTE_CS4, 60}, // Quick trill up
-        {NOTE_B3, 120}  // Ending chirp
-    };
-    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+void playComboTune() {
+  // Quick high-pitched notes with trills
+  ToneDuration melody[] = {
+      {NOTE_G3, 80},  // Quick chirp
+      {NOTE_B3, 60},  // Higher chirp
+      {NOTE_CS4, 80}, // Even higher
+      {NOTE_G3, 60},  // Quick trill down
+      {NOTE_CS4, 60}, // Quick trill up
+      {NOTE_B3, 120}  // Ending chirp
+  };
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }

src/buzz/buzz.h

@@ -9,6 +9,7 @@ void playGPSDisableBeep();
 void playComboTune();
 void playBoop();
 void playChirp();
+void playClick();
 void playLongPressLeadUp();
 bool playNextLeadUpNote();  // Play the next note in the lead-up sequence
 void resetLeadUpSequence(); // Reset the lead-up sequence to start from beginning

src/commands.h

@@ -4,15 +4,15 @@
  */
 
 enum class Cmd {
-    INVALID,
-    SET_ON,
-    SET_OFF,
-    ON_PRESS,
-    START_ALERT_FRAME,
-    STOP_ALERT_FRAME,
-    START_FIRMWARE_UPDATE_SCREEN,
-    STOP_BOOT_SCREEN,
-    SHOW_PREV_FRAME,
-    SHOW_NEXT_FRAME,
-    NOOP
+  INVALID,
+  SET_ON,
+  SET_OFF,
+  ON_PRESS,
+  START_ALERT_FRAME,
+  STOP_ALERT_FRAME,
+  START_FIRMWARE_UPDATE_SCREEN,
+  STOP_BOOT_SCREEN,
+  SHOW_PREV_FRAME,
+  SHOW_NEXT_FRAME,
+  NOOP
 };

src/concurrency/BinarySemaphoreFreeRTOS.cpp

@@ -4,35 +4,21 @@
 
 #ifdef HAS_FREE_RTOS
 
-namespace concurrency
-{
+namespace concurrency {
 
-BinarySemaphoreFreeRTOS::BinarySemaphoreFreeRTOS() : semaphore(xSemaphoreCreateBinary())
-{
-    assert(semaphore);
-}
+BinarySemaphoreFreeRTOS::BinarySemaphoreFreeRTOS() : semaphore(xSemaphoreCreateBinary()) { assert(semaphore); }
 
-BinarySemaphoreFreeRTOS::~BinarySemaphoreFreeRTOS()
-{
-    vSemaphoreDelete(semaphore);
-}
+BinarySemaphoreFreeRTOS::~BinarySemaphoreFreeRTOS() { vSemaphoreDelete(semaphore); }
 
 /**
  * Returns false if we were interrupted
  */
-bool BinarySemaphoreFreeRTOS::take(uint32_t msec)
-{
-    return xSemaphoreTake(semaphore, pdMS_TO_TICKS(msec));
-}
+bool BinarySemaphoreFreeRTOS::take(uint32_t msec) { return xSemaphoreTake(semaphore, pdMS_TO_TICKS(msec)); }
 
-void BinarySemaphoreFreeRTOS::give()
-{
-    xSemaphoreGive(semaphore);
-}
+void BinarySemaphoreFreeRTOS::give() { xSemaphoreGive(semaphore); }
 
-IRAM_ATTR void BinarySemaphoreFreeRTOS::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken)
-{
-    xSemaphoreGiveFromISR(semaphore, pxHigherPriorityTaskWoken);
+IRAM_ATTR void BinarySemaphoreFreeRTOS::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken) {
+  xSemaphoreGiveFromISR(semaphore, pxHigherPriorityTaskWoken);
 }
 
 } // namespace concurrency

src/concurrency/BinarySemaphoreFreeRTOS.h

@@ -2,27 +2,25 @@
 
 #include "../freertosinc.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 #ifdef HAS_FREE_RTOS
 
-class BinarySemaphoreFreeRTOS
-{
-    SemaphoreHandle_t semaphore;
+class BinarySemaphoreFreeRTOS {
+  SemaphoreHandle_t semaphore;
 
-  public:
-    BinarySemaphoreFreeRTOS();
-    ~BinarySemaphoreFreeRTOS();
+public:
+  BinarySemaphoreFreeRTOS();
+  ~BinarySemaphoreFreeRTOS();
 
-    /**
-     * Returns false if we timed out
-     */
-    bool take(uint32_t msec);
+  /**
+   * Returns false if we timed out
+   */
+  bool take(uint32_t msec);
 
-    void give();
+  void give();
 
-    void giveFromISR(BaseType_t *pxHigherPriorityTaskWoken);
+  void giveFromISR(BaseType_t *pxHigherPriorityTaskWoken);
 };
 
 #endif

src/concurrency/BinarySemaphorePosix.cpp

@@ -3,8 +3,7 @@
 
 #ifndef HAS_FREE_RTOS
 
-namespace concurrency
-{
+namespace concurrency {
 
 BinarySemaphorePosix::BinarySemaphorePosix() {}
 
@@ -13,10 +12,9 @@ BinarySemaphorePosix::~BinarySemaphorePosix() {}
 /**
  * Returns false if we timed out
  */
-bool BinarySemaphorePosix::take(uint32_t msec)
-{
-    delay(msec); // FIXME
-    return false;
+bool BinarySemaphorePosix::take(uint32_t msec) {
+  delay(msec); // FIXME
+  return false;
 }
 
 void BinarySemaphorePosix::give() {}

src/concurrency/BinarySemaphorePosix.h

@@ -2,27 +2,25 @@
 
 #include "../freertosinc.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 #ifndef HAS_FREE_RTOS
 
-class BinarySemaphorePosix
-{
-    // SemaphoreHandle_t semaphore;
+class BinarySemaphorePosix {
+  // SemaphoreHandle_t semaphore;
 
-  public:
-    BinarySemaphorePosix();
-    ~BinarySemaphorePosix();
+public:
+  BinarySemaphorePosix();
+  ~BinarySemaphorePosix();
 
-    /**
-     * Returns false if we timed out
-     */
-    bool take(uint32_t msec);
+  /**
+   * Returns false if we timed out
+   */
+  bool take(uint32_t msec);
 
-    void give();
+  void give();
 
-    void giveFromISR(BaseType_t *pxHigherPriorityTaskWoken);
+  void giveFromISR(BaseType_t *pxHigherPriorityTaskWoken);
 };
 
 #endif

src/concurrency/InterruptableDelay.cpp

@@ -1,8 +1,7 @@
 #include "concurrency/InterruptableDelay.h"
 #include "configuration.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 InterruptableDelay::InterruptableDelay() {}
 
@@ -11,25 +10,18 @@ InterruptableDelay::~InterruptableDelay() {}
 /**
  * Returns false if we were interrupted
  */
-bool InterruptableDelay::delay(uint32_t msec)
-{
-    // LOG_DEBUG("delay %u ", msec);
+bool InterruptableDelay::delay(uint32_t msec) {
+  // LOG_DEBUG("delay %u ", msec);
 
-    // sem take will return false if we timed out (i.e. were not interrupted)
-    bool r = semaphore.take(msec);
+  // sem take will return false if we timed out (i.e. were not interrupted)
+  bool r = semaphore.take(msec);
 
-    // LOG_DEBUG("interrupt=%d", r);
-    return !r;
+  // LOG_DEBUG("interrupt=%d", r);
+  return !r;
 }
 
-void InterruptableDelay::interrupt()
-{
-    semaphore.give();
-}
+void InterruptableDelay::interrupt() { semaphore.give(); }
 
-IRAM_ATTR void InterruptableDelay::interruptFromISR(BaseType_t *pxHigherPriorityTaskWoken)
-{
-    semaphore.giveFromISR(pxHigherPriorityTaskWoken);
-}
+IRAM_ATTR void InterruptableDelay::interruptFromISR(BaseType_t *pxHigherPriorityTaskWoken) { semaphore.giveFromISR(pxHigherPriorityTaskWoken); }
 
 } // namespace concurrency

src/concurrency/InterruptableDelay.h

@@ -10,32 +10,31 @@
 #define BinarySemaphore BinarySemaphorePosix
 #endif
 
-namespace concurrency
-{
+namespace concurrency {
 
 /**
  * An object that provides delay(msec) like functionality, but can be interrupted by calling interrupt().
  *
- * Useful for they top level loop() delay call to keep the CPU powered down until our next scheduled event or some external event.
+ * Useful for they top level loop() delay call to keep the CPU powered down until our next scheduled event or some
+ * external event.
  *
  * This is implemented for FreeRTOS but should be easy to port to other operating systems.
  */
-class InterruptableDelay
-{
-    BinarySemaphore semaphore;
+class InterruptableDelay {
+  BinarySemaphore semaphore;
 
-  public:
-    InterruptableDelay();
-    ~InterruptableDelay();
+public:
+  InterruptableDelay();
+  ~InterruptableDelay();
 
-    /**
-     * Returns false if we were interrupted
-     */
-    bool delay(uint32_t msec);
+  /**
+   * Returns false if we were interrupted
+   */
+  bool delay(uint32_t msec);
 
-    void interrupt();
+  void interrupt();
 
-    void interruptFromISR(BaseType_t *pxHigherPriorityTaskWoken);
+  void interruptFromISR(BaseType_t *pxHigherPriorityTaskWoken);
 };
 
 } // namespace concurrency

src/concurrency/Lock.cpp

@@ -2,30 +2,26 @@
 #include "configuration.h"
 #include <cassert>
 
-namespace concurrency
-{
+namespace concurrency {
 
 #ifdef HAS_FREE_RTOS
-Lock::Lock() : handle(xSemaphoreCreateBinary())
-{
-    assert(handle);
-    if (xSemaphoreGive(handle) == false) {
-        abort();
-    }
+Lock::Lock() : handle(xSemaphoreCreateBinary()) {
+  assert(handle);
+  if (xSemaphoreGive(handle) == false) {
+    abort();
+  }
 }
 
-void Lock::lock()
-{
-    if (xSemaphoreTake(handle, portMAX_DELAY) == false) {
-        abort();
-    }
+void Lock::lock() {
+  if (xSemaphoreTake(handle, portMAX_DELAY) == false) {
+    abort();
+  }
 }
 
-void Lock::unlock()
-{
-    if (xSemaphoreGive(handle) == false) {
-        abort();
-    }
+void Lock::unlock() {
+  if (xSemaphoreGive(handle) == false) {
+    abort();
+  }
 }
 #else
 Lock::Lock() {}

src/concurrency/Lock.h

@@ -2,33 +2,31 @@
 
 #include "../freertosinc.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 /**
  * @brief Simple wrapper around FreeRTOS API for implementing a mutex lock
  */
-class Lock
-{
-  public:
-    Lock();
+class Lock {
+public:
+  Lock();
 
-    Lock(const Lock &) = delete;
-    Lock &operator=(const Lock &) = delete;
+  Lock(const Lock &) = delete;
+  Lock &operator=(const Lock &) = delete;
 
-    /// Locks the lock.
-    //
-    // Must not be called from an ISR.
-    void lock();
+  /// Locks the lock.
+  //
+  // Must not be called from an ISR.
+  void lock();
 
-    // Unlocks the lock.
-    //
-    // Must not be called from an ISR.
-    void unlock();
+  // Unlocks the lock.
+  //
+  // Must not be called from an ISR.
+  void unlock();
 
-  private:
+private:
 #ifdef HAS_FREE_RTOS
-    SemaphoreHandle_t handle;
+  SemaphoreHandle_t handle;
 #endif
 };
 

src/concurrency/LockGuard.cpp

@@ -1,17 +1,10 @@
 #include "LockGuard.h"
 #include "configuration.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
-LockGuard::LockGuard(Lock *lock) : lock(lock)
-{
-    lock->lock();
-}
+LockGuard::LockGuard(Lock *lock) : lock(lock) { lock->lock(); }
 
-LockGuard::~LockGuard()
-{
-    lock->unlock();
-}
+LockGuard::~LockGuard() { lock->unlock(); }
 
 } // namespace concurrency

src/concurrency/LockGuard.h

@@ -2,23 +2,21 @@
 
 #include "Lock.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 /**
  * @brief RAII lock guard
  */
-class LockGuard
-{
-  public:
-    explicit LockGuard(Lock *lock);
-    ~LockGuard();
+class LockGuard {
+public:
+  explicit LockGuard(Lock *lock);
+  ~LockGuard();
 
-    LockGuard(const LockGuard &) = delete;
-    LockGuard &operator=(const LockGuard &) = delete;
+  LockGuard(const LockGuard &) = delete;
+  LockGuard &operator=(const LockGuard &) = delete;
 
-  private:
-    Lock *lock;
+private:
+  Lock *lock;
 };
 
 } // namespace concurrency

src/concurrency/NotifiedWorkerThread.cpp

@@ -2,45 +2,42 @@
 #include "configuration.h"
 #include "main.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 static bool debugNotification;
 
 /**
  * Notify this thread so it can run
  */
-bool NotifiedWorkerThread::notify(uint32_t v, bool overwrite)
-{
-    bool r = notifyCommon(v, overwrite);
+bool NotifiedWorkerThread::notify(uint32_t v, bool overwrite) {
+  bool r = notifyCommon(v, overwrite);
 
-    if (r)
-        mainDelay.interrupt();
+  if (r)
+    mainDelay.interrupt();
 
-    return r;
+  return r;
 }
 
 /**
  * Notify this thread so it can run
  */
-IRAM_ATTR bool NotifiedWorkerThread::notifyCommon(uint32_t v, bool overwrite)
-{
-    if (overwrite || notification == 0) {
-        enabled = true;
-        setInterval(0); // Run ASAP
-        runASAP = true;
+IRAM_ATTR bool NotifiedWorkerThread::notifyCommon(uint32_t v, bool overwrite) {
+  if (overwrite || notification == 0) {
+    enabled = true;
+    setInterval(0); // Run ASAP
+    runASAP = true;
 
-        notification = v;
-        if (debugNotification) {
-            LOG_DEBUG("Set notification %d", v);
-        }
-        return true;
-    } else {
-        if (debugNotification) {
-            LOG_DEBUG("Drop notification %d", v);
-        }
-        return false;
+    notification = v;
+    if (debugNotification) {
+      LOG_DEBUG("Set notification %d", v);
     }
+    return true;
+  } else {
+    if (debugNotification) {
+      LOG_DEBUG("Drop notification %d", v);
+    }
+    return false;
+  }
 }
 
 /**
@@ -48,47 +45,43 @@ IRAM_ATTR bool NotifiedWorkerThread::notifyCommon(uint32_t v, bool overwrite)
  *
  * This must be inline or IRAM_ATTR on ESP32
  */
-IRAM_ATTR bool NotifiedWorkerThread::notifyFromISR(BaseType_t *highPriWoken, uint32_t v, bool overwrite)
-{
-    bool r = notifyCommon(v, overwrite);
-    if (r)
-        mainDelay.interruptFromISR(highPriWoken);
+IRAM_ATTR bool NotifiedWorkerThread::notifyFromISR(BaseType_t *highPriWoken, uint32_t v, bool overwrite) {
+  bool r = notifyCommon(v, overwrite);
+  if (r)
+    mainDelay.interruptFromISR(highPriWoken);
 
-    return r;
+  return r;
 }
 
 /**
  * Schedule a notification to fire in delay msecs
  */
-bool NotifiedWorkerThread::notifyLater(uint32_t delay, uint32_t v, bool overwrite)
-{
-    bool didIt = notify(v, overwrite);
+bool NotifiedWorkerThread::notifyLater(uint32_t delay, uint32_t v, bool overwrite) {
+  bool didIt = notify(v, overwrite);
 
-    if (didIt) {                   // If we didn't already have something queued, override the delay to be larger
-        setIntervalFromNow(delay); // a new version of setInterval relative to the current time
-        if (debugNotification) {
-            LOG_DEBUG("Delay notification %u", delay);
-        }
+  if (didIt) {                 // If we didn't already have something queued, override the delay to be larger
+    setIntervalFromNow(delay); // a new version of setInterval relative to the current time
+    if (debugNotification) {
+      LOG_DEBUG("Delay notification %u", delay);
     }
+  }
 
-    return didIt;
+  return didIt;
 }
 
-void NotifiedWorkerThread::checkNotification()
-{
-    auto n = notification;
-    notification = 0; // clear notification
-    if (n) {
-        onNotify(n);
-    }
+void NotifiedWorkerThread::checkNotification() {
+  auto n = notification;
+  notification = 0; // clear notification
+  if (n) {
+    onNotify(n);
+  }
 }
 
-int32_t NotifiedWorkerThread::runOnce()
-{
-    enabled = false; // Only run once per notification
-    checkNotification();
+int32_t NotifiedWorkerThread::runOnce() {
+  enabled = false; // Only run once per notification
+  checkNotification();
 
-    return RUN_SAME;
+  return RUN_SAME;
 }
 
 } // namespace concurrency

src/concurrency/NotifiedWorkerThread.h

@@ -2,55 +2,53 @@
 
 #include "OSThread.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 /**
  * @brief A worker thread that waits on a freertos notification
  */
-class NotifiedWorkerThread : public OSThread
-{
-    /**
-     * The notification that was most recently used to wake the thread.  Read from runOnce()
-     */
-    uint32_t notification = 0;
+class NotifiedWorkerThread : public OSThread {
+  /**
+   * The notification that was most recently used to wake the thread.  Read from runOnce()
+   */
+  uint32_t notification = 0;
 
-  public:
-    NotifiedWorkerThread(const char *name) : OSThread(name) {}
+public:
+  NotifiedWorkerThread(const char *name) : OSThread(name) {}
 
-    /**
-     * Notify this thread so it can run
-     */
-    bool notify(uint32_t v, bool overwrite);
+  /**
+   * Notify this thread so it can run
+   */
+  bool notify(uint32_t v, bool overwrite);
 
-    /**
-     * Notify from an ISR
-     *
-     * This must be inline or IRAM_ATTR on ESP32
-     */
-    bool notifyFromISR(BaseType_t *highPriWoken, uint32_t v, bool overwrite);
+  /**
+   * Notify from an ISR
+   *
+   * This must be inline or IRAM_ATTR on ESP32
+   */
+  bool notifyFromISR(BaseType_t *highPriWoken, uint32_t v, bool overwrite);
 
-    /**
-     * Schedule a notification to fire in delay msecs
-     */
-    bool notifyLater(uint32_t delay, uint32_t v, bool overwrite);
+  /**
+   * Schedule a notification to fire in delay msecs
+   */
+  bool notifyLater(uint32_t delay, uint32_t v, bool overwrite);
 
-  protected:
-    virtual void onNotify(uint32_t notification) = 0;
+protected:
+  virtual void onNotify(uint32_t notification) = 0;
 
-    /// just calls checkNotification()
-    virtual int32_t runOnce() override;
+  /// just calls checkNotification()
+  virtual int32_t runOnce() override;
 
-    /// Sometimes we might want to check notifications independently of when our thread was getting woken up (i.e. if we are about
-    /// to change radio transmit/receive modes we want to handle any pending interrupts first).  You can call this method and if
-    /// any notifications are currently pending they will be handled immediately.
-    void checkNotification();
+  /// Sometimes we might want to check notifications independently of when our thread was getting woken up (i.e. if we
+  /// are about to change radio transmit/receive modes we want to handle any pending interrupts first).  You can call
+  /// this method and if any notifications are currently pending they will be handled immediately.
+  void checkNotification();
 
-  private:
-    /**
-     * Notify this thread so it can run
-     */
-    bool notifyCommon(uint32_t v, bool overwrite);
+private:
+  /**
+   * Notify this thread so it can run
+   */
+  bool notifyCommon(uint32_t v, bool overwrite);
 };
 
 } // namespace concurrency

src/concurrency/OSThread.cpp

@@ -3,8 +3,7 @@
 #include "memGet.h"
 #include <assert.h>
 
-namespace concurrency
-{
+namespace concurrency {
 
 /// Show debugging info for disabled threads
 bool OSThread::showDisabled;
@@ -20,93 +19,85 @@ const OSThread *OSThread::currentThread;
 ThreadController mainController, timerController;
 InterruptableDelay mainDelay;
 
-void OSThread::setup()
-{
-    mainController.ThreadName = "mainController";
-    timerController.ThreadName = "timerController";
+void OSThread::setup() {
+  mainController.ThreadName = "mainController";
+  timerController.ThreadName = "timerController";
 }
 
-OSThread::OSThread(const char *_name, uint32_t period, ThreadController *_controller)
-    : Thread(NULL, period), controller(_controller)
-{
-    assertIsSetup();
+OSThread::OSThread(const char *_name, uint32_t period, ThreadController *_controller) : Thread(NULL, period), controller(_controller) {
+  assertIsSetup();
 
-    ThreadName = _name;
+  ThreadName = _name;
 
-    if (controller) {
-        bool added = controller->add(this);
-        assert(added);
-    }
+  if (controller) {
+    bool added = controller->add(this);
+    assert(added);
+  }
 }
 
-OSThread::~OSThread()
-{
-    if (controller)
-        controller->remove(this);
+OSThread::~OSThread() {
+  if (controller)
+    controller->remove(this);
 }
 
 /**
  * Wait a specified number msecs starting from the current time (rather than the last time we were run)
  */
-void OSThread::setIntervalFromNow(unsigned long _interval)
-{
-    // Save interval
-    interval = _interval;
+void OSThread::setIntervalFromNow(unsigned long _interval) {
+  // Save interval
+  interval = _interval;
 
-    // Cache the next run based on the last_run
-    _cached_next_run = millis() + interval;
+  // Cache the next run based on the last_run
+  _cached_next_run = millis() + interval;
 }
 
-bool OSThread::shouldRun(unsigned long time)
-{
-    bool r = Thread::shouldRun(time);
+bool OSThread::shouldRun(unsigned long time) {
+  bool r = Thread::shouldRun(time);
 
-    if (showRun && r) {
-        LOG_DEBUG("Thread %s: run", ThreadName.c_str());
-    }
+  if (showRun && r) {
+    LOG_DEBUG("Thread %s: run", ThreadName.c_str());
+  }
 
-    if (showWaiting && enabled && !r) {
-        LOG_DEBUG("Thread %s: wait %lu", ThreadName.c_str(), interval);
-    }
+  if (showWaiting && enabled && !r) {
+    LOG_DEBUG("Thread %s: wait %lu", ThreadName.c_str(), interval);
+  }
 
-    if (showDisabled && !enabled) {
-        LOG_DEBUG("Thread %s: disabled", ThreadName.c_str());
-    }
+  if (showDisabled && !enabled) {
+    LOG_DEBUG("Thread %s: disabled", ThreadName.c_str());
+  }
 
-    return r;
+  return r;
 }
 
-void OSThread::run()
-{
+void OSThread::run() {
 #ifdef DEBUG_HEAP
-    auto heap = memGet.getFreeHeap();
+  auto heap = memGet.getFreeHeap();
 #endif
-    currentThread = this;
-    auto newDelay = runOnce();
+  currentThread = this;
+  auto newDelay = runOnce();
 #ifdef DEBUG_HEAP
-    auto newHeap = memGet.getFreeHeap();
-    if (newHeap < heap)
-        LOG_HEAP("------ Thread %s leaked heap %d -> %d (%d) ------", ThreadName.c_str(), heap, newHeap, newHeap - heap);
-    if (heap < newHeap)
-        LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+  auto newHeap = memGet.getFreeHeap();
+  if (newHeap < heap)
+    LOG_HEAP("------ Thread %s leaked heap %d -> %d (%d) ------", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+  if (heap < newHeap)
+    LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
 #endif
 #ifdef DEBUG_LOOP_TIMING
-    LOG_DEBUG("====== Thread next run in: %d", newDelay);
+  LOG_DEBUG("====== Thread next run in: %d", newDelay);
 #endif
-    runned();
+  runned();
 
-    if (newDelay >= 0)
-        setInterval(newDelay);
+  if (newDelay >= 0)
+    setInterval(newDelay);
 
-    currentThread = NULL;
+  currentThread = NULL;
 }
 
-int32_t OSThread::disable()
-{
-    enabled = false;
-    setInterval(INT32_MAX);
+int32_t OSThread::disable() {
+  enabled = false;
+  setInterval(INT32_MAX);
 
-    return INT32_MAX;
+  return INT32_MAX;
 }
 
 /**
@@ -122,23 +113,22 @@ int32_t OSThread::disable()
  */
 bool hasBeenSetup;
 
-void assertIsSetup()
-{
+void assertIsSetup() {
 
-    /**
-     * Dear developer comrade - If this assert fails() that means you need to fix the following:
-     *
-     * This flag is set **only** when setup() starts, to provide a way for us to check for sloppy static constructor calls.
-     * Call assertIsSetup() to force a crash if someone tries to create an instance too early.
-     *
-     * it is super important to never allocate those object statically.  instead, you should explicitly
-     *  new them at a point where you are guaranteed that other objects that this instance
-     * depends on have already been created.
-     *
-     * in particular, for OSThread that means "all instances must be declared via new() in setup() or later" -
-     * this makes it guaranteed that the global mainController is fully constructed first.
-     */
-    assert(hasBeenSetup);
+  /**
+   * Dear developer comrade - If this assert fails() that means you need to fix the following:
+   *
+   * This flag is set **only** when setup() starts, to provide a way for us to check for sloppy static constructor
+   * calls. Call assertIsSetup() to force a crash if someone tries to create an instance too early.
+   *
+   * it is super important to never allocate those object statically.  instead, you should explicitly
+   *  new them at a point where you are guaranteed that other objects that this instance
+   * depends on have already been created.
+   *
+   * in particular, for OSThread that means "all instances must be declared via new() in setup() or later" -
+   * this makes it guaranteed that the global mainController is fully constructed first.
+   */
+  assert(hasBeenSetup);
 }
 
 } // namespace concurrency

src/concurrency/OSThread.h

@@ -7,8 +7,7 @@
 #include "ThreadController.h"
 #include "concurrency/InterruptableDelay.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 extern ThreadController mainController, timerController;
 extern InterruptableDelay mainDelay;
@@ -18,7 +17,8 @@ extern InterruptableDelay mainDelay;
 /**
  * @brief Base threading
  *
- * This is a pseudo threading layer that is super easy to port, well suited to our slow network and very ram & power efficient.
+ * This is a pseudo threading layer that is super easy to port, well suited to our slow network and very ram & power
+ * efficient.
  *
  * TODO FIXME @geeksville
  *
@@ -28,49 +28,48 @@ extern InterruptableDelay mainDelay;
  * move typedQueue into concurrency
  * remove freertos from typedqueue
  */
-class OSThread : public Thread
-{
-    ThreadController *controller;
+class OSThread : public Thread {
+  ThreadController *controller;
 
-    /// Show debugging info for disabled threads
-    static bool showDisabled;
+  /// Show debugging info for disabled threads
+  static bool showDisabled;
 
-    /// Show debugging info for threads when we run them
-    static bool showRun;
+  /// Show debugging info for threads when we run them
+  static bool showRun;
 
-    /// Show debugging info for threads we decide not to run;
-    static bool showWaiting;
+  /// Show debugging info for threads we decide not to run;
+  static bool showWaiting;
 
-  public:
-    /// For debug printing only (might be null)
-    static const OSThread *currentThread;
+public:
+  /// For debug printing only (might be null)
+  static const OSThread *currentThread;
 
-    OSThread(const char *name, uint32_t period = 0, ThreadController *controller = &mainController);
+  OSThread(const char *name, uint32_t period = 0, ThreadController *controller = &mainController);
 
-    virtual ~OSThread();
+  virtual ~OSThread();
 
-    virtual bool shouldRun(unsigned long time);
+  virtual bool shouldRun(unsigned long time);
 
-    static void setup();
+  static void setup();
 
-    virtual int32_t disable();
+  virtual int32_t disable();
 
-    /**
-     * Wait a specified number msecs starting from the current time (rather than the last time we were run)
-     */
-    void setIntervalFromNow(unsigned long _interval);
+  /**
+   * Wait a specified number msecs starting from the current time (rather than the last time we were run)
+   */
+  void setIntervalFromNow(unsigned long _interval);
 
-  protected:
-    /**
-     * The method that will be called each time our thread gets a chance to run
-     *
-     * Returns desired period for next invocation (or RUN_SAME for no change)
-     */
-    virtual int32_t runOnce() = 0;
-    bool sleepOnNextExecution = false;
+protected:
+  /**
+   * The method that will be called each time our thread gets a chance to run
+   *
+   * Returns desired period for next invocation (or RUN_SAME for no change)
+   */
+  virtual int32_t runOnce() = 0;
+  bool sleepOnNextExecution = false;
 
-    // Do not override this
-    virtual void run();
+  // Do not override this
+  virtual void run();
 };
 
 /**

src/concurrency/Periodic.h

@@ -2,23 +2,21 @@
 
 #include "concurrency/OSThread.h"
 
-namespace concurrency
-{
+namespace concurrency {
 
 /**
  * @brief Periodically invoke a callback. This just provides C-style callback conventions
  *        rather than a virtual function - FIXME, remove?
  */
-class Periodic : public OSThread
-{
-    int32_t (*callback)();
+class Periodic : public OSThread {
+  int32_t (*callback)();
 
-  public:
-    // callback returns the period for the next callback invocation (or 0 if we should no longer be called)
-    Periodic(const char *name, int32_t (*_callback)()) : OSThread(name), callback(_callback) {}
+public:
+  // callback returns the period for the next callback invocation (or 0 if we should no longer be called)
+  Periodic(const char *name, int32_t (*_callback)()) : OSThread(name), callback(_callback) {}
 
-  protected:
-    int32_t runOnce() override { return callback(); }
+protected:
+  int32_t runOnce() override { return callback(); }
 };
 
 } // namespace concurrency

src/configuration.h

@@ -29,8 +29,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #if __has_include("Melopero_RV3028.h")
 #include "Melopero_RV3028.h"
 #endif
-#if __has_include("pcf8563.h")
-#include "pcf8563.h"
+#if __has_include("SensorRtcHelper.hpp")
+#include "SensorRtcHelper.hpp"
 #endif
 
 /* Offer chance for variant-specific defines */
@@ -68,8 +68,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #error APP_VERSION must be set by the build environment
 #endif
 
-// FIXME: This is still needed by the Bluetooth Stack and needs to be replaced by something better. Remnant of the old versioning
-// system.
+// FIXME: This is still needed by the Bluetooth Stack and needs to be replaced by something better. Remnant of the old
+// versioning system.
 #ifndef HW_VERSION
 #define HW_VERSION "1.0"
 #endif