[create-pull-request] automated change (#3662)

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

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

@@ -16,6 +16,19 @@ runs:
       run: |
         sudo apt-get install -y cppcheck
 
+    - name: Install libbluetooth
+      shell: bash
+      run: |
+        sudo apt-get install -y libbluetooth-dev
+    - name: Install libgpiod
+      shell: bash
+      run: |
+        sudo apt-get install -y libgpiod-dev
+    - name: Install libyaml-cpp
+      shell: bash
+      run: |
+        sudo apt-get install -y libyaml-cpp-dev
+
     - name: Setup Python
       uses: actions/setup-python@v4
       with:

.github/pull_request_template.md

@@ -7,7 +7,7 @@
   is appreciated." This will allow other devs to potentially save you time by not accidentially duplicating work etc...
 - Please do not check in files that don't have real changes
 - Please do not reformat lines that you didn't have to change the code on
-- We recommend using the [Visual Studio Code](https://platformio.org/install/ide?install=vscode) editor along with the ['Trunk Check' extension](https://marketplace.visualstudio.com/items?itemName=trunk.io) (WSL2 is required on windows),
+- We recommend using the [Visual Studio Code](https://platformio.org/install/ide?install=vscode) editor along with the ['Trunk Check' extension](https://marketplace.visualstudio.com/items?itemName=trunk.io) (In beta for windows, WSL2 for the linux version),
   because it automatically follows our indentation rules and its auto reformatting will not cause spurious changes to lines.
 - If your PR fixes a bug, mention "fixes #bugnum" somewhere in your pull request description.
 - If your other co-developers have comments on your PR please tweak as needed.

.github/workflows/build_esp32.yml

@@ -35,6 +35,7 @@ jobs:
           sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32.ini
           sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s2.ini
           sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s3.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32c3.ini
 
       - name: Build ESP32
         run: bin/build-esp32.sh ${{ inputs.board }}

.github/workflows/build_esp32_c3.yml

@@ -0,0 +1,62 @@
+name: Build ESP32-C3
+
+on:
+  workflow_call:
+    inputs:
+      board:
+        required: true
+        type: string
+
+permissions: read-all
+
+jobs:
+  build-esp32-c3:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
+
+      - name: Pull web ui
+        uses: dsaltares/fetch-gh-release-asset@a40c8b4a0471f9ab81bdf73a010f74cc51476ad4
+        with:
+          repo: meshtastic/web
+          file: build.tar
+          target: build.tar
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Unpack web ui
+        run: |
+          tar -xf build.tar -C data/static
+          rm build.tar
+      - name: Remove debug flags for release
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        run: |
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s2.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s3.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32c3.ini
+      - name: Build ESP32
+        run: bin/build-esp32.sh ${{ inputs.board }}
+
+      - name: Pull OTA Firmware
+        uses: dsaltares/fetch-gh-release-asset@a40c8b4a0471f9ab81bdf73a010f74cc51476ad4
+        with:
+          repo: meshtastic/firmware-ota
+          file: firmware-c3.bin
+          target: release/bleota-c3.bin
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get release version string
+        shell: bash
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          path: |
+            release/*.bin
+            release/*.elf

.github/workflows/build_esp32_s3.yml

@@ -34,6 +34,7 @@ jobs:
           sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32.ini
           sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s2.ini
           sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s3.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32c3.ini
       - name: Build ESP32
         run: bin/build-esp32.sh ${{ inputs.board }}
 

.github/workflows/build_raspbian.yml

@@ -0,0 +1,45 @@
+name: Build Raspbian
+
+on: workflow_call
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  build-raspbian:
+    runs-on: [self-hosted, linux, ARM64]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - name: Upgrade python tools
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio adafruit-nrfutil
+          pip install -U meshtastic --pre
+
+      - name: Upgrade platformio
+        shell: bash
+        run: |
+          pio upgrade
+
+      - name: Build Raspbian
+        run: bin/build-native.sh
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: firmware-raspbian-${{ steps.version.outputs.version }}.zip
+          path: |
+            release/meshtasticd_linux_aarch64
+            bin/config-dist.yaml

.github/workflows/main_matrix.yml

@@ -32,7 +32,7 @@ jobs:
           - board: meshtastic-diy-v1
           - board: rak4631
           - board: t-echo
-          - board: station-g1
+          - board: station-g2
           - board: m5stack-coreink
           - board: tbeam-s3-core
           - board: tlora-t3s3-v1
@@ -64,9 +64,9 @@ jobs:
           - board: tlora-v1
           - board: tlora_v1_3
           - board: tlora-v2-1-1_6
+          - board: tlora-v2-1-1_6-tcxo
           - board: tlora-v2-1-1_8
           - board: tbeam
-          - board: heltec-v1
           - board: heltec-v2_0
           - board: heltec-v2_1
           - board: tbeam0_7
@@ -78,6 +78,7 @@ jobs:
           - board: m5stack-core
           - board: m5stack-coreink
           - board: nano-g1-explorer
+          - board: chatter2
     uses: ./.github/workflows/build_esp32.yml
     with:
       board: ${{ matrix.board }}
@@ -90,26 +91,40 @@ jobs:
           - board: heltec-v3
           - board: heltec-wsl-v3
           - board: heltec-wireless-tracker
-          - board: heltec-wireless-paper
+          - board: heltec-wireless-tracker-V1-0
+          - board: heltec-wireless-paper-v1_0
+          - board: heltec-wireless-paper #v1.1
           - board: tbeam-s3-core
           - board: tlora-t3s3-v1
           - board: t-watch-s3
           - board: t-deck
           - board: picomputer-s3
+          - board: station-g2
+          - board: unphone
     uses: ./.github/workflows/build_esp32_s3.yml
     with:
       board: ${{ matrix.board }}
 
+  build-esp32-c3:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - board: heltec-ht62-esp32c3-sx1262
+    uses: ./.github/workflows/build_esp32_c3.yml
+    with:
+      board: ${{ matrix.board }}
+
   build-nrf52:
     strategy:
       fail-fast: false
-      max-parallel: 2
       matrix:
         include:
           - board: rak4631
           - board: rak4631_eink
           - board: monteops_hw1
           - board: t-echo
+          - board: canaryone
           - board: pca10059_diy_eink
           - board: feather_diy
           - board: nano-g2-ultra
@@ -120,15 +135,26 @@ jobs:
   build-rpi2040:
     strategy:
       fail-fast: false
-      max-parallel: 2
       matrix:
         include:
           - board: pico
+          - board: picow
           - board: rak11310
+          - board: senselora_rp2040
+          - board: rp2040-lora
     uses: ./.github/workflows/build_rpi2040.yml
     with:
       board: ${{ matrix.board }}
 
+  build-raspbian:
+    strategy:
+      fail-fast: false
+      max-parallel: 1
+    uses: ./.github/workflows/build_raspbian.yml
+
+  package-raspbian:
+    uses: ./.github/workflows/package_raspbian.yml
+
   build-native:
     runs-on: ubuntu-latest
     steps:
@@ -202,9 +228,21 @@ jobs:
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
   gather-artifacts:
+    permissions:
+      contents: write
+      pull-requests: write
     runs-on: ubuntu-latest
     needs:
-      [build-esp32, build-esp32-s3, build-nrf52, build-native, build-rpi2040]
+      [
+        build-esp32,
+        build-esp32-s3,
+        build-esp32-c3,
+        build-nrf52,
+        build-raspbian,
+        build-native,
+        build-rpi2040,
+        package-raspbian,
+      ]
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
@@ -216,12 +254,15 @@ jobs:
         with:
           path: ./
 
+      - name: Display structure of downloaded files
+        run: ls -R
+
       - name: Get release version string
         run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
         id: version
 
       - name: Move files up
-        run: mv -b -t ./ ./*tbeam-2*/littlefs*.bin ./*tbeam-2*/bleota.bin ./*tbeam-s3*/bleota-s3.bin ./**/firmware*.bin ./*t-echo*/Meshtastic_nRF52_factory_erase.uf2 ./**/firmware-*.uf2 ./**/firmware-*-ota.zip ./**/*.elf ./*native*/*device-*.sh ./*native*/*device-*.bat
+        run: mv -b -t ./ ./*tbeam-2*/littlefs*.bin ./*tbeam-2*/bleota.bin ./*tbeam-s3*/bleota-s3.bin ./*esp32c3*/bleota-c3.bin ./**/firmware*.bin ./*t-echo*/Meshtastic_nRF52_factory_erase_v2.uf2 ./**/firmware-*.uf2 ./**/firmware-*-ota.zip ./**/*.elf ./*native*/*device-*.sh ./*native*/*device-*.bat ./firmware-raspbian-*/release/meshtasticd_linux_aarch64 ./firmware-raspbian-*/bin/config-dist.yaml
 
       - name: Repackage in single firmware zip
         uses: actions/upload-artifact@v3
@@ -233,6 +274,8 @@ jobs:
             ./firmware-*-ota.zip
             ./device-*.sh
             ./device-*.bat
+            ./meshtasticd_linux_arm64
+            ./config-dist.yaml
           retention-days: 90
 
       - uses: actions/download-artifact@v3
@@ -262,14 +305,13 @@ jobs:
       - name: Create request artifacts
         continue-on-error: true # FIXME: Why are we getting 502, but things still work?
         if: ${{ github.event_name == 'pull_request_target' || github.event_name == 'pull_request' }}
-        uses: gavv/pull-request-artifacts@v1.1.0
+        uses: gavv/pull-request-artifacts@v2.1.0
         with:
           commit: ${{ (github.event.pull_request_target || github.event.pull_request).head.sha }}
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           artifacts-token: ${{ secrets.ARTIFACTS_TOKEN }}
           artifacts-repo: meshtastic/artifacts
           artifacts-branch: device
-          artifacts-dir: pr
           artifacts: ./firmware-${{ steps.version.outputs.version }}.zip
 
   release-artifacts:
@@ -294,6 +336,13 @@ jobs:
           name: firmware-${{ steps.version.outputs.version }}
           path: ./output
 
+      - uses: actions/download-artifact@v3
+        with:
+          name: artifact-deb
+
+      - name: Display structure of downloaded files
+        run: ls -R
+
       - name: Device scripts permissions
         run: |
           chmod +x ./output/device-install.sh
@@ -347,6 +396,16 @@ jobs:
           asset_name: debug-elfs-${{ steps.version.outputs.version }}.zip
           asset_content_type: application/zip
 
+      - name: Add raspbian .deb
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./meshtasticd_${{ steps.version.outputs.version }}_arm64.deb
+          asset_name: meshtasticd_${{ steps.version.outputs.version }}_arm64.deb
+          asset_content_type: application/vnd.debian.binary-package
+
       - name: Bump version.properties
         run: >-
           bin/bump_version.py

.github/workflows/package_raspbian.yml

@@ -0,0 +1,73 @@
+name: Package Raspbian
+
+on:
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  build-raspbian:
+    uses: ./.github/workflows/build_raspbian.yml
+
+  package-raspbian:
+    runs-on: ubuntu-latest
+    needs: build-raspbian
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - name: Pull web ui
+        uses: dsaltares/fetch-gh-release-asset@a40c8b4a0471f9ab81bdf73a010f74cc51476ad4
+        with:
+          repo: meshtastic/web
+          file: build.tar
+          target: build.tar
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: firmware-raspbian-${{ steps.version.outputs.version }}.zip
+
+      - name: Display structure of downloaded files
+        run: ls -R
+
+      - name: build .debpkg
+        run: |
+          mkdir -p .debpkg/usr/share/doc/meshtasticd/web
+          mkdir -p .debpkg/usr/sbin
+          mkdir -p .debpkg/etc/meshtasticd
+          mkdir -p .debpkg/usr/lib/systemd/system/
+          tar -xf build.tar -C .debpkg/usr/share/doc/meshtasticd/web
+          gunzip .debpkg/usr/share/doc/meshtasticd/web/*.gz
+          cp release/meshtasticd_linux_aarch64 .debpkg/usr/sbin/meshtasticd
+          cp bin/config-dist.yaml .debpkg/etc/meshtasticd/config.yaml
+          chmod +x .debpkg/usr/sbin/meshtasticd
+          cp bin/meshtasticd.service .debpkg/usr/lib/systemd/system/meshtasticd.service
+
+      - uses: jiro4989/build-deb-action@v3
+        with:
+          package: meshtasticd
+          package_root: .debpkg
+          maintainer: Jonathan Bennett
+          version: ${{ steps.version.outputs.version }} # refs/tags/v*.*.*
+          arch: arm64
+          depends: libyaml-cpp0.7, openssl, libulfius2.7
+          desc: Native Linux Meshtastic binary.
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: artifact-deb
+          path: |
+            ./*.deb

.github/workflows/trunk-check.yml

@@ -0,0 +1,22 @@
+name: Pull Request
+on: [pull_request]
+concurrency:
+  group: ${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions: read-all
+
+jobs:
+  trunk_check:
+    name: Trunk Check Runner
+    runs-on: ubuntu-latest
+    permissions:
+      checks: write # For trunk to post annotations
+      contents: read # For repo checkout
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Trunk Check
+        uses: trunk-io/trunk-action@v1

.github/workflows/update_protobufs.yml

@@ -17,9 +17,9 @@ jobs:
 
       - name: Download nanopb
         run: |
-          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.7-linux-x86.tar.gz
-          tar xvzf nanopb-0.4.7-linux-x86.tar.gz
-          mv nanopb-0.4.7-linux-x86 nanopb-0.4.7
+          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.8-linux-x86.tar.gz
+          tar xvzf nanopb-0.4.8-linux-x86.tar.gz
+          mv nanopb-0.4.8-linux-x86 nanopb-0.4.8
 
       - name: Re-generate protocol buffers
         run: |

.gitignore

@@ -31,3 +31,5 @@ venv/
 release/
 .vscode/extensions.json
 /compile_commands.json
+src/mesh/raspihttp/certificate.pem
+src/mesh/raspihttp/private_key.pem

.trunk/.gitignore

@@ -2,7 +2,8 @@
 *logs
 *actions
 *notifications
+*tools
 plugins
 user_trunk.yaml
 user.yaml
-tools
+tmp

.trunk/configs/.shellcheckrc

@@ -1,7 +1,10 @@
 enable=all
 source-path=SCRIPTDIR
 disable=SC2154
+disable=SC2248
+disable=SC2250
 
 # If you're having issues with shellcheck following source, disable the errors via:
 # disable=SC1090
 # disable=SC1091
+# 

.trunk/configs/.yamllint.yaml

@@ -3,7 +3,7 @@ rules:
     required: only-when-needed
     extra-allowed: ["{|}"]
   empty-values:
-    forbid-in-block-mappings: true
+    forbid-in-block-mappings: false
     forbid-in-flow-mappings: true
   key-duplicates: {}
   octal-values:

.trunk/trunk.yaml

@@ -1,53 +1,45 @@
 version: 0.1
 cli:
-  version: 1.13.0
+  version: 1.20.1
 plugins:
   sources:
     - id: trunk
-      ref: v1.1.1
+      ref: v1.4.4
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - bandit@1.7.5
-    - checkov@2.4.1
-    - terrascan@1.18.3
-    - trivy@0.44.1
-    - trufflehog@3.48.0
+    - trufflehog@3.68.5
+    - yamllint@1.35.1
+    - bandit@1.7.7
+    - checkov@3.2.32
+    - terrascan@1.19.1
+    - trivy@0.49.1
+    #- trufflehog@3.63.2-rc0
     - taplo@0.8.1
-    - ruff@0.0.284
-    - yamllint@1.32.0
-    - isort@5.12.0
-    - markdownlint@0.35.0
-    - oxipng@8.0.0
-    - svgo@3.0.2
-    - actionlint@1.6.25
-    - flake8@6.1.0
+    - ruff@0.3.1
+    - isort@5.13.2
+    - markdownlint@0.39.0
+    - oxipng@9.0.0
+    - svgo@3.2.0
+    - actionlint@1.6.27
+    - flake8@7.0.0
     - hadolint@2.12.0
     - shfmt@3.6.0
     - shellcheck@0.9.0
-    - black@23.7.0
+    - black@24.2.0
     - git-diff-check
-    - gitleaks@8.17.0
+    - gitleaks@8.18.2
     - clang-format@16.0.3
-    - prettier@3.0.2
-  disabled:
-    - taplo@0.8.1
-    - shellcheck@0.9.0
-    - shfmt@3.6.0
-    - oxipng@8.0.0
-    - actionlint@1.6.22
-    - markdownlint@0.35.0
-    - hadolint@2.12.0
-    - svgo@3.0.2
+    - prettier@3.2.5
 runtimes:
   enabled:
     - python@3.10.8
-    - go@1.19.5
+    - go@1.21.0
     - node@18.12.1
 actions:
   disabled:
     - trunk-announce
-    - trunk-check-pre-push
-    - trunk-fmt-pre-commit
   enabled:
+    - trunk-fmt-pre-commit
+    - trunk-check-pre-push
     - trunk-upgrade-available

.vscode/settings.json

@@ -1,5 +1,7 @@
 {
   "editor.formatOnSave": true,
   "editor.defaultFormatter": "trunk.io",
-  "trunk.enableWindows": true
+  "trunk.enableWindows": true,
+  "files.insertFinalNewline": false,
+  "files.trimFinalNewlines": false
 }

Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:bullseye-slim AS builder
+FROM debian:bookworm-slim AS builder
 
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC
@@ -11,31 +11,45 @@ SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
 # Install build deps
 USER root
-RUN apt-get update && \
-	apt-get -y install wget python3 g++ zip python3-venv git vim ca-certificates
 
-# create a non-priveleged user & group
+# trunk-ignore(terrascan/AC_DOCKER_0002): Known terrascan issue
+# trunk-ignore(hadolint/DL3008): Use latest version of packages for buildchain
+RUN apt-get update && apt-get install --no-install-recommends -y wget python3 python3-pip python3-wheel python3-venv g++ zip git \
+                           ca-certificates libgpiod-dev libyaml-cpp-dev libbluetooth-dev \
+                           libulfius-dev liborcania-dev libssl-dev pkg-config && \
+    apt-get clean && rm -rf /var/lib/apt/lists/* && mkdir /tmp/firmware
+
+RUN groupadd -g 1000 mesh && useradd -ml -u 1000 -g 1000 mesh && chown mesh:mesh /tmp/firmware
+USER mesh
+
+WORKDIR /tmp/firmware
+RUN python3 -m venv /tmp/firmware 
+RUN source ./bin/activate && pip3 install --no-cache-dir -U platformio==6.1.14
+# trunk-ignore(terrascan/AC_DOCKER_00024): We would actually like these files to be owned by mesh tyvm
+COPY --chown=mesh:mesh . /tmp/firmware
+RUN source ./bin/activate && chmod +x /tmp/firmware/bin/build-native.sh && ./bin/build-native.sh
+RUN cp "/tmp/firmware/release/meshtasticd_linux_$(uname -m)" "/tmp/firmware/release/meshtasticd"
+
+
+##### PRODUCTION BUILD #############
+
+FROM debian:bookworm-slim
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=Etc/UTC
+
+# trunk-ignore(terrascan/AC_DOCKER_0002): Known terrascan issue
+# trunk-ignore(hadolint/DL3008): Use latest version of packages for buildchain
+RUN apt-get update && apt-get --no-install-recommends -y install libc-bin libc6 libgpiod2 libyaml-cpp0.7 libulfius2.7 liborcania2.3 libssl3 && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
 RUN groupadd -g 1000 mesh && useradd -ml -u 1000 -g 1000 mesh
-
 USER mesh
-RUN wget https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py -qO /tmp/get-platformio.py && \
-	chmod +x /tmp/get-platformio.py && \
-	python3 /tmp/get-platformio.py && \
-	git clone https://github.com/meshtastic/firmware --recurse-submodules /tmp/firmware && \
-	cd /tmp/firmware && \
-	chmod +x /tmp/firmware/bin/build-native.sh && \
-	source ~/.platformio/penv/bin/activate && \
-	./bin/build-native.sh
 
-FROM frolvlad/alpine-glibc
-
-RUN apk --update add --no-cache g++ shadow && \
-	groupadd -g 1000 mesh && useradd -ml -u 1000 -g 1000 mesh
-
-COPY --from=builder /tmp/firmware/release/meshtasticd_linux_amd64 /home/mesh/
-
-USER mesh
 WORKDIR /home/mesh
-CMD sh -cx "./meshtasticd_linux_amd64 --hwid '$RANDOM'"
+COPY --from=builder /tmp/firmware/release/meshtasticd /home/mesh/
+
+VOLUME /home/mesh/data
+
+CMD [ "sh",  "-cx", "./meshtasticd -d /home/mesh/data --hwid=${HWID:-$RANDOM}" ]
 
 HEALTHCHECK NONE

README.md

@@ -10,8 +10,8 @@
 
 This repository contains the device firmware for the Meshtastic project.
 
-**[Building Instructions](https://meshtastic.org/docs/development/firmware/build)**
-**[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)**
+- **[Building Instructions](https://meshtastic.org/docs/development/firmware/build)**
+- **[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)**
 
 ## Stats
 

arch/esp32/esp32.ini

@@ -1,10 +1,10 @@
 ; Common settings for ESP targes, mixin with extends = esp32_base
 [esp32_base]
 extends = arduino_base
-platform = platformio/espressif32@^6.3.2
+platform = platformio/espressif32@6.3.2 # This is a temporary fix to the S3-based devices bluetooth issues until we can determine what within ESP-IDF changed and can develop a suitable patch. 
 
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/> -<mesh/raspihttp>
 
 upload_speed = 921600
 debug_init_break = tbreak setup
@@ -31,6 +31,9 @@ build_flags =
   -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=5120
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
   -DSERIAL_BUFFER_SIZE=4096
+  -DLIBPAX_ARDUINO
+  -DLIBPAX_WIFI
+  -DLIBPAX_BLE
   ;-DDEBUG_HEAP
 
 lib_deps =
@@ -38,8 +41,8 @@ lib_deps =
   ${networking_base.lib_deps}
   ${environmental_base.lib_deps}
   https://github.com/meshtastic/esp32_https_server.git#23665b3adc080a311dcbb586ed5941b5f94d6ea2
-  h2zero/NimBLE-Arduino@^1.4.0
-  jgromes/RadioLib@^6.1.0
+  h2zero/NimBLE-Arduino@^1.4.1
+  https://github.com/dbSuS/libpax.git#7bcd3fcab75037505be9b122ab2b24cc5176b587
   https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
   https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f
 

arch/esp32/esp32s2.ini

@@ -2,7 +2,7 @@
 extends = esp32_base
 
 build_src_filter = 
-  ${esp32_base.build_src_filter} -<nimble/>
+  ${esp32_base.build_src_filter} -<nimble/> -<mesh/raspihttp>
 
 monitor_speed = 115200
 
@@ -12,5 +12,4 @@ build_flags =
   
 lib_ignore = 
   ${esp32_base.lib_ignore} 
-  NimBLE-Arduino
-
+  NimBLE-Arduino

arch/nrf52/nrf52.ini

@@ -1,6 +1,6 @@
 [nrf52_base]
 ; Instead of the standard nordicnrf52 platform, we use our fork which has our added variant files
-platform = platformio/nordicnrf52@^10.1.0
+platform = platformio/nordicnrf52@^10.4.0
 extends = arduino_base
 
 build_type = debug ; I'm debugging with ICE a lot now
@@ -11,11 +11,10 @@ build_flags =
   -Isrc/platform/nrf52
 
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<platform/stm32wl> -<nimble/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<platform/rp2040> -<mesh/eth/>
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<platform/stm32wl> -<nimble/> -<mesh/wifi/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<platform/rp2040> -<mesh/eth/> -<mesh/raspihttp>
 
 lib_deps=
   ${arduino_base.lib_deps}
-  jgromes/RadioLib@^6.1.0
 
 lib_ignore =
   BluetoothOTA

arch/portduino/portduino.ini

@@ -1,6 +1,6 @@
 ; The Portduino based sim environment on top of any host OS, all hardware will be simulated
 [portduino_base]
-platform = https://github.com/meshtastic/platform-native.git#489ff929dca0bb768256ba2de45f95815111490f
+platform = https://github.com/meshtastic/platform-native.git#6fb39b6f94ece9c042141edb4afb91aca94dcaab
 framework = arduino
 
 build_src_filter = 
@@ -10,7 +10,9 @@ build_src_filter =
   -<platform/nrf52/> 
   -<platform/stm32wl/> 
   -<platform/rp2040>
+  -<mesh/wifi/>
   -<mesh/http/>
+  +<mesh/raspihttp/>
   -<mesh/eth/>
   -<modules/esp32>
   -<modules/Telemetry/EnvironmentTelemetry.cpp>
@@ -22,9 +24,14 @@ lib_deps =
   ${env.lib_deps}
   ${networking_base.lib_deps}
   rweather/Crypto@^0.4.0
-  jgromes/RadioLib@6.1.0
+  lovyan03/LovyanGFX@^1.1.12
 
 build_flags =
   ${arduino_base.build_flags}
   -fPIC
-  -Isrc/platform/portduino
+  -Isrc/platform/portduino
+  -DRADIOLIB_EEPROM_UNSUPPORTED
+  -DPORTDUINO_LINUX_HARDWARE
+  -lbluetooth
+  -lgpiod
+  -lyaml-cpp

arch/rp2040/rp2040.ini

@@ -1,8 +1,8 @@
 ; Common settings for rp2040 Processor based targets
 [rp2040_base]
-platform = https://github.com/maxgerhardt/platform-raspberrypi.git#0c33219f53faa035e188925ea1324f472e8b93d2
+platform = https://github.com/maxgerhardt/platform-raspberrypi.git#60d6ae81fcc73c34b1493ca9e261695e471bc0c2
 extends = arduino_base
-platform_packages = framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git#3.2.2
+platform_packages = framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git#3.7.2
 
 board_build.core = earlephilhower
 board_build.filesystem_size = 0.5m
@@ -12,7 +12,7 @@ build_flags =
   -D__PLAT_RP2040__
 #  -D _POSIX_THREADS
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<platform/nrf52/> -<platform/stm32wl> -<mesh/eth/>
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<modules/esp32> -<platform/nrf52/> -<platform/stm32wl> -<mesh/eth/> -<mesh/wifi/> -<mesh/http/> -<mesh/raspihttp>
 
 lib_ignore =
   BluetoothOTA
@@ -20,5 +20,4 @@ lib_ignore =
 lib_deps =
   ${arduino_base.lib_deps}
   ${environmental_base.lib_deps}
-  jgromes/RadioLib@^6.1.0
-  https://github.com/kokke/tiny-AES-c.git#f06ac37fc31dfdaca2e0d9bec83f90d5663c319b
+  rweather/Crypto

arch/stm32/stm32wl5e.ini

@@ -13,17 +13,16 @@ build_flags =
   -DVECT_TAB_OFFSET=0x08000000
   
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/Telemetry> -<platform/nrf52> -<platform/portduino> -<platform/rp2040>
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/Telemetry> -<platform/nrf52> -<platform/portduino> -<platform/rp2040> -<mesh/raspihttp>
 
 board_upload.offset_address = 0x08000000
 upload_protocol = stlink
 
 lib_deps =
   ${env.lib_deps}
-  jgromes/RadioLib@^6.1.0
   https://github.com/kokke/tiny-AES-c.git#f06ac37fc31dfdaca2e0d9bec83f90d5663c319b
   https://github.com/littlefs-project/littlefs.git#v2.5.1
   https://github.com/stm32duino/STM32FreeRTOS.git#10.3.1
 
 lib_ignore =
-  https://github.com/mathertel/OneButton#2.1.0
+  mathertel/OneButton

bin/build-native.sh

@@ -2,8 +2,8 @@
 
 set -e
 
-VERSION=`bin/buildinfo.py long`
-SHORT_VERSION=`bin/buildinfo.py short`
+VERSION=$(bin/buildinfo.py long)
+SHORT_VERSION=$(bin/buildinfo.py short)
 
 OUTDIR=release/
 
@@ -13,11 +13,8 @@ mkdir -p $OUTDIR/
 rm -r $OUTDIR/* || true
 
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio pkg update 
-
+platformio pkg update --environment native
 pio run --environment native
-cp .pio/build/native/program $OUTDIR/meshtasticd_linux_amd64
-
+cp .pio/build/native/program "$OUTDIR/meshtasticd_linux_$(uname -m)"
 cp bin/device-install.* $OUTDIR
 cp bin/device-update.* $OUTDIR
-

bin/check-all.sh

@@ -13,7 +13,7 @@ if [[ $# -gt 0 ]]; then
 	# can override which environment by passing arg
 	BOARDS="$@"
 else
-	BOARDS="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v1 heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo pca10059_diy_eink"
+	BOARDS="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo canaryone pca10059_diy_eink"
 fi
 
 echo "BOARDS:${BOARDS}"

bin/check-dependencies.sh

@@ -5,17 +5,17 @@
 set -e
 
 if [[ $# -gt 0 ]]; then
-    # can override which environment by passing arg
-    BOARDS="$@"
+	# can override which environment by passing arg
+	BOARDS="$@"
 else
-    BOARDS="rak4631 rak4631_eink t-echo pca10059_diy_eink pico rak11200 tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v1 heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 nano-g1 station-g1 m5stack-core m5stack-coreink tbeam-s3-core"
+	BOARDS="rak4631 rak4631_eink t-echo canaryone pca10059_diy_eink pico rak11200 tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 nano-g1 station-g1 m5stack-core m5stack-coreink tbeam-s3-core"
 fi
 
 echo "BOARDS:${BOARDS}"
 
 CHECK=""
 for BOARD in $BOARDS; do
-     CHECK="${CHECK} -e ${BOARD}"
+	CHECK="${CHECK} -e ${BOARD}"
 done
 
 echo $CHECK

bin/config-dist.yaml

@@ -0,0 +1,129 @@
+### Define your devices here using Broadcom pin numbering
+### Uncomment the block that corresponds to your hardware
+### Including the "Module:" line!
+---
+Lora:
+#  Module: sx1262  # Waveshare SX126X XXXM
+#  DIO2_AS_RF_SWITCH: true
+#  CS: 21
+#  IRQ: 16
+#  Busy: 20
+#  Reset: 18
+
+#  Module: sx1262  # Waveshare SX1302 LISTEN ONLY AT THIS TIME!
+#  CS: 7
+#  IRQ: 17
+#  Reset: 22
+
+#  Module: sx1262  # pinedio
+#  CS: 0
+#  IRQ: 10
+#  Busy: 11
+#  spidev: spidev0.1
+
+#  Module: RF95  # Adafruit RFM9x
+#  Reset: 25
+#  CS: 7
+#  IRQ: 22
+#  Busy: 23
+
+#  Module: RF95  # Elecrow Lora RFM95 IOT https://www.elecrow.com/lora-rfm95-iot-board-for-rpi.html
+#  Reset: 22
+#  CS: 7
+#  IRQ: 25
+
+#  Module: sx1280  # SX1280
+#  CS: 21
+#  IRQ: 16
+#  Busy: 20
+#  Reset: 18
+
+#  DIO3_TCXO_VOLTAGE: true  # the Waveshare Core1262 and others are known to need this setting
+
+#  TXen: x  # TX and RX enable pins
+#  RXen: x
+
+### Set gpio chip to use in /dev/. Defaults to 0.
+### Notably the Raspberry Pi 5 puts the GPIO header on gpiochip4
+#  gpiochip: 4
+
+### Specify the SPI device to use in /dev/. Defaults to spidev0.0
+### Some devices, like the pinedio, may require spidev0.1 as a workaround.
+#  spidev: spidev0.0
+
+### Define GPIO buttons here:
+
+GPIO:
+#  User: 6
+
+### Define GPS
+
+GPS:
+#  SerialPath: /dev/ttyS0
+
+### Specify I2C device, or leave blank for none
+
+I2C:
+#  I2CDevice: /dev/i2c-1
+
+### Set up SPI displays here. Note that I2C displays are generally auto-detected.
+
+Display:
+
+### Waveshare 2.8inch RPi LCD
+#  Panel: ST7789
+#  CS: 8
+#  DC: 22        # Data/Command pin
+#  Backlight: 18
+#  Width: 240
+#  Height: 320
+#  Reset: 27
+#  Rotate: true
+#  Invert: true
+
+### Waveshare 1.44inch LCD HAT
+#  Panel: ST7735S
+#  CS: 8         #Chip Select
+#  DC: 25        # Data/Command pin
+#  Backlight: 24
+#  Width: 128
+#  Height: 128
+#  Reset: 27
+#  OffsetX: 0
+#  OffsetY: 0
+
+### Adafruit PiTFT 2.8 TFT+Touchscreen
+#  Panel: ILI9341
+#  CS: 8
+#  DC: 25
+#  Backlight: 2
+#  Width: 320
+#  Height: 240
+
+Touchscreen:
+### Note, at least for now, the touchscreen must have a CS pin defined, even if you let Linux manage the CS switching.
+
+#  Module: STMPE610
+#  CS: 7
+#  IRQ: 24
+
+#  Module: XPT2046 # Waveshare 2.8inch
+#  CS: 7
+#  IRQ: 17
+
+### Configure device for direct keyboard input
+
+Input:
+#  KeyboardDevice: /dev/input/by-id/usb-_Raspberry_Pi_Internal_Keyboard-event-kbd
+
+###
+
+Logging:
+  LogLevel: info # debug, info, warn, error
+
+Webserver:
+#  Port: 443 # Port for Webserver & Webservices
+#  RootPath: /usr/share/doc/meshtasticd/web # Root Dir of WebServer
+
+General:
+  MaxNodes: 200

bin/device-install.bat

@@ -31,9 +31,13 @@ IF EXIST %FILENAME% IF x%FILENAME:update=%==x%FILENAME% (
 	%PYTHON% -m esptool --baud 115200 erase_flash
 	%PYTHON% -m esptool --baud 115200 write_flash 0x00 %FILENAME%
     
-    @REM Account for S3 board's different OTA partition
-    IF x%FILENAME:s3=%==x%FILENAME% IF x%FILENAME:v3=%==x%FILENAME% IF x%FILENAME:t-deck=%==x%FILENAME% IF x%FILENAME:wireless-paper=%==x%FILENAME% IF x%FILENAME:wireless-tracker=%==x%FILENAME% (
-        %PYTHON% -m esptool --baud 115200 write_flash 0x260000 bleota.bin
+    @REM Account for S3 and C3 board's different OTA partition
+    IF x%FILENAME:s3=%==x%FILENAME% IF x%FILENAME:v3=%==x%FILENAME% IF x%FILENAME:t-deck=%==x%FILENAME% IF x%FILENAME:wireless-paper=%==x%FILENAME% IF x%FILENAME:wireless-tracker=%==x%FILENAME% IF x%FILENAME:station-g2=%==x%FILENAME% IF x%FILENAME:unphone=%==x%FILENAME% (
+        IF x%FILENAME:esp32c3=%==x%FILENAME% (
+            %PYTHON% -m esptool --baud 115200 write_flash 0x260000 bleota.bin
+        ) else (
+            %PYTHON% -m esptool --baud 115200 write_flash 0x260000 bleota-c3.bin
+        )
 	) else (
         %PYTHON% -m esptool --baud 115200 write_flash 0x260000 bleota-s3.bin
     )

bin/device-install.sh

@@ -1,12 +1,12 @@
 #!/bin/sh
 
-PYTHON=${PYTHON:-$(which python3 python|head -n 1)}
+PYTHON=${PYTHON:-$(which python3 python | head -n 1)}
 
 set -e
 
 # Usage info
 show_help() {
-cat << EOF
+	cat <<EOF
 Usage: $(basename $0) [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME|FILENAME]
 Flash image file to device, but first erasing and writing system information"
 
@@ -18,44 +18,50 @@ Flash image file to device, but first erasing and writing system information"
 EOF
 }
 
-
 while getopts ":hp:P:f:" opt; do
-    case "${opt}" in
-        h)
-            show_help
-            exit 0
-            ;;
-        p)  export ESPTOOL_PORT=${OPTARG}
-	    ;;
-        P)  PYTHON=${OPTARG}
-            ;;
-        f)  FILENAME=${OPTARG}
-            ;;
-        *)
- 	    echo "Invalid flag."
-            show_help >&2
-            exit 1
-            ;;
-    esac
+	case "${opt}" in
+	h)
+		show_help
+		exit 0
+		;;
+	p)
+		export ESPTOOL_PORT=${OPTARG}
+		;;
+	P)
+		PYTHON=${OPTARG}
+		;;
+	f)
+		FILENAME=${OPTARG}
+		;;
+	*)
+		echo "Invalid flag."
+		show_help >&2
+		exit 1
+		;;
+	esac
 done
-shift "$((OPTIND-1))"
+shift "$((OPTIND - 1))"
 
 [ -z "$FILENAME" -a -n "$1" ] && {
-    FILENAME=$1
-    shift
+	FILENAME=$1
+	shift
 }
 
-if [ -f "${FILENAME}" ] && [ ! -z "${FILENAME##*"update"*}" ]; then
+if [ -f "${FILENAME}" ] && [ -n "${FILENAME##*"update"*}" ]; then
 	echo "Trying to flash ${FILENAME}, but first erasing and writing system information"
-	"$PYTHON" -m esptool  erase_flash
-	"$PYTHON" -m esptool  write_flash 0x00 ${FILENAME}
+	"$PYTHON" -m esptool erase_flash
+	"$PYTHON" -m esptool write_flash 0x00 ${FILENAME}
 	# Account for S3 board's different OTA partition
-	if [ ! -z "${FILENAME##*"s3"*}" ] && [ ! -z "${FILENAME##*"-v3"*}" ] && [ ! -z "${FILENAME##*"t-deck"*}" ] && [ ! -z "${FILENAME##*"wireless-paper"*}" ] && [ ! -z "${FILENAME##*"wireless-tracker"*}" ]; then
-		"$PYTHON" -m esptool  write_flash 0x260000 bleota.bin
+	if [ -n "${FILENAME##*"s3"*}" ] && [ -n "${FILENAME##*"-v3"*}" ] && [ -n "${FILENAME##*"t-deck"*}" ] && [ -n "${FILENAME##*"wireless-paper"*}" ] && [ -n "${FILENAME##*"wireless-tracker"*}" ] && [ -n "${FILENAME##*"station-g2"*}" ] && [ -n "${FILENAME##*"unphone"*}" ]; then
+		if [ -n "${FILENAME##*"esp32c3"*}" ]; then
+			"$PYTHON" -m esptool write_flash 0x260000 bleota.bin
+		else
+			"$PYTHON" -m esptool write_flash 0x260000 bleota-c3.bin
+		fi
 	else
-	    "$PYTHON" -m esptool  write_flash 0x260000 bleota-s3.bin
+		"$PYTHON" -m esptool write_flash 0x260000 bleota-s3.bin
 	fi
-	"$PYTHON" -m esptool  write_flash 0x300000 littlefs-*.bin
+	"$PYTHON" -m esptool write_flash 0x300000 littlefs-*.bin
 
 else
 	show_help

bin/exception_decoder.py

@@ -11,19 +11,22 @@ Meshtastic notes:
 * version that's checked into meshtastic repo is based on: https://github.com/me21/EspArduinoExceptionDecoder
   which adds in ESP32 Backtrace decoding.
 * this also updates the defaults to use ESP32, instead of ESP8266 and defaults to the built firmware.bin
+* also updated the toolchain name, which will be set according to the platform
 
 To use, copy the "Backtrace: 0x...." line to a file, e.g., backtrace.txt, then run:
 $ bin/exception_decoder.py backtrace.txt
+For a platform other than ESP32, use the -p option, e.g.:
+$ bin/exception_decoder.py -p ESP32S3 backtrace.txt
+To specify a specific .elf file, use the -e option, e.g.:
+$ bin/exception_decoder.py -e firmware.elf backtrace.txt
 """
 
 import argparse
+import os
 import re
 import subprocess
-from collections import namedtuple
-
 import sys
-
-import os
+from collections import namedtuple
 
 EXCEPTIONS = [
     "Illegal instruction",
@@ -55,24 +58,39 @@ EXCEPTIONS = [
     "LoadStorePrivilege: A load or store referenced a virtual address at a ring level less than CRING",
     "reserved",
     "LoadProhibited: A load referenced a page mapped with an attribute that does not permit loads",
-    "StoreProhibited: A store referenced a page mapped with an attribute that does not permit stores"
+    "StoreProhibited: A store referenced a page mapped with an attribute that does not permit stores",
 ]
 
 PLATFORMS = {
-    "ESP8266": "lx106",
-    "ESP32": "esp32"
+    "ESP8266": "xtensa-lx106",
+    "ESP32": "xtensa-esp32",
+    "ESP32S3": "xtensa-esp32s3",
+    "ESP32C3": "riscv32-esp",
+}
+TOOLS = {
+    "ESP8266": "xtensa",
+    "ESP32": "xtensa-esp32",
+    "ESP32S3": "xtensa-esp32s3",
+    "ESP32C3": "riscv32-esp",
 }
 
-BACKTRACE_REGEX = re.compile(r"(?:\s+(0x40[0-2](?:\d|[a-f]|[A-F]){5}):0x(?:\d|[a-f]|[A-F]){8})\b")
+BACKTRACE_REGEX = re.compile(
+    r"(?:\s+(0x40[0-2](?:\d|[a-f]|[A-F]){5}):0x(?:\d|[a-f]|[A-F]){8})\b"
+)
 EXCEPTION_REGEX = re.compile("^Exception \\((?P<exc>[0-9]*)\\):$")
-COUNTER_REGEX = re.compile('^epc1=(?P<epc1>0x[0-9a-f]+) epc2=(?P<epc2>0x[0-9a-f]+) epc3=(?P<epc3>0x[0-9a-f]+) '
-                           'excvaddr=(?P<excvaddr>0x[0-9a-f]+) depc=(?P<depc>0x[0-9a-f]+)$')
+COUNTER_REGEX = re.compile(
+    "^epc1=(?P<epc1>0x[0-9a-f]+) epc2=(?P<epc2>0x[0-9a-f]+) epc3=(?P<epc3>0x[0-9a-f]+) "
+    "excvaddr=(?P<excvaddr>0x[0-9a-f]+) depc=(?P<depc>0x[0-9a-f]+)$"
+)
 CTX_REGEX = re.compile("^ctx: (?P<ctx>.+)$")
-POINTER_REGEX = re.compile('^sp: (?P<sp>[0-9a-f]+) end: (?P<end>[0-9a-f]+) offset: (?P<offset>[0-9a-f]+)$')
-STACK_BEGIN = '>>>stack>>>'
-STACK_END = '<<<stack<<<'
+POINTER_REGEX = re.compile(
+    "^sp: (?P<sp>[0-9a-f]+) end: (?P<end>[0-9a-f]+) offset: (?P<offset>[0-9a-f]+)$"
+)
+STACK_BEGIN = ">>>stack>>>"
+STACK_END = "<<<stack<<<"
 STACK_REGEX = re.compile(
-    '^(?P<off>[0-9a-f]+):\W+(?P<c1>[0-9a-f]+) (?P<c2>[0-9a-f]+) (?P<c3>[0-9a-f]+) (?P<c4>[0-9a-f]+)(\W.*)?$')
+    "^(?P<off>[0-9a-f]+):\W+(?P<c1>[0-9a-f]+) (?P<c2>[0-9a-f]+) (?P<c3>[0-9a-f]+) (?P<c4>[0-9a-f]+)(\W.*)?$"
+)
 
 StackLine = namedtuple("StackLine", ["offset", "content"])
 
@@ -96,15 +114,18 @@ class ExceptionDataParser(object):
         self.stack = []
 
     def _parse_backtrace(self, line):
-        if line.startswith('Backtrace:'):
-            self.stack = [StackLine(offset=0, content=(addr,)) for addr in BACKTRACE_REGEX.findall(line)]
+        if line.startswith("Backtrace:"):
+            self.stack = [
+                StackLine(offset=0, content=(addr,))
+                for addr in BACKTRACE_REGEX.findall(line)
+            ]
             return None
         return self._parse_backtrace
 
     def _parse_exception(self, line):
         match = EXCEPTION_REGEX.match(line)
         if match is not None:
-            self.exception = int(match.group('exc'))
+            self.exception = int(match.group("exc"))
             return self._parse_counters
         return self._parse_exception
 
@@ -144,14 +165,22 @@ class ExceptionDataParser(object):
         if line != STACK_END:
             match = STACK_REGEX.match(line)
             if match is not None:
-                self.stack.append(StackLine(offset=match.group("off"),
-                                            content=(match.group("c1"), match.group("c2"), match.group("c3"),
-                                                     match.group("c4"))))
+                self.stack.append(
+                    StackLine(
+                        offset=match.group("off"),
+                        content=(
+                            match.group("c1"),
+                            match.group("c2"),
+                            match.group("c3"),
+                            match.group("c4"),
+                        ),
+                    )
+                )
             return self._parse_stack_line
         return None
 
     def parse_file(self, file, platform, stack_only=False):
-        if platform == 'ESP32':
+        if platform != "ESP8266":
             func = self._parse_backtrace
         else:
             func = self._parse_exception
@@ -175,7 +204,9 @@ class AddressResolver(object):
         self._address_map = {}
 
     def _lookup(self, addresses):
-        cmd = [self._tool, "-aipfC", "-e", self._elf] + [addr for addr in addresses if addr is not None]
+        cmd = [self._tool, "-aipfC", "-e", self._elf] + [
+            addr for addr in addresses if addr is not None
+        ]
 
         if sys.version_info[0] < 3:
             output = subprocess.check_output(cmd)
@@ -190,19 +221,27 @@ class AddressResolver(object):
             match = line_regex.match(line)
 
             if match is None:
-                if last is not None and line.startswith('(inlined by)'):
-                    line = line [12:].strip()
-                    self._address_map[last] += ("\n  \-> inlined by: " + line)
+                if last is not None and line.startswith("(inlined by)"):
+                    line = line[12:].strip()
+                    self._address_map[last] += "\n  \-> inlined by: " + line
                 continue
 
-            if match.group("result") == '?? ??:0':
+            if match.group("result") == "?? ??:0":
                 continue
 
             self._address_map[match.group("addr")] = match.group("result")
             last = match.group("addr")
 
     def fill(self, parser):
-        addresses = [parser.epc1, parser.epc2, parser.epc3, parser.excvaddr, parser.sp, parser.end, parser.offset]
+        addresses = [
+            parser.epc1,
+            parser.epc2,
+            parser.epc3,
+            parser.excvaddr,
+            parser.sp,
+            parser.end,
+            parser.offset,
+        ]
         for line in parser.stack:
             addresses.extend(line.content)
 
@@ -257,8 +296,10 @@ def print_stack(lines, resolver):
 
 
 def print_result(parser, resolver, platform, full=True, stack_only=False):
-    if platform == 'ESP8266' and not stack_only:
-        print('Exception: {} ({})'.format(parser.exception, EXCEPTIONS[parser.exception]))
+    if platform == "ESP8266" and not stack_only:
+        print(
+            "Exception: {} ({})".format(parser.exception, EXCEPTIONS[parser.exception])
+        )
 
         print("")
         print_addr("epc1", parser.epc1, resolver)
@@ -285,15 +326,33 @@ def print_result(parser, resolver, platform, full=True, stack_only=False):
 def parse_args():
     parser = argparse.ArgumentParser(description="decode ESP Stacktraces.")
 
-    parser.add_argument("-p", "--platform", help="The platform to decode from", choices=PLATFORMS.keys(),
-                        default="ESP32")
-    parser.add_argument("-t", "--tool", help="Path to the xtensa toolchain",
-                        default="~/.platformio/packages/toolchain-xtensa32/")
-    parser.add_argument("-e", "--elf", help="path to elf file",
-                        default=".pio/build/esp32/firmware.elf")
-    parser.add_argument("-f", "--full", help="Print full stack dump", action="store_true")
-    parser.add_argument("-s", "--stack_only", help="Decode only a stractrace", action="store_true")
-    parser.add_argument("file", help="The file to read the exception data from ('-' for STDIN)", default="-")
+    parser.add_argument(
+        "-p",
+        "--platform",
+        help="The platform to decode from",
+        choices=PLATFORMS.keys(),
+        default="ESP32",
+    )
+    parser.add_argument(
+        "-t",
+        "--tool",
+        help="Path to the toolchain (without specific platform)",
+        default="~/.platformio/packages/toolchain-",
+    )
+    parser.add_argument(
+        "-e", "--elf", help="path to elf file", default=".pio/build/tbeam/firmware.elf"
+    )
+    parser.add_argument(
+        "-f", "--full", help="Print full stack dump", action="store_true"
+    )
+    parser.add_argument(
+        "-s", "--stack_only", help="Decode only a stractrace", action="store_true"
+    )
+    parser.add_argument(
+        "file",
+        help="The file to read the exception data from ('-' for STDIN)",
+        default="-",
+    )
 
     return parser.parse_args()
 
@@ -309,10 +368,12 @@ if __name__ == "__main__":
             sys.exit(1)
         file = open(args.file, "r")
 
-    addr2line = os.path.join(os.path.abspath(os.path.expanduser(args.tool)),
-                             "bin/xtensa-" + PLATFORMS[args.platform] + "-elf-addr2line")
-    if os.name == 'nt':
-        addr2line += '.exe'
+    addr2line = os.path.join(
+        os.path.abspath(os.path.expanduser(args.tool + TOOLS[args.platform])),
+        "bin/" + PLATFORMS[args.platform] + "-elf-addr2line",
+    )
+    if os.name == "nt":
+        addr2line += ".exe"
     if not os.path.exists(addr2line):
         print("ERROR: addr2line not found (" + addr2line + ")")
 

bin/meshtasticd.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=Meshtastic Native Daemon
+After=network-online.target
+
+[Service]
+User=root
+Group=root
+Type=simple
+ExecStart=/usr/sbin/meshtasticd
+
+[Install]
+WantedBy=multi-user.target

bin/native-install.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+cp "release/meshtasticd_linux_$(uname -m)" /usr/sbin/meshtasticd
+mkdir /etc/meshtasticd
+if [[ -f "/etc/meshtasticd/config.yaml" ]]; then
+	cp bin/config-dist.yaml /etc/meshtasticd/config-upgrade.yaml
+else
+	cp bin/config-dist.yaml /etc/meshtasticd/config.yaml
+fi
+cp bin/meshtasticd.service /usr/lib/systemd/system/meshtasticd.service

bin/regen-protos.bat

@@ -1 +1 @@
-cd protobufs && ..\nanopb-0.4.7\generator-bin\protoc.exe --experimental_allow_proto3_optional --nanopb_out=-v:..\src\mesh\generated -I=..\protobufs ..\protobufs\meshtastic\*.proto
+cd protobufs && ..\nanopb-0.4.8\generator-bin\protoc.exe --experimental_allow_proto3_optional "--nanopb_out=-S.cpp -v:..\src\mesh\generated" -I=..\protobufs\ ..\protobufs\meshtastic\*.proto

bin/regen-protos.sh

@@ -2,19 +2,10 @@
 
 set -e
 
-echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.7 to be located in the"
+echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.8 to be located in the"
 echo "firmware root directory if the following step fails, you should download the correct"
-echo "prebuilt binaries for your computer into nanopb-0.4.7"
+echo "prebuilt binaries for your computer into nanopb-0.4.8"
 
 # the nanopb tool seems to require that the .options file be in the current directory!
 cd protobufs
-../nanopb-0.4.7/generator-bin/protoc --nanopb_out=-v:../src/mesh/generated/ -I=../protobufs meshtastic/*.proto --experimental_allow_proto3_optional
-
-# cd ../src/mesh/generated/meshtastic
-# sed -i 's/#include "meshtastic/#include "./g' -- *
-
-# sed -i 's/meshtastic_//g' -- *
-
-#echo "Regenerating protobuf documentation - if you see an error message"
-#echo "you can ignore it unless doing a new protobuf release to github."
-#bin/regen-docs.sh
+../nanopb-0.4.8/generator-bin/protoc --experimental_allow_proto3_optional "--nanopb_out=-S.cpp -v:../src/mesh/generated/" -I=../protobufs meshtastic/*.proto

boards/CDEBYTE_EoRa-S3.json

@@ -0,0 +1,38 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-D CDEBYTE_EORA_S3",
+      "-D ARDUINO_USB_CDC_ON_BOOT=1",
+      "-D ARDUINO_USB_MODE=0",
+      "-D ARDUINO_RUNNING_CORE=1",
+      "-D ARDUINO_EVENT_RUNNING_CORE=1",
+      "-D BOARD_HAS_PSRAM"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "dio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "CDEBYTE_EoRa-S3"
+  },
+  "connectivity": ["wifi"],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "CDEBYTE EoRa-S3",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://www.cdebyte.com/Module-Testkits-EoRaPI",
+  "vendor": "CDEBYTE"
+}

boards/canaryone.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_CANARY -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      ["0x239A", "0x4405"],
+      ["0x239A", "0x009F"]
+    ],
+    "usb_product": "CanaryOne",
+    "mcu": "nrf52840",
+    "variant": "canaryone",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino"],
+  "name": "Canary (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  },
+  "url": "https://canaryradio.io/",
+  "vendor": "Canary Radio Company"
+}

boards/eink0.1.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "TTGO eink (Adafruit BSP)",

boards/esp32-s3-pico.json

@@ -0,0 +1,40 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_16MB.csv"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DARDUINO_ESP32S3_DEV",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "Waveshare ESP32-S3-Pico (16 MB FLASH, 2 MB PSRAM)",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://www.waveshare.com/esp32-s3-pico.htm",
+  "vendor": "Waveshare"
+}

boards/lora-relay-v1.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "Meshtastic Lora Relay V1 (Adafruit BSP)",

boards/lora-relay-v2.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "Meshtastic Lora Relay V1 (Adafruit BSP)",

boards/lora_isp4520.json

@@ -22,7 +22,8 @@
   "connectivity": ["bluetooth"],
   "debug": {
     "jlink_device": "nRF52832_xxAA",
-    "svd_path": "nrf52.svd"
+    "svd_path": "nrf52.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "lora ISP4520",

boards/nordic_pca10059.json

@@ -32,7 +32,8 @@
   "connectivity": ["bluetooth"],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "nRF52840 Dongle",

boards/nrf52840_dk.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "A modified NRF52840-DK devboard (Adafruit BSP)",

boards/nrf52840_dk_modified.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "A modified NRF52840-DK devboard (Adafruit BSP)",

boards/ppr.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "Meshtastic PPR (Adafruit BSP)",

boards/ppr1.json

@@ -29,7 +29,8 @@
   "debug": {
     "jlink_device": "nRF52833_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52833.svd"
+    "svd_path": "nrf52833.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "Meshtastic PPR1 (Adafruit BSP)",

boards/station-g2.json

@@ -0,0 +1,41 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=0"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "station-g2"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "BQ Station G2",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://wiki.uniteng.com/en/meshtastic/station-g2",
+  "vendor": "BQ Consulting"
+}

boards/t-deck.json

@@ -1,7 +1,8 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "esp32s3_out.ld"
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
     },
     "core": "esp32",
     "extra_flags": [
@@ -13,7 +14,7 @@
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
-    "flash_mode": "dio",
+    "flash_mode": "qio",
     "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "t-deck"

boards/t-echo.json

@@ -9,6 +9,7 @@
     "f_cpu": "64000000L",
     "hwids": [
       ["0x239A", "0x4405"],
+      ["0x239A", "0x0029"],
       ["0x239A", "0x002A"]
     ],
     "usb_product": "TTGO_eink",
@@ -32,7 +33,8 @@
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "TTGO eink (Adafruit BSP)",

boards/t-watch-s3.json

@@ -1,7 +1,8 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "esp32s3_out.ld"
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
     },
     "core": "esp32",
     "extra_flags": [
@@ -14,8 +15,11 @@
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
-    "flash_mode": "dio",
-    "hwids": [["0x303A", "0x1001"]],
+    "flash_mode": "qio",
+    "hwids": [
+      ["0x303A", "0x1001"],
+      ["0x303A", "0x0002"]
+    ],
     "mcu": "esp32s3",
     "variant": "t-watch-s3"
   },
@@ -31,8 +35,9 @@
     "maximum_size": 8388608,
     "require_upload_port": true,
     "use_1200bps_touch": true,
-    "wait_for_upload_port": true
+    "wait_for_upload_port": true,
+    "speed": 921600
   },
-  "url": "http://www.lilygo.cn/",
+  "url": "https://www.lilygo.cc/en-pl/products/t-watch-s3",
   "vendor": "LilyGo"
 }

boards/tbeam-s3-core.json

@@ -7,15 +7,14 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DLILYGO_TBEAM_S3_CORE",
-      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
     "flash_mode": "dio",
-    "hwids": [["0X303A", "0x1001"]],
+    "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "tbeam-s3-core"
   },

boards/wiscore_rak4600.json

@@ -32,7 +32,8 @@
   "connectivity": ["bluetooth"],
   "debug": {
     "jlink_device": "nRF52832_xxAA",
-    "svd_path": "nrf52.svd"
+    "svd_path": "nrf52.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino", "zephyr"],
   "name": "Adafruit Bluefruit nRF52832 Feather",

boards/wiscore_rak4631.json

@@ -32,7 +32,8 @@
   "connectivity": ["bluetooth"],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "WisCore RAK4631 Board",

boards/xiao_ble_sense.json

@@ -31,7 +31,8 @@
   "connectivity": ["bluetooth"],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd"
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
   },
   "frameworks": ["arduino"],
   "name": "Seeed Xiao BLE Sense",

platformio.ini

@@ -2,7 +2,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-;default_envs = tbeam
+default_envs = tbeam
 ;default_envs = pico
 ;default_envs = tbeam-s3-core
 ;default_envs = tbeam0.7
@@ -10,13 +10,16 @@
 ;default_envs = heltec-v2_0
 ;default_envs = heltec-v2_1
 ;default_envs = heltec-wireless-tracker
+;default_envs = chatter2
 ;default_envs = tlora-v1
 ;default_envs = tlora_v1_3
 ;default_envs = tlora-v2
 ;default_envs = tlora-v2-1-1_6
+;default_envs = tlora-v2-1-1_6-tcxo
 ;default_envs = tlora-t3s3-v1
 ;default_envs = lora-relay-v1 # nrf board
 ;default_envs = t-echo
+;default_envs = canaryone
 ;default_envs = nrf52840dk-geeksville
 ;default_envs = native # lora-relay-v1 # nrf52840dk-geeksville # linux # or if you'd like to change the default to something like lora-relay-v1 put that here
 ;default_envs = nano-g1
@@ -26,7 +29,8 @@
 ;default_envs = meshtastic-dr-dev
 ;default_envs = m5stack-coreink
 ;default_envs = rak4631
-default_envs = wio-e5
+;default_envs = rak10701
+;default_envs = wio-e5
 
 extra_configs =
   arch/*/*.ini
@@ -50,9 +54,11 @@ build_flags = -Wno-missing-field-initializers
   -DRADIOLIB_EXCLUDE_NRF24
   -DRADIOLIB_EXCLUDE_RF69
   -DRADIOLIB_EXCLUDE_SX1231
+  -DRADIOLIB_EXCLUDE_SX1233
   -DRADIOLIB_EXCLUDE_SI443X
   -DRADIOLIB_EXCLUDE_RFM2X
   -DRADIOLIB_EXCLUDE_AFSK
+  -DRADIOLIB_EXCLUDE_BELL
   -DRADIOLIB_EXCLUDE_HELLSCHREIBER
   -DRADIOLIB_EXCLUDE_MORSE
   -DRADIOLIB_EXCLUDE_RTTY
@@ -63,15 +69,17 @@ build_flags = -Wno-missing-field-initializers
   -DRADIOLIB_EXCLUDE_PAGER
   -DRADIOLIB_EXCLUDE_FSK4
   -DRADIOLIB_EXCLUDE_APRS
+  -DRADIOLIB_EXCLUDE_LORAWAN
 
 monitor_speed = 115200
 
 lib_deps =
-  https://github.com/meshtastic/esp8266-oled-ssd1306.git#b38094e03dfa964fbc0e799bc374e91a605c1223 ; ESP8266_SSD1306
-  https://github.com/mathertel/OneButton#2.1.0 ; OneButton library for non-blocking button debounce
+  jgromes/RadioLib@~6.5.0
+  https://github.com/meshtastic/esp8266-oled-ssd1306.git#ee628ee6c9588d4c56c9e3da35f0fc9448ad54a8 ; ESP8266_SSD1306
+  mathertel/OneButton@^2.5.0 ; OneButton library for non-blocking button debounce
   https://github.com/meshtastic/arduino-fsm.git#7db3702bf0cfe97b783d6c72595e3f38e0b19159
-  https://github.com/meshtastic/TinyGPSPlus.git#127ad674ef85f0201cb68a065879653ed94792c4
-  https://github.com/meshtastic/ArduinoThread.git#72921ac222eed6f526ba1682023cee290d9aa1b3
+  https://github.com/meshtastic/TinyGPSPlus.git#964f75a72cccd6b53cd74e4add1f7a42c6f7344d
+  https://github.com/meshtastic/ArduinoThread.git#1ae8778c85d0a2a729f989e0b1e7d7c4dc84eef0
   nanopb/Nanopb@^0.4.7
   erriez/ErriezCRC32@^1.0.1
 
@@ -92,7 +100,7 @@ lib_deps =
   end2endzone/NonBlockingRTTTL@^1.3.0
   https://github.com/meshtastic/SparkFun_ATECCX08a_Arduino_Library.git#5cf62b36c6f30bc72a07bdb2c11fc9a22d1e31da
 
-build_flags = ${env.build_flags} -Os -DRADIOLIB_SPI_PARANOID=0
+build_flags = ${env.build_flags} -Os
 build_src_filter = ${env.build_src_filter} -<platform/portduino/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
@@ -106,13 +114,15 @@ lib_deps =
 ; (not included in native / portduino)
 [environmental_base]
 lib_deps =
-  adafruit/Adafruit BusIO@^1.11.4
+  adafruit/Adafruit BusIO@^1.15.0
   adafruit/Adafruit Unified Sensor@^1.1.11
   adafruit/Adafruit BMP280 Library@^2.6.8
+  adafruit/Adafruit BMP085 Library@^1.2.4
   adafruit/Adafruit BME280 Library@^2.2.2
   https://github.com/boschsensortec/Bosch-BSEC2-Library#v1.5.2400
   boschsensortec/BME68x Sensor Library@^1.1.40407
   adafruit/Adafruit MCP9808 Library@^2.0.0
+  https://github.com/KodinLanewave/INA3221@^1.0.0
   adafruit/Adafruit INA260 Library@^1.5.0
   adafruit/Adafruit INA219@^1.2.0
   adafruit/Adafruit SHTC3 Library@^1.0.0
@@ -121,4 +131,5 @@ lib_deps =
   adafruit/Adafruit PM25 AQI Sensor@^1.0.6
   adafruit/Adafruit MPU6050@^2.2.4
   adafruit/Adafruit LIS3DH@^1.2.4
-  https://github.com/lewisxhe/BMA423_Library@^0.0.1
+  https://github.com/lewisxhe/SensorLib#27fd0f721e20cd09e1f81383f0ba58a54fe84a17
+  adafruit/Adafruit LSM6DS@^4.7.2

src/AccelerometerThread.h

@@ -5,18 +5,19 @@
 #include "power.h"
 
 #include <Adafruit_LIS3DH.h>
+#include <Adafruit_LSM6DS3TRC.h>
 #include <Adafruit_MPU6050.h>
 #include <Arduino.h>
+#include <SensorBMA423.hpp>
 #include <Wire.h>
-#include <bma.h>
 
-BMA423 bmaSensor;
+SensorBMA423 bmaSensor;
 bool BMA_IRQ = false;
 
 #define ACCELEROMETER_CHECK_INTERVAL_MS 100
 #define ACCELEROMETER_CLICK_THRESHOLD 40
 
-uint16_t readRegister(uint8_t address, uint8_t reg, uint8_t *data, uint16_t len)
+int readRegister(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
 {
     Wire.beginTransmission(address);
     Wire.write(reg);
@@ -29,7 +30,7 @@ uint16_t readRegister(uint8_t address, uint8_t reg, uint8_t *data, uint16_t len)
     return 0; // Pass
 }
 
-uint16_t writeRegister(uint8_t address, uint8_t reg, uint8_t *data, uint16_t len)
+int writeRegister(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
 {
     Wire.beginTransmission(address);
     Wire.write(reg);
@@ -42,7 +43,7 @@ namespace concurrency
 class AccelerometerThread : public concurrency::OSThread
 {
   public:
-    AccelerometerThread(ScanI2C::DeviceType type = ScanI2C::DeviceType::NONE) : OSThread("AccelerometerThread")
+    explicit AccelerometerThread(ScanI2C::DeviceType type) : OSThread("AccelerometerThread")
     {
         if (accelerometer_found.port == ScanI2C::I2CPort::NO_I2C) {
             LOG_DEBUG("AccelerometerThread disabling due to no sensors found\n");
@@ -72,24 +73,14 @@ class AccelerometerThread : public concurrency::OSThread
             lis.setRange(LIS3DH_RANGE_2_G);
             // Adjust threshold, higher numbers are less sensitive
             lis.setClick(config.device.double_tap_as_button_press ? 2 : 1, ACCELEROMETER_CLICK_THRESHOLD);
-        } else if (acceleremoter_type == ScanI2C::DeviceType::BMA423 && bmaSensor.begin(readRegister, writeRegister, delay)) {
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMA423 &&
+                   bmaSensor.begin(accelerometer_found.address, &readRegister, &writeRegister)) {
             LOG_DEBUG("BMA423 initializing\n");
-            Acfg cfg;
-            cfg.odr = BMA4_OUTPUT_DATA_RATE_100HZ;
-            cfg.range = BMA4_ACCEL_RANGE_2G;
-            cfg.bandwidth = BMA4_ACCEL_NORMAL_AVG4;
-            cfg.perf_mode = BMA4_CONTINUOUS_MODE;
-            bmaSensor.setAccelConfig(cfg);
-            bmaSensor.enableAccel();
-
-            struct bma4_int_pin_config pin_config;
-            pin_config.edge_ctrl = BMA4_LEVEL_TRIGGER;
-            pin_config.lvl = BMA4_ACTIVE_HIGH;
-            pin_config.od = BMA4_PUSH_PULL;
-            pin_config.output_en = BMA4_OUTPUT_ENABLE;
-            pin_config.input_en = BMA4_INPUT_DISABLE;
-            // The correct trigger interrupt needs to be configured as needed
-            bmaSensor.setINTPinConfig(pin_config, BMA4_INTR1_MAP);
+            bmaSensor.configAccelerometer(bmaSensor.RANGE_2G, bmaSensor.ODR_100HZ, bmaSensor.BW_NORMAL_AVG4,
+                                          bmaSensor.PERF_CONTINUOUS_MODE);
+            bmaSensor.enableAccelerometer();
+            bmaSensor.configInterrupt(BMA4_LEVEL_TRIGGER, BMA4_ACTIVE_HIGH, BMA4_PUSH_PULL, BMA4_OUTPUT_ENABLE,
+                                      BMA4_INPUT_DISABLE);
 
 #ifdef BMA423_INT
             pinMode(BMA4XX_INT, INPUT);
@@ -102,25 +93,31 @@ class AccelerometerThread : public concurrency::OSThread
                 RISING); // Select the interrupt mode according to the actual circuit
 #endif
 
-            struct bma423_axes_remap remap_data;
-            remap_data.x_axis = 0;
-            remap_data.x_axis_sign = 1;
-            remap_data.y_axis = 1;
-            remap_data.y_axis_sign = 0;
-            remap_data.z_axis = 2;
-            remap_data.z_axis_sign = 1;
+#ifdef T_WATCH_S3
             // Need to raise the wrist function, need to set the correct axis
-            bmaSensor.setRemapAxes(&remap_data);
-            // sensor.enableFeature(BMA423_STEP_CNTR, true);
-            bmaSensor.enableFeature(BMA423_TILT, true);
-            bmaSensor.enableFeature(BMA423_WAKEUP, true);
-            // sensor.resetStepCounter();
+            bmaSensor.setReampAxes(bmaSensor.REMAP_TOP_LAYER_RIGHT_CORNER);
+#else
+            bmaSensor.setReampAxes(bmaSensor.REMAP_BOTTOM_LAYER_BOTTOM_LEFT_CORNER);
+#endif
+            // bmaSensor.enableFeature(bmaSensor.FEATURE_STEP_CNTR, true);
+            bmaSensor.enableFeature(bmaSensor.FEATURE_TILT, true);
+            bmaSensor.enableFeature(bmaSensor.FEATURE_WAKEUP, true);
+            // bmaSensor.resetPedometer();
 
             // Turn on feature interrupt
-            bmaSensor.enableStepCountInterrupt();
-            bmaSensor.enableTiltInterrupt();
+            bmaSensor.enablePedometerIRQ();
+            bmaSensor.enableTiltIRQ();
             // It corresponds to isDoubleClick interrupt
-            bmaSensor.enableWakeupInterrupt();
+            bmaSensor.enableWakeupIRQ();
+        } else if (acceleremoter_type == ScanI2C::DeviceType::LSM6DS3 && lsm.begin_I2C(accelerometer_found.address)) {
+            LOG_DEBUG("LSM6DS3 initializing\n");
+            // Default threshold of 2G, less sensitive options are 4, 8 or 16G
+            lsm.setAccelRange(LSM6DS_ACCEL_RANGE_2_G);
+#ifndef LSM6DS3_WAKE_THRESH
+#define LSM6DS3_WAKE_THRESH 20
+#endif
+            lsm.enableWakeup(config.display.wake_on_tap_or_motion, 1, LSM6DS3_WAKE_THRESH);
+            // Duration is number of occurances needed to trigger, higher threshold is less sensitive
         }
     }
 
@@ -141,11 +138,14 @@ class AccelerometerThread : public concurrency::OSThread
                 buttonPress();
                 return 500;
             }
-        } else if (acceleremoter_type == ScanI2C::DeviceType::BMA423 && bmaSensor.getINT()) {
-            if (bmaSensor.isTilt() || bmaSensor.isDoubleClick()) {
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMA423 && bmaSensor.readIrqStatus() != DEV_WIRE_NONE) {
+            if (bmaSensor.isTilt() || bmaSensor.isDoubleTap()) {
                 wakeScreen();
                 return 500;
             }
+        } else if (acceleremoter_type == ScanI2C::DeviceType::LSM6DS3 && lsm.shake()) {
+            wakeScreen();
+            return 500;
         }
 
         return ACCELEROMETER_CHECK_INTERVAL_MS;
@@ -169,6 +169,7 @@ class AccelerometerThread : public concurrency::OSThread
     ScanI2C::DeviceType acceleremoter_type;
     Adafruit_MPU6050 mpu;
     Adafruit_LIS3DH lis;
+    Adafruit_LSM6DS3TRC lsm;
 };
 
 } // namespace concurrency

src/AmbientLightingThread.h

@@ -0,0 +1,75 @@
+#include "configuration.h"
+
+#ifdef HAS_NCP5623
+#include <graphics/RAKled.h>
+NCP5623 rgb;
+#endif
+
+namespace concurrency
+{
+class AmbientLightingThread : public concurrency::OSThread
+{
+  public:
+    explicit AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLightingThread")
+    {
+        // 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;
+
+#ifdef HAS_NCP5623
+        _type = type;
+        if (_type == ScanI2C::DeviceType::NONE) {
+            LOG_DEBUG("AmbientLightingThread disabling due to no RGB leds found on I2C bus\n");
+            disable();
+            return;
+        }
+        if (!moduleConfig.ambient_lighting.led_state) {
+            LOG_DEBUG("AmbientLightingThread disabling due to moduleConfig.ambient_lighting.led_state OFF\n");
+            disable();
+            return;
+        }
+        LOG_DEBUG("AmbientLightingThread initializing\n");
+        if (_type == ScanI2C::NCP5623) {
+            rgb.begin();
+            setLighting();
+        }
+#endif
+    }
+
+  protected:
+    int32_t runOnce() override
+    {
+#ifdef HAS_NCP5623
+        if (_type == ScanI2C::NCP5623 && moduleConfig.ambient_lighting.led_state) {
+            setLighting();
+            return 30000; // 30 seconds to reset from any animations that may have been running from Ext. Notification
+        } else {
+            return disable();
+        }
+#else
+        return disable();
+#endif
+    }
+
+  private:
+    ScanI2C::DeviceType _type = ScanI2C::DeviceType::NONE;
+
+    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("Initializing Ambient lighting w/ current=%d, red=%d, green=%d, blue=%d\n",
+                  moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                  moduleConfig.ambient_lighting.blue);
+#endif
+    }
+};
+
+} // namespace concurrency

src/AudioThread.h

@@ -0,0 +1,77 @@
+#pragma once
+#include "PowerFSM.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include "main.h"
+#include "sleep.h"
+
+#ifdef HAS_I2S
+#include <AudioFileSourcePROGMEM.h>
+#include <AudioGeneratorRTTTL.h>
+#include <AudioOutputI2S.h>
+#include <ESP8266SAM.h>
+
+#define AUDIO_THREAD_INTERVAL_MS 100
+
+class AudioThread : public concurrency::OSThread
+{
+  public:
+    AudioThread() : OSThread("AudioThread") { initOutput(); }
+
+    void beginRttl(const void *data, uint32_t len)
+    {
+        setCPUFast(true);
+        rtttlFile = new AudioFileSourcePROGMEM(data, len);
+        i2sRtttl = new AudioGeneratorRTTTL();
+        i2sRtttl->begin(rtttlFile, audioOut);
+    }
+
+    bool isPlaying()
+    {
+        if (i2sRtttl != nullptr) {
+            return i2sRtttl->isRunning() && i2sRtttl->loop();
+        }
+        return false;
+    }
+
+    void stop()
+    {
+        if (i2sRtttl != nullptr) {
+            i2sRtttl->stop();
+            delete i2sRtttl;
+            i2sRtttl = nullptr;
+        }
+        if (rtttlFile != nullptr) {
+            delete rtttlFile;
+            rtttlFile = nullptr;
+        }
+
+        setCPUFast(false);
+    }
+
+  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;
+    }
+
+  private:
+    void initOutput()
+    {
+        audioOut = new AudioOutputI2S(1, AudioOutputI2S::EXTERNAL_I2S);
+        audioOut->SetPinout(DAC_I2S_BCK, DAC_I2S_WS, DAC_I2S_DOUT);
+        audioOut->SetGain(0.2);
+    };
+
+    AudioGeneratorRTTTL *i2sRtttl = nullptr;
+    AudioOutputI2S *audioOut;
+
+    AudioFileSourcePROGMEM *rtttlFile;
+};
+
+#endif

src/ButtonThread.cpp

@@ -0,0 +1,317 @@
+#include "ButtonThread.h"
+#include "configuration.h"
+#if !MESHTASTIC_EXCLUDE_GPS
+#include "GPS.h"
+#endif
+#include "MeshService.h"
+#include "PowerFSM.h"
+#include "RadioLibInterface.h"
+#include "buzz.h"
+#include "main.h"
+#include "modules/ExternalNotificationModule.h"
+#include "power.h"
+#ifdef ARCH_PORTDUINO
+#include "platform/portduino/PortduinoGlue.h"
+#endif
+
+#define DEBUG_BUTTONS 0
+#if DEBUG_BUTTONS
+#define LOG_BUTTON(...) LOG_DEBUG(__VA_ARGS__)
+#else
+#define LOG_BUTTON(...)
+#endif
+
+using namespace concurrency;
+
+ButtonThread *buttonThread; // Declared extern in header
+volatile ButtonThread::ButtonEventType ButtonThread::btnEvent = ButtonThread::BUTTON_EVENT_NONE;
+
+#if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
+OneButton ButtonThread::userButton; // Get reference to static member
+#endif
+
+ButtonThread::ButtonThread() : OSThread("Button")
+{
+#if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
+
+#if defined(ARCH_PORTDUINO)
+    if (settingsMap.count(user) != 0 && settingsMap[user] != RADIOLIB_NC) {
+        this->userButton = OneButton(settingsMap[user], true, true);
+        LOG_DEBUG("Using GPIO%02d for button\n", settingsMap[user]);
+    }
+#elif defined(BUTTON_PIN)
+    int pin = config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN; // Resolved button pin
+    this->userButton = OneButton(pin, true, true);
+    LOG_DEBUG("Using GPIO%02d for button\n", pin);
+#endif
+
+#ifdef INPUT_PULLUP_SENSE
+    // Some platforms (nrf52) have a SENSE variant which allows wake from sleep - override what OneButton did
+    pinMode(pin, INPUT_PULLUP_SENSE);
+#endif
+
+#if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
+    userButton.attachClick(userButtonPressed);
+    userButton.setClickMs(250);
+    userButton.setPressMs(c_longPressTime);
+    userButton.setDebounceMs(1);
+    userButton.attachDoubleClick(userButtonDoublePressed);
+    userButton.attachMultiClick(userButtonMultiPressed, this); // Reference to instance: get click count from non-static OneButton
+#ifndef T_DECK // T-Deck immediately wakes up after shutdown, so disable this function
+    userButton.attachLongPressStart(userButtonPressedLongStart);
+    userButton.attachLongPressStop(userButtonPressedLongStop);
+#endif
+#endif
+
+#ifdef BUTTON_PIN_ALT
+    userButtonAlt = OneButton(BUTTON_PIN_ALT, true, true);
+#ifdef INPUT_PULLUP_SENSE
+    // Some platforms (nrf52) have a SENSE variant which allows wake from sleep - override what OneButton did
+    pinMode(BUTTON_PIN_ALT, INPUT_PULLUP_SENSE);
+#endif
+    userButtonAlt.attachClick(userButtonPressed);
+    userButtonAlt.setClickMs(250);
+    userButtonAlt.setPressMs(c_longPressTime);
+    userButtonAlt.setDebounceMs(1);
+    userButtonAlt.attachDoubleClick(userButtonDoublePressed);
+    userButtonAlt.attachLongPressStart(userButtonPressedLongStart);
+    userButtonAlt.attachLongPressStop(userButtonPressedLongStop);
+#endif
+
+#ifdef BUTTON_PIN_TOUCH
+    userButtonTouch = OneButton(BUTTON_PIN_TOUCH, true, true);
+    userButtonTouch.setPressMs(400);
+    userButtonTouch.attachLongPressStart(touchPressedLongStart); // Better handling with longpress than click?
+#endif
+
+    attachButtonInterrupts();
+#endif
+}
+
+int32_t ButtonThread::runOnce()
+{
+    // If the button is pressed we suppress CPU sleep until release
+    canSleep = true; // Assume we should not keep the board awake
+
+#if defined(BUTTON_PIN)
+    userButton.tick();
+    canSleep &= userButton.isIdle();
+#elif defined(ARCH_PORTDUINO)
+    if (settingsMap.count(user) != 0 && settingsMap[user] != RADIOLIB_NC) {
+        userButton.tick();
+        canSleep &= userButton.isIdle();
+    }
+#endif
+#ifdef BUTTON_PIN_ALT
+    userButtonAlt.tick();
+    canSleep &= userButtonAlt.isIdle();
+#endif
+#ifdef BUTTON_PIN_TOUCH
+    userButtonTouch.tick();
+    canSleep &= userButtonTouch.isIdle();
+#endif
+
+    if (btnEvent != BUTTON_EVENT_NONE) {
+        switch (btnEvent) {
+        case BUTTON_EVENT_PRESSED: {
+            LOG_BUTTON("press!\n");
+#ifdef BUTTON_PIN
+            if (((config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN) !=
+                 moduleConfig.canned_message.inputbroker_pin_press) ||
+                !(moduleConfig.canned_message.updown1_enabled || moduleConfig.canned_message.rotary1_enabled) ||
+                !moduleConfig.canned_message.enabled) {
+                powerFSM.trigger(EVENT_PRESS);
+            }
+#endif
+#if defined(ARCH_PORTDUINO)
+            if ((settingsMap.count(user) != 0 && settingsMap[user] != RADIOLIB_NC) &&
+                    (settingsMap[user] != moduleConfig.canned_message.inputbroker_pin_press) ||
+                !moduleConfig.canned_message.enabled) {
+                powerFSM.trigger(EVENT_PRESS);
+            }
+#endif
+            break;
+        }
+
+        case BUTTON_EVENT_DOUBLE_PRESSED: {
+            LOG_BUTTON("Double press!\n");
+            service.refreshLocalMeshNode();
+            service.sendNetworkPing(NODENUM_BROADCAST, true);
+            if (screen) {
+                screen->print("Sent ad-hoc ping\n");
+                screen->forceDisplay(true); // Force a new UI frame, then force an EInk update
+            }
+            break;
+        }
+
+        case BUTTON_EVENT_MULTI_PRESSED: {
+            LOG_BUTTON("Mulitipress! %hux\n", multipressClickCount);
+            switch (multipressClickCount) {
+#if HAS_GPS
+            // 3 clicks: toggle GPS
+            case 3:
+                if (!config.device.disable_triple_click && (gps != nullptr)) {
+                    gps->toggleGpsMode();
+                    if (screen)
+                        screen->forceDisplay(true); // Force a new UI frame, then force an EInk update
+                }
+                break;
+#endif
+#if defined(USE_EINK) && defined(PIN_EINK_EN) // i.e. T-Echo
+            // 4 clicks: toggle backlight
+            case 4:
+                digitalWrite(PIN_EINK_EN, digitalRead(PIN_EINK_EN) == LOW);
+                break;
+#endif
+            // No valid multipress action
+            default:
+                break;
+            } // end switch: click count
+
+            break;
+        } // end multipress event
+
+        case BUTTON_EVENT_LONG_PRESSED: {
+            LOG_BUTTON("Long press!\n");
+            powerFSM.trigger(EVENT_PRESS);
+            if (screen)
+                screen->startShutdownScreen();
+            playBeep();
+            break;
+        }
+
+        // Do actual shutdown when button released, otherwise the button release
+        // may wake the board immediatedly.
+        case BUTTON_EVENT_LONG_RELEASED: {
+            LOG_INFO("Shutdown from long press\n");
+            playShutdownMelody();
+            delay(3000);
+            power->shutdown();
+            break;
+        }
+
+#ifdef BUTTON_PIN_TOUCH
+        case BUTTON_EVENT_TOUCH_LONG_PRESSED: {
+            LOG_BUTTON("Touch press!\n");
+            if (config.display.wake_on_tap_or_motion) {
+                if (screen) {
+                    // Wake if asleep
+                    if (powerFSM.getState() == &stateDARK)
+                        powerFSM.trigger(EVENT_PRESS);
+
+                    // Update display (legacy behaviour)
+                    screen->forceDisplay();
+                }
+            }
+            break;
+        }
+#endif // BUTTON_PIN_TOUCH
+
+        default:
+            break;
+        }
+        btnEvent = BUTTON_EVENT_NONE;
+    }
+
+    return 50;
+}
+
+/*
+ * Attach (or re-attach) hardware interrupts for buttons
+ * Public method. Used outside class when waking from MCU sleep
+ */
+void ButtonThread::attachButtonInterrupts()
+{
+#if defined(ARCH_PORTDUINO)
+    if (settingsMap.count(user) != 0 && settingsMap[user] != RADIOLIB_NC)
+        wakeOnIrq(settingsMap[user], FALLING);
+#elif defined(BUTTON_PIN)
+    // Interrupt for user button, during normal use. Improves responsiveness.
+    attachInterrupt(
+        config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN,
+        []() {
+            BaseType_t higherWake = 0;
+            mainDelay.interruptFromISR(&higherWake);
+            ButtonThread::userButton.tick();
+        },
+        CHANGE);
+#endif
+
+#ifdef BUTTON_PIN_ALT
+    wakeOnIrq(BUTTON_PIN_ALT, FALLING);
+#endif
+
+#ifdef BUTTON_PIN_TOUCH
+    wakeOnIrq(BUTTON_PIN_TOUCH, FALLING);
+#endif
+}
+
+/*
+ * Detach the "normal" button interrupts.
+ * Public method. Used before attaching a "wake-on-button" interrupt for MCU sleep
+ */
+void ButtonThread::detachButtonInterrupts()
+{
+#if defined(ARCH_PORTDUINO)
+    if (settingsMap.count(user) != 0 && settingsMap[user] != RADIOLIB_NC)
+        detachInterrupt(settingsMap[user]);
+#elif defined(BUTTON_PIN)
+    detachInterrupt(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN);
+#endif
+
+#ifdef BUTTON_PIN_ALT
+    detachInterrupt(BUTTON_PIN_ALT);
+#endif
+
+#ifdef BUTTON_PIN_TOUCH
+    detachInterrupt(BUTTON_PIN_TOUCH);
+#endif
+}
+
+/**
+ * Watch a GPIO and if we get an IRQ, wake the main thread.
+ * Use to add wake on button press
+ */
+void ButtonThread::wakeOnIrq(int irq, int mode)
+{
+    attachInterrupt(
+        irq,
+        [] {
+            BaseType_t higherWake = 0;
+            mainDelay.interruptFromISR(&higherWake);
+        },
+        FALLING);
+}
+
+// Static callback
+void ButtonThread::userButtonMultiPressed(void *callerThread)
+{
+    // Grab click count from non-static button, while the info is still valid
+    ButtonThread *thread = (ButtonThread *)callerThread;
+    thread->storeClickCount();
+
+    // Then handle later, in the usual way
+    btnEvent = BUTTON_EVENT_MULTI_PRESSED;
+}
+
+// Non-static method, runs during callback. Grabs info while still valid
+void ButtonThread::storeClickCount()
+{
+#ifdef BUTTON_PIN
+    multipressClickCount = userButton.getNumberClicks();
+#endif
+}
+
+void ButtonThread::userButtonPressedLongStart()
+{
+    if (millis() > c_holdOffTime) {
+        btnEvent = BUTTON_EVENT_LONG_PRESSED;
+    }
+}
+
+void ButtonThread::userButtonPressedLongStop()
+{
+    if (millis() > c_holdOffTime) {
+        btnEvent = BUTTON_EVENT_LONG_RELEASED;
+    }
+}

src/ButtonThread.h

@@ -1,35 +1,34 @@
-#include "PowerFSM.h"
-#include "RadioLibInterface.h"
-#include "buzz.h"
+#pragma once
+
+#include "OneButton.h"
 #include "concurrency/OSThread.h"
 #include "configuration.h"
-#include "graphics/Screen.h"
-#include "main.h"
-#include "power.h"
-#include <OneButton.h>
-
-namespace concurrency
-{
-/**
- * Watch a GPIO and if we get an IRQ, wake the main thread.
- * Use to add wake on button press
- */
-void wakeOnIrq(int irq, int mode)
-{
-    attachInterrupt(
-        irq,
-        [] {
-            BaseType_t higherWake = 0;
-            mainDelay.interruptFromISR(&higherWake);
-        },
-        FALLING);
-}
 
 class ButtonThread : public concurrency::OSThread
 {
-// Prepare for button presses
-#ifdef BUTTON_PIN
-    OneButton userButton;
+  public:
+    static const uint32_t c_longPressTime = 5000; // shutdown after 5s
+    static const uint32_t c_holdOffTime = 30000;  // hold off 30s after boot
+
+    enum ButtonEventType {
+        BUTTON_EVENT_NONE,
+        BUTTON_EVENT_PRESSED,
+        BUTTON_EVENT_DOUBLE_PRESSED,
+        BUTTON_EVENT_MULTI_PRESSED,
+        BUTTON_EVENT_LONG_PRESSED,
+        BUTTON_EVENT_LONG_RELEASED,
+        BUTTON_EVENT_TOUCH_LONG_PRESSED,
+    };
+
+    ButtonThread();
+    int32_t runOnce() override;
+    void attachButtonInterrupts();
+    void detachButtonInterrupts();
+    void storeClickCount();
+
+  private:
+#if defined(BUTTON_PIN) || defined(ARCH_PORTDUINO)
+    static OneButton userButton; // Static - accessed from an interrupt
 #endif
 #ifdef BUTTON_PIN_ALT
     OneButton userButtonAlt;
@@ -37,164 +36,22 @@ class ButtonThread : public concurrency::OSThread
 #ifdef BUTTON_PIN_TOUCH
     OneButton userButtonTouch;
 #endif
-    static bool shutdown_on_long_stop;
 
-  public:
-    static uint32_t longPressTime;
+    // set during IRQ
+    static volatile ButtonEventType btnEvent;
 
-    // callback returns the period for the next callback invocation (or 0 if we should no longer be called)
-    ButtonThread() : OSThread("Button")
-    {
-#ifdef BUTTON_PIN
-        userButton = OneButton(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, true, true);
-#ifdef INPUT_PULLUP_SENSE
-        // Some platforms (nrf52) have a SENSE variant which allows wake from sleep - override what OneButton did
-        pinMode(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, INPUT_PULLUP_SENSE);
-#endif
-        userButton.attachClick(userButtonPressed);
-        userButton.setClickMs(300);
-        userButton.attachDuringLongPress(userButtonPressedLong);
-        userButton.attachDoubleClick(userButtonDoublePressed);
-        userButton.attachMultiClick(userButtonMultiPressed);
-        userButton.attachLongPressStart(userButtonPressedLongStart);
-        userButton.attachLongPressStop(userButtonPressedLongStop);
-        wakeOnIrq(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, FALLING);
-#endif
-#ifdef BUTTON_PIN_ALT
-        userButtonAlt = OneButton(BUTTON_PIN_ALT, true, true);
-#ifdef INPUT_PULLUP_SENSE
-        // Some platforms (nrf52) have a SENSE variant which allows wake from sleep - override what OneButton did
-        pinMode(BUTTON_PIN_ALT, INPUT_PULLUP_SENSE);
-#endif
-        userButtonAlt.attachClick(userButtonPressed);
-        userButtonAlt.attachDuringLongPress(userButtonPressedLong);
-        userButtonAlt.attachDoubleClick(userButtonDoublePressed);
-        userButtonAlt.attachLongPressStart(userButtonPressedLongStart);
-        userButtonAlt.attachLongPressStop(userButtonPressedLongStop);
-        wakeOnIrq(BUTTON_PIN_ALT, FALLING);
-#endif
+    // Store click count during callback, for later use
+    volatile int multipressClickCount = 0;
 
-#ifdef BUTTON_PIN_TOUCH
-        userButtonTouch = OneButton(BUTTON_PIN_TOUCH, true, true);
-        userButtonTouch.attachClick(touchPressed);
-        wakeOnIrq(BUTTON_PIN_TOUCH, FALLING);
-#endif
-    }
+    static void wakeOnIrq(int irq, int mode);
 
-  protected:
-    /// If the button is pressed we suppress CPU sleep until release
-    int32_t runOnce() override
-    {
-        canSleep = true; // Assume we should not keep the board awake
-
-#ifdef BUTTON_PIN
-        userButton.tick();
-        canSleep &= userButton.isIdle();
-#endif
-#ifdef BUTTON_PIN_ALT
-        userButtonAlt.tick();
-        canSleep &= userButtonAlt.isIdle();
-#endif
-#ifdef BUTTON_PIN_TOUCH
-        userButtonTouch.tick();
-        canSleep &= userButtonTouch.isIdle();
-#endif
-        // if (!canSleep) LOG_DEBUG("Suppressing sleep!\n");
-        // else LOG_DEBUG("sleep ok\n");
-
-        return 50;
-    }
-
-  private:
-    static void touchPressed()
-    {
-        screen->forceDisplay();
-        LOG_DEBUG("touch press!\n");
-    }
-
-    static void userButtonPressed()
-    {
-        // LOG_DEBUG("press!\n");
-#ifdef BUTTON_PIN
-        if (((config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN) !=
-             moduleConfig.canned_message.inputbroker_pin_press) ||
-            !moduleConfig.canned_message.enabled) {
-            powerFSM.trigger(EVENT_PRESS);
-        }
-#endif
-    }
-    static void userButtonPressedLong()
-    {
-        // LOG_DEBUG("Long press!\n");
-        // If user button is held down for 5 seconds, shutdown the device.
-        if ((millis() - longPressTime > 5000) && (longPressTime > 0)) {
-#if defined(ARCH_NRF52) || defined(ARCH_ESP32)
-            // Do actual shutdown when button released, otherwise the button release
-            // may wake the board immediatedly.
-            if ((!shutdown_on_long_stop) && (millis() > 30 * 1000)) {
-                screen->startShutdownScreen();
-                LOG_INFO("Shutdown from long press");
-                playBeep();
-#ifdef PIN_LED1
-                ledOff(PIN_LED1);
-#endif
-#ifdef PIN_LED2
-                ledOff(PIN_LED2);
-#endif
-#ifdef PIN_LED3
-                ledOff(PIN_LED3);
-#endif
-                shutdown_on_long_stop = true;
-            }
-#endif
-        } else {
-            // LOG_DEBUG("Long press %u\n", (millis() - longPressTime));
-        }
-    }
-
-    static void userButtonDoublePressed()
-    {
-#if defined(USE_EINK) && defined(PIN_EINK_EN)
-        digitalWrite(PIN_EINK_EN, digitalRead(PIN_EINK_EN) == LOW);
-#endif
-        screen->print("Sent ad-hoc ping\n");
-        service.refreshLocalMeshNode();
-        service.sendNetworkPing(NODENUM_BROADCAST, true);
-    }
-
-    static void userButtonMultiPressed()
-    {
-#if defined(GPS_POWER_TOGGLE)
-        if (config.position.gps_enabled) {
-            LOG_DEBUG("Flag set to false for gps power\n");
-        } else {
-            LOG_DEBUG("Flag set to true to restore power\n");
-        }
-        config.position.gps_enabled = !(config.position.gps_enabled);
-        doGPSpowersave(config.position.gps_enabled);
-#endif
-    }
-
-    static void userButtonPressedLongStart()
-    {
-        if (millis() > 30 * 1000) {
-            LOG_DEBUG("Long press start!\n");
-            longPressTime = millis();
-        }
-    }
-
-    static void userButtonPressedLongStop()
-    {
-        if (millis() > 30 * 1000) {
-            LOG_DEBUG("Long press stop!\n");
-            longPressTime = 0;
-            if (shutdown_on_long_stop) {
-                playShutdownMelody();
-                delay(3000);
-                power->shutdown();
-            }
-        }
-    }
+    // IRQ callbacks
+    static void userButtonPressed() { btnEvent = BUTTON_EVENT_PRESSED; }
+    static void userButtonDoublePressed() { btnEvent = BUTTON_EVENT_DOUBLE_PRESSED; }
+    static void userButtonMultiPressed(void *callerThread); // Retrieve click count from non-static Onebutton while still valid
+    static void userButtonPressedLongStart();
+    static void userButtonPressedLongStop();
+    static void touchPressedLongStart() { btnEvent = BUTTON_EVENT_TOUCH_LONG_PRESSED; }
 };
 
-} // namespace concurrency
+extern ButtonThread *buttonThread;

src/DebugConfiguration.h

@@ -28,7 +28,7 @@
 #define DEBUG_PORT (*console) // Serial debug port
 
 #ifdef USE_SEGGER
-#define DEBUG_PORT
+// #undef DEBUG_PORT
 #define LOG_DEBUG(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #define LOG_INFO(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #define LOG_WARN(...) SEGGER_RTT_printf(0, __VA_ARGS__)

src/DisplayFormatters.cpp

@@ -0,0 +1,34 @@
+#include "DisplayFormatters.h"
+
+const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName)
+{
+    switch (preset) {
+    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;
+    case meshtastic_Config_LoRaConfig_ModemPreset_VERY_LONG_SLOW:
+        return useShortName ? "VeryL" : "VLongSlow";
+        break;
+    default:
+        return useShortName ? "Custom" : "Invalid";
+        break;
+    }
+}

src/DisplayFormatters.h

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

src/GPSStatus.h

@@ -4,8 +4,6 @@
 #include "configuration.h"
 #include <Arduino.h>
 
-extern NodeDB nodeDB;
-
 namespace meshtastic
 {
 
@@ -55,7 +53,7 @@ class GPSStatus : public Status
 #ifdef GPS_EXTRAVERBOSE
             LOG_WARN("Using fixed latitude\n");
 #endif
-            meshtastic_NodeInfoLite *node = nodeDB.getMeshNode(nodeDB.getNodeNum());
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
             return node->position.latitude_i;
         } else {
             return p.latitude_i;
@@ -68,7 +66,7 @@ class GPSStatus : public Status
 #ifdef GPS_EXTRAVERBOSE
             LOG_WARN("Using fixed longitude\n");
 #endif
-            meshtastic_NodeInfoLite *node = nodeDB.getMeshNode(nodeDB.getNodeNum());
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
             return node->position.longitude_i;
         } else {
             return p.longitude_i;
@@ -81,27 +79,18 @@ class GPSStatus : public Status
 #ifdef GPS_EXTRAVERBOSE
             LOG_WARN("Using fixed altitude\n");
 #endif
-            meshtastic_NodeInfoLite *node = nodeDB.getMeshNode(nodeDB.getNodeNum());
+            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; }
 
     bool matches(const GPSStatus *newStatus) const
     {
@@ -149,4 +138,4 @@ class GPSStatus : public Status
 
 } // namespace meshtastic
 
-extern meshtastic::GPSStatus *gpsStatus;
+extern meshtastic::GPSStatus *gpsStatus;

src/Observer.h

@@ -10,12 +10,12 @@ template <class T> class Observable;
  */
 template <class T> class Observer
 {
-    std::list<Observable<T> *> observed;
+    std::list<Observable<T> *> observables;
 
   public:
     virtual ~Observer();
 
-    /// Stop watching the obserable
+    /// Stop watching the observable
     void unobserve(Observable<T> *o);
 
     /// Start watching a specified observable
@@ -86,21 +86,21 @@ template <class T> class Observable
 
 template <class T> Observer<T>::~Observer()
 {
-    for (typename std::list<Observable<T> *>::const_iterator iterator = observed.begin(); iterator != observed.end();
+    for (typename std::list<Observable<T> *>::const_iterator iterator = observables.begin(); iterator != observables.end();
          ++iterator) {
         (*iterator)->removeObserver(this);
     }
-    observed.clear();
+    observables.clear();
 }
 
 template <class T> void Observer<T>::unobserve(Observable<T> *o)
 {
     o->removeObserver(this);
-    observed.remove(o);
+    observables.remove(o);
 }
 
 template <class T> void Observer<T>::observe(Observable<T> *o)
 {
-    observed.push_back(o);
+    observables.push_back(o);
     o->addObserver(this);
-}
+}

src/Power.cpp

@@ -19,11 +19,18 @@
 #include "meshUtils.h"
 #include "sleep.h"
 
-#ifdef DEBUG_HEAP_MQTT
+// Working USB detection for powered/charging states on the RAK platform
+#ifdef NRF_APM
+#include "nrfx_power.h"
+#endif
+
+#if defined(DEBUG_HEAP_MQTT) && !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #include "target_specific.h"
+#if !MESTASTIC_EXCLUDE_WIFI
 #include <WiFi.h>
 #endif
+#endif
 
 #ifndef DELAY_FOREVER
 #define DELAY_FOREVER portMAX_DELAY
@@ -49,9 +56,23 @@ static const adc_atten_t atten = ADC_ATTENUATION;
 #endif
 #endif // BATTERY_PIN && ARCH_ESP32
 
+#ifdef EXT_CHRG_DETECT
+#ifndef EXT_CHRG_DETECT_MODE
+static const uint8_t ext_chrg_detect_mode = INPUT;
+#else
+static const uint8_t ext_chrg_detect_mode = EXT_CHRG_DETECT_MODE;
+#endif
+#ifndef EXT_CHRG_DETECT_VALUE
+static const uint8_t ext_chrg_detect_value = HIGH;
+#else
+static const uint8_t ext_chrg_detect_value = EXT_CHRG_DETECT_VALUE;
+#endif
+#endif
+
 #if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
 INA260Sensor ina260Sensor;
 INA219Sensor ina219Sensor;
+INA3221Sensor ina3221Sensor;
 #endif
 
 #ifdef HAS_PMU
@@ -121,8 +142,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
 {
     /**
      * Battery state of charge, from 0 to 100 or -1 for unknown
-     *
-     * FIXME - use a lipo lookup table, the current % full is super wrong
      */
     virtual int getBatteryPercent() override
     {
@@ -131,13 +150,32 @@ class AnalogBatteryLevel : public HasBatteryLevel
         if (v < noBatVolt)
             return -1; // If voltage is super low assume no battery installed
 
-#ifdef ARCH_ESP32
+#ifdef NO_BATTERY_LEVEL_ON_CHARGE
         // This does not work on a RAK4631 with battery connected
         if (v > chargingVolt)
             return 0; // While charging we can't report % full on the battery
 #endif
-
-        return clamp((int)(100 * (v - emptyVolt) / (fullVolt - emptyVolt)), 0, 100);
+        /**
+         * @brief   Battery voltage lookup table interpolation to obtain a more
+         * precise percentage rather than the old proportional one.
+         * @author  Gabriele Russo
+         * @date    06/02/2024
+         */
+        float battery_SOC = 0.0;
+        uint16_t voltage = v / NUM_CELLS; // single cell voltage (average)
+        for (int i = 0; i < NUM_OCV_POINTS; i++) {
+            if (OCV[i] <= voltage) {
+                if (i == 0) {
+                    battery_SOC = 100.0; // 100% full
+                } else {
+                    // interpolate between OCV[i] and OCV[i-1]
+                    battery_SOC = (float)100.0 / (NUM_OCV_POINTS - 1.0) *
+                                  (NUM_OCV_POINTS - 1.0 - i + ((float)voltage - OCV[i]) / (OCV[i - 1] - OCV[i]));
+                }
+                break;
+            }
+        }
+        return clamp((int)(battery_SOC), 0, 100);
     }
 
     /**
@@ -158,7 +196,8 @@ class AnalogBatteryLevel : public HasBatteryLevel
 #endif
 
 #ifndef BATTERY_SENSE_SAMPLES
-#define BATTERY_SENSE_SAMPLES 30
+#define BATTERY_SENSE_SAMPLES                                                                                                    \
+    15 // Set the number of samples, it has an effect of increasing sensitivity in complex electromagnetic environment.
 #endif
 
 #ifdef BATTERY_PIN
@@ -170,54 +209,110 @@ class AnalogBatteryLevel : public HasBatteryLevel
         if (millis() - last_read_time_ms > min_read_interval) {
             last_read_time_ms = millis();
 
-            // Set the number of samples, it has an effect of increasing sensitivity, especially in complex electromagnetic
-            // environment.
             uint32_t raw = 0;
-#ifdef ARCH_ESP32
-#ifndef BAT_MEASURE_ADC_UNIT // ADC1
-            for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-                raw += adc1_get_raw(adc_channel);
-            }
-#else  // ADC2
-            int32_t adc_buf = 0;
-            for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-                // ADC2 wifi bug workaround, see
-                // https://github.com/espressif/arduino-esp32/issues/102
-                WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, RTC_reg_b);
-                SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
-                adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
-                raw += adc_buf;
-            }
-#endif // BAT_MEASURE_ADC_UNIT
-#else  // !ARCH_ESP32
+            float scaled = 0;
+
+#ifdef ARCH_ESP32 // ADC block for espressif platforms
+            raw = espAdcRead();
+            scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
+            scaled *= operativeAdcMultiplier;
+#else // block for all other platforms
             for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
                 raw += analogRead(BATTERY_PIN);
             }
-#endif
             raw = raw / BATTERY_SENSE_SAMPLES;
-            float scaled;
-#ifdef ARCH_ESP32
-            scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
-            scaled *= operativeAdcMultiplier;
-#else
-#ifndef VBAT_RAW_TO_SCALED
-            scaled = 1000.0 * operativeAdcMultiplier * (AREF_VOLTAGE / 1024.0) * raw;
-#else
-            scaled = VBAT_RAW_TO_SCALED(raw); // defined in variant.h
-#endif // VBAT RAW TO SCALED
-#endif // ARCH_ESP32
-       // LOG_DEBUG("battery gpio %d raw val=%u scaled=%u\n", BATTERY_PIN, raw, (uint32_t)(scaled));
-
-            last_read_value = scaled;
-            return scaled;
-        } else {
-            return last_read_value;
+            scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
+#endif
+            last_read_value += (scaled - last_read_value) * 0.5; // Virtual LPF
+            // LOG_DEBUG("battery gpio %d raw val=%u scaled=%u filtered=%u\n", BATTERY_PIN, raw, (uint32_t)(scaled), (uint32_t)
+            // (last_read_value));
         }
-#else
-        return 0;
+        return last_read_value;
 #endif // BATTERY_PIN
+        return 0;
     }
 
+#if defined(ARCH_ESP32) && !defined(HAS_PMU) && defined(BATTERY_PIN)
+    /**
+     * ESP32 specific function for getting calibrated ADC reads
+     */
+    uint32_t espAdcRead()
+    {
+
+        uint32_t raw = 0;
+        uint8_t raw_c = 0; // raw reading counter
+
+#ifndef BAT_MEASURE_ADC_UNIT // ADC1
+#ifdef ADC_CTRL              // enable adc voltage divider when we need to read
+        pinMode(ADC_CTRL, OUTPUT);
+        digitalWrite(ADC_CTRL, ADC_CTRL_ENABLED);
+        delay(10);
+#endif
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            int val_ = adc1_get_raw(adc_channel);
+            if (val_ >= 0) { // save only valid readings
+                raw += val_;
+                raw_c++;
+            }
+            // delayMicroseconds(100);
+        }
+#ifdef ADC_CTRL // disable adc voltage divider when we need to read
+        digitalWrite(ADC_CTRL, !ADC_CTRL_ENABLED);
+#endif
+#else // ADC2
+#ifdef ADC_CTRL
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0)
+        pinMode(ADC_CTRL, OUTPUT);
+        digitalWrite(ADC_CTRL, LOW); // ACTIVE LOW
+        delay(10);
+#endif
+#endif // End ADC_CTRL
+
+#ifdef CONFIG_IDF_TARGET_ESP32S3 // ESP32S3
+        // ADC2 wifi bug workaround not required, breaks compile
+        // On ESP32S3, ADC2 can take turns with Wifi (?)
+
+        int32_t adc_buf;
+        esp_err_t read_result;
+
+        // Multiple samples
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            adc_buf = 0;
+            read_result = -1;
+
+            read_result = adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
+            if (read_result == ESP_OK) {
+                raw += adc_buf;
+                raw_c++; // Count valid samples
+            } else {
+                LOG_DEBUG("An attempt to sample ADC2 failed\n");
+            }
+        }
+
+#else  // Other ESP32
+        int32_t adc_buf = 0;
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            // ADC2 wifi bug workaround, see
+            // https://github.com/espressif/arduino-esp32/issues/102
+            WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, RTC_reg_b);
+            SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
+            adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
+            raw += adc_buf;
+            raw_c++;
+        }
+#endif // BAT_MEASURE_ADC_UNIT
+
+#ifdef ADC_CTRL
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0)
+        digitalWrite(ADC_CTRL, HIGH);
+#endif
+#endif // End ADC_CTRL
+
+#endif // End BAT_MEASURE_ADC_UNIT
+        return (raw / (raw_c < 1 ? 1 : raw_c));
+    }
+#endif
+
     /**
      * return true if there is a battery installed in this unit
      */
@@ -242,37 +337,40 @@ class AnalogBatteryLevel : public HasBatteryLevel
 
     /// Assume charging if we have a battery and external power is connected.
     /// we can't be smart enough to say 'full'?
-    virtual bool isCharging() override { return isBatteryConnect() && isVbusIn(); }
+    virtual bool isCharging() override
+    {
+#ifdef EXT_CHRG_DETECT
+        return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
+#else
+        return isBatteryConnect() && isVbusIn();
+#endif
+    }
 
   private:
     /// If we see a battery voltage higher than physics allows - assume charger is pumping
     /// in power
 
-#ifndef BAT_FULLVOLT
-#define BAT_FULLVOLT 4200
-#endif
-#ifndef BAT_EMPTYVOLT
-#define BAT_EMPTYVOLT 3270
-#endif
-#ifndef BAT_CHARGINGVOLT
-#define BAT_CHARGINGVOLT 4210
-#endif
-#ifndef BAT_NOBATVOLT
-#define BAT_NOBATVOLT 2230
-#endif
-
-    /// For heltecs with no battery connected, the measured voltage is 2204, so raising to 2230 from 2100
-    const float fullVolt = BAT_FULLVOLT, emptyVolt = BAT_EMPTYVOLT, chargingVolt = BAT_CHARGINGVOLT, noBatVolt = BAT_NOBATVOLT;
-    float last_read_value = 0.0;
+    /// For heltecs with no battery connected, the measured voltage is 2204, so
+    // need to be higher than that, in this case is 2500mV (3000-500)
+    const uint16_t OCV[NUM_OCV_POINTS] = {OCV_ARRAY};
+    const float chargingVolt = (OCV[0] + 10) * NUM_CELLS;
+    const float noBatVolt = (OCV[NUM_OCV_POINTS - 1] - 500) * NUM_CELLS;
+    // Start value from minimum voltage for the filter to not start from 0
+    // that could trigger some events.
+    float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
     uint32_t last_read_time_ms = 0;
 
 #if defined(HAS_TELEMETRY) && !defined(ARCH_PORTDUINO)
     uint16_t getINAVoltage()
     {
-        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219] == config.power.device_battery_ina_address) {
+        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
             return ina219Sensor.getBusVoltageMv();
-        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260] == config.power.device_battery_ina_address) {
+        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first ==
+                   config.power.device_battery_ina_address) {
             return ina260Sensor.getBusVoltageMv();
+        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first ==
+                   config.power.device_battery_ina_address) {
+            return ina3221Sensor.getBusVoltageMv();
         }
         return 0;
     }
@@ -282,11 +380,12 @@ class AnalogBatteryLevel : public HasBatteryLevel
         if (!config.power.device_battery_ina_address) {
             return false;
         }
-        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219] == config.power.device_battery_ina_address) {
+        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
             if (!ina219Sensor.isInitialized())
                 return ina219Sensor.runOnce() > 0;
             return ina219Sensor.isRunning();
-        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260] == config.power.device_battery_ina_address) {
+        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first ==
+                   config.power.device_battery_ina_address) {
             if (!ina260Sensor.isInitialized())
                 return ina260Sensor.runOnce() > 0;
             return ina260Sensor.isRunning();
@@ -312,6 +411,9 @@ bool Power::analogInit()
 #ifdef EXT_PWR_DETECT
     pinMode(EXT_PWR_DETECT, INPUT);
 #endif
+#ifdef EXT_CHRG_DETECT
+    pinMode(EXT_CHRG_DETECT, ext_chrg_detect_mode);
+#endif
 
 #ifdef BATTERY_PIN
     LOG_DEBUG("Using analog input %d for battery level\n", BATTERY_PIN);
@@ -335,8 +437,11 @@ bool Power::analogInit()
     adc1_config_channel_atten(adc_channel, atten);
 #else // ADC2
     adc2_config_channel_atten(adc_channel, atten);
+#ifndef CONFIG_IDF_TARGET_ESP32S3
     // ADC2 wifi bug workaround
+    // Not required with ESP32S3, breaks compile
     RTC_reg_b = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG);
+#endif
 #endif
     // calibrate ADC
     esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, atten, width, DEFAULT_VREF, adc_characs);
@@ -345,13 +450,16 @@ bool Power::analogInit()
         LOG_INFO("ADCmod: ADC characterization based on Two Point values stored in eFuse\n");
     } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
         LOG_INFO("ADCmod: ADC characterization based on reference voltage stored in eFuse\n");
-    } else {
+    }
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+    // ESP32S3
+    else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP_FIT) {
+        LOG_INFO("ADCmod: ADC Characterization based on Two Point values and fitting curve coefficients stored in eFuse\n");
+    }
+#endif
+    else {
         LOG_INFO("ADCmod: ADC characterization based on default reference voltage\n");
     }
-#if defined(HELTEC_V3) || defined(HELTEC_WSL_V3)
-    pinMode(37, OUTPUT); // needed for P channel mosfet to work
-    digitalWrite(37, LOW);
-#endif
 #endif // ARCH_ESP32
 
 #ifdef ARCH_NRF52
@@ -360,11 +468,12 @@ bool Power::analogInit()
 #else
     analogReference(AR_INTERNAL); // 3.6V
 #endif
-    analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS); // Default of 12 is not very linear. Recommended to use 10 or 11
-                                                         // depending on needed resolution.
-
 #endif // ARCH_NRF52
 
+#ifndef ARCH_ESP32
+    analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
+#endif
+
     batteryLevel = &analogLevel;
     return true;
 #else
@@ -379,11 +488,8 @@ bool Power::analogInit()
  */
 bool Power::setup()
 {
-    bool found = axpChipInit();
+    bool found = axpChipInit() || analogInit();
 
-    if (!found) {
-        found = analogInit();
-    }
     enabled = found;
     low_voltage_counter = 0;
 
@@ -392,19 +498,9 @@ bool Power::setup()
 
 void Power::shutdown()
 {
-    screen->setOn(false);
-#if defined(USE_EINK) && defined(PIN_EINK_EN)
-    digitalWrite(PIN_EINK_EN, LOW); // power off backlight first
-#endif
-
     LOG_INFO("Shutting down\n");
 
-#ifdef HAS_PMU
-    if (pmu_found == true) {
-        PMU->setChargingLedMode(XPOWERS_CHG_LED_OFF);
-        PMU->shutdown();
-    }
-#elif defined(ARCH_NRF52) || defined(ARCH_ESP32)
+#if defined(ARCH_NRF52) || defined(ARCH_ESP32)
 #ifdef PIN_LED1
     ledOff(PIN_LED1);
 #endif
@@ -412,9 +508,9 @@ void Power::shutdown()
     ledOff(PIN_LED2);
 #endif
 #ifdef PIN_LED3
-    ledOff(PIN_LED2);
+    ledOff(PIN_LED3);
 #endif
-    doDeepSleep(DELAY_FOREVER);
+    doDeepSleep(DELAY_FOREVER, false);
 #endif
 }
 
@@ -434,18 +530,33 @@ void Power::readPowerStatus()
                 batteryChargePercent = batteryLevel->getBatteryPercent();
             } else {
                 // If the AXP192 returns a percentage less than 0, the feature is either not supported or there is an error
-                // In that case, we compute an estimate of the charge percent based on maximum and minimum voltages defined in
-                // power.h
-                batteryChargePercent =
-                    clamp((int)(((batteryVoltageMv - BAT_MILLIVOLTS_EMPTY) * 1e2) / (BAT_MILLIVOLTS_FULL - BAT_MILLIVOLTS_EMPTY)),
-                          0, 100);
+                // In that case, we compute an estimate of the charge percent based on open circuite voltage table defined
+                // in power.h
+                batteryChargePercent = clamp((int)(((batteryVoltageMv - (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS)) * 1e2) /
+                                                   ((OCV[0] * NUM_CELLS) - (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS))),
+                                             0, 100);
             }
         }
 
+        OptionalBool NRF_USB = OptFalse;
+
+#ifdef NRF_APM // Section of code detects USB power on the RAK4631 and updates the power states.  Takes 20 seconds or so to detect
+               // changes.
+
+        nrfx_power_usb_state_t nrf_usb_state = nrfx_power_usbstatus_get();
+
+        if (nrf_usb_state == NRFX_POWER_USB_STATE_DISCONNECTED) {
+            powerFSM.trigger(EVENT_POWER_DISCONNECTED);
+            NRF_USB = OptFalse;
+        } else {
+            powerFSM.trigger(EVENT_POWER_CONNECTED);
+            NRF_USB = OptTrue;
+        }
+#endif
         // Notify any status instances that are observing us
-        const PowerStatus powerStatus2 =
-            PowerStatus(hasBattery ? OptTrue : OptFalse, batteryLevel->isVbusIn() ? OptTrue : OptFalse,
-                        batteryLevel->isCharging() ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
+        const PowerStatus powerStatus2 = PowerStatus(
+            hasBattery ? OptTrue : OptFalse, batteryLevel->isVbusIn() || NRF_USB == OptTrue ? OptTrue : OptFalse,
+            batteryLevel->isCharging() || NRF_USB == OptTrue ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
         LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
                   powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
         newStatus.notifyObservers(&powerStatus2);
@@ -488,10 +599,11 @@ void Power::readPowerStatus()
 
 #endif
 
-        // If we have a battery at all and it is less than 10% full, force deep sleep if we have more than 10 low readings in
-        // a row
+        // If we have a battery at all and it is less than 0%, force deep sleep if we have more than 10 low readings in
+        // a row. NOTE: min LiIon/LiPo voltage is 2.0 to 2.5V, current OCV min is set to 3100 that is large enough.
+        //
         if (powerStatus2.getHasBattery() && !powerStatus2.getHasUSB()) {
-            if (batteryLevel->getBattVoltage() < MIN_BAT_MILLIVOLTS) {
+            if (batteryLevel->getBattVoltage() < OCV[NUM_OCV_POINTS - 1]) {
                 low_voltage_counter++;
                 LOG_DEBUG("Low voltage counter: %d/10\n", low_voltage_counter);
                 if (low_voltage_counter > 10) {
@@ -859,4 +971,4 @@ bool Power::axpChipInit()
 #else
     return false;
 #endif
-}
+}

src/PowerFSM.cpp

@@ -8,7 +8,7 @@
  * actions to be taken upon entering or exiting each state.
  */
 #include "PowerFSM.h"
-#include "GPS.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "configuration.h"
@@ -17,6 +17,10 @@
 #include "sleep.h"
 #include "target_specific.h"
 
+#ifndef SLEEP_TIME
+#define SLEEP_TIME 30
+#endif
+
 /// Should we behave as if we have AC power now?
 static bool isPowered()
 {
@@ -46,7 +50,7 @@ static void sdsEnter()
 {
     LOG_DEBUG("Enter state: SDS\n");
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
-    doDeepSleep(getConfiguredOrDefaultMs(config.power.sds_secs));
+    doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false);
 }
 
 extern Power *power;
@@ -81,7 +85,7 @@ static void lsIdle()
         // 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 = 30;
+            uint32_t sleepTime = SLEEP_TIME;
 
             setLed(false); // Never leave led on while in light sleep
             esp_sleep_source_t wakeCause2 = doLightSleep(sleepTime * 1000LL);
@@ -103,9 +107,7 @@ static void lsIdle()
                 break;
 
             default:
-                // We woke for some other reason (button press, device interrupt)
-                // uint64_t status = esp_sleep_get_ext1_wakeup_status();
-                LOG_INFO("wakeCause2 %d\n", wakeCause2);
+                // 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);
@@ -137,9 +139,6 @@ static void lsIdle()
 static void lsExit()
 {
     LOG_INFO("Exit state: LS\n");
-    // setGPSPower(true); // restore GPS power
-    if (gps)
-        gps->forceWake(true);
 }
 
 static void nbEnter()
@@ -186,10 +185,12 @@ static void powerEnter()
         screen->setOn(true);
         setBluetoothEnable(true);
         // within enter() the function getState() returns the state we came from
-        if (strcmp(powerFSM.getState()->name, "BOOT") != 0 && strcmp(powerFSM.getState()->name, "POWER") != 0 &&
+
+        // Mothballed: print change of power-state to device screen
+        /* if (strcmp(powerFSM.getState()->name, "BOOT") != 0 && strcmp(powerFSM.getState()->name, "POWER") != 0 &&
             strcmp(powerFSM.getState()->name, "DARK") != 0) {
             screen->print("Powered...\n");
-        }
+        }*/
     }
 }
 
@@ -206,8 +207,10 @@ static void powerExit()
 {
     screen->setOn(true);
     setBluetoothEnable(true);
-    if (!isPowered())
-        screen->print("Unpowered...\n");
+
+    // Mothballed: print change of power-state to device screen
+    /*if (!isPowered())
+        screen->print("Unpowered...\n");*/
 }
 
 static void onEnter()
@@ -249,6 +252,9 @@ Fsm powerFSM(&stateBOOT);
 void PowerFSM_setup()
 {
     bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
+    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 hasPower = isPowered();
 
     LOG_INFO("PowerFSM init, USB power=%d\n", hasPower ? 1 : 0);
@@ -343,32 +349,39 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateDARK, &stateDARK, EVENT_CONTACT_FROM_PHONE, NULL, "Contact from phone");
 
     powerFSM.add_timed_transition(&stateON, &stateDARK,
-                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
+                                  Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
                                   "Screen-on timeout");
     powerFSM.add_timed_transition(&statePOWER, &stateDARK,
-                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
-                                  "Screen-on timeout");
-    powerFSM.add_timed_transition(&stateDARK, &stateDARK,
-                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
+                                  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
-    State *lowPowerState = &stateLS;
-    // We never enter light-sleep or NB states on NRF52 (because the CPU uses so little power normally)
-
     // See: https://github.com/meshtastic/firmware/issues/1071
-    if (isRouter || config.power.is_power_saving) {
+    // Don't add power saving transitions if we are a power saving tracker or sensor. Sleep will be initiatiated through the
+    // modules
+    if ((isRouter || config.power.is_power_saving) && !isTrackerOrSensor) {
         powerFSM.add_timed_transition(&stateNB, &stateLS,
-                                      getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
+                                      Default::getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
                                       "Min wake timeout");
-        powerFSM.add_timed_transition(&stateDARK, &stateLS,
-                                      getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs),
-                                      NULL, "Bluetooth timeout");
-    }
 
-    if (config.power.sds_secs != UINT32_MAX)
-        powerFSM.add_timed_transition(lowPowerState, &stateSDS, getConfiguredOrDefaultMs(config.power.sds_secs), NULL,
-                                      "mesh 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");
+    }
+#else
+    // 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

src/PowerFSMThread.h

@@ -1,3 +1,4 @@
+#include "Default.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "concurrency/OSThread.h"
@@ -21,19 +22,19 @@ class PowerFSMThread : public OSThread
 
         /// 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 auto state = powerFSM.getState();
+        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 +
-                               getConfiguredOrDefaultMs(
+                               Default::getConfiguredOrDefaultMs(
                                    config.power.on_battery_shutdown_after_secs))) { // shutdown after 30 minutes unpowered
             powerFSM.trigger(EVENT_SHUTDOWN);
         }
 
-        return 10;
+        return 100;
     }
 };
 

src/RedirectablePrint.cpp

@@ -10,6 +10,10 @@
 #include <sys/time.h>
 #include <time.h>
 
+#ifdef ARCH_PORTDUINO
+#include "platform/portduino/PortduinoGlue.h"
+#endif
+
 /**
  * A printer that doesn't go anywhere
  */
@@ -68,7 +72,15 @@ size_t RedirectablePrint::vprintf(const char *format, va_list arg)
 
 size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
 {
-    if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, "DEBUG") == 0) {
+#ifdef ARCH_PORTDUINO
+    if (settingsMap[logoutputlevel] < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+        return 0;
+    else if (settingsMap[logoutputlevel] < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+        return 0;
+    else if (settingsMap[logoutputlevel] < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+        return 0;
+#endif
+    if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
         return 0;
     }
     size_t r = 0;
@@ -87,7 +99,7 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
 
         // If we are the first message on a report, include the header
         if (!isContinuationMessage) {
-            uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice);
+            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;
@@ -99,10 +111,17 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
                 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
+                r += ::printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
+#else
                 r += printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
+#endif
             } else
+#ifdef ARCH_PORTDUINO
+                r += ::printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
+#else
                 r += printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
+#endif
 
             auto thread = concurrency::OSThread::currentThread;
             if (thread) {
@@ -163,11 +182,11 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
 void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16_t len)
 {
     const char alphabet[17] = "0123456789abcdef";
-    log(logLevel, "   +------------------------------------------------+ +----------------+\n");
-    log(logLevel, "   |.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .a .b .c .d .e .f | |      ASCII     |\n");
+    log(logLevel, "    +------------------------------------------------+ +----------------+\n");
+    log(logLevel, "    |.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .a .b .c .d .e .f | |      ASCII     |\n");
     for (uint16_t i = 0; i < len; i += 16) {
         if (i % 128 == 0)
-            log(logLevel, "   +------------------------------------------------+ +----------------+\n");
+            log(logLevel, "    +------------------------------------------------+ +----------------+\n");
         char s[] = "|                                                | |                |\n";
         uint8_t ix = 1, iy = 52;
         for (uint8_t j = 0; j < 16; j++) {
@@ -189,7 +208,7 @@ void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16
         log(logLevel, ".");
         log(logLevel, s);
     }
-    log(logLevel, "   +------------------------------------------------+ +----------------+\n");
+    log(logLevel, "    +------------------------------------------------+ +----------------+\n");
 }
 
 std::string RedirectablePrint::mt_sprintf(const std::string fmt_str, ...)

src/SerialConsole.cpp

@@ -3,7 +3,11 @@
 #include "PowerFSM.h"
 #include "configuration.h"
 
+#ifdef RP2040_SLOW_CLOCK
+#define Port Serial2
+#else
 #define Port Serial
+#endif
 // Defaulting to the formerly removed phone_timeout_secs value of 15 minutes
 #define SERIAL_CONNECTION_TIMEOUT (15 * 60) * 1000UL
 
@@ -31,6 +35,10 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), con
     canWrite = false; // We don't send packets to our port until it has talked to us first
                       // setDestination(&noopPrint); for testing, try turning off 'all' debug output and see what leaks
 
+#ifdef RP2040_SLOW_CLOCK
+    Port.setTX(SERIAL2_TX);
+    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)
     time_t timeout = millis();
@@ -64,7 +72,7 @@ bool SerialConsole::checkIsConnected()
 
 /**
  * we override this to notice when we've received a protobuf over the serial
- * stream.  Then we shunt off debug serial output.
+ * stream.  Then we shut off debug serial output.
  */
 bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
 {

src/concurrency/OSThread.h

@@ -53,7 +53,7 @@ class OSThread : public Thread
 
     static void setup();
 
-    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)
@@ -67,6 +67,7 @@ class OSThread : public Thread
      * 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();
@@ -87,4 +88,4 @@ extern bool hasBeenSetup;
 
 void assertIsSetup();
 
-} // namespace concurrency
+} // namespace concurrency

src/configuration.h

@@ -57,8 +57,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define REQUIRE_RADIO true // If true, we will fail to start if the radio is not found
 
 /// Convert a preprocessor name into a quoted string
-#define xstr(s) str(s)
-#define str(s) #s
+#define xstr(s) ystr(s)
+#define ystr(s) #s
 
 /// Convert a preprocessor name into a quoted string and if that string is empty use "unset"
 #define optstr(s) (xstr(s)[0] ? xstr(s) : "unset")
@@ -74,6 +74,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define RTC_DATA_ATTR
 #endif
 
+// -----------------------------------------------------------------------------
+// Regulatory overrides for producing regional builds
+// -----------------------------------------------------------------------------
+
+// Define if region should override user saved region
+// #define LORA_REGIONCODE meshtastic_Config_LoRaConfig_RegionCode_SG_923
+
 // -----------------------------------------------------------------------------
 // Feature toggles
 // -----------------------------------------------------------------------------
@@ -111,6 +118,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MCP9808_ADDR 0x18
 #define INA_ADDR 0x40
 #define INA_ADDR_ALTERNATE 0x41
+#define INA_ADDR_WAVESHARE_UPS 0x43
+#define INA3221_ADDR 0x42
 #define QMC6310_ADDR 0x1C
 #define QMI8658_ADDR 0x6B
 #define QMC5883L_ADDR 0x1E
@@ -126,6 +135,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MPU6050_ADDR 0x68
 #define LIS3DH_ADR 0x18
 #define BMA423_ADDR 0x19
+#define LSM6DS3_ADDR 0x6A
 
 // -----------------------------------------------------------------------------
 // LED
@@ -135,17 +145,22 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // -----------------------------------------------------------------------------
 // Security
 // -----------------------------------------------------------------------------
-
 #define ATECC608B_ADDR 0x35
 
+// -----------------------------------------------------------------------------
+// IO Expander
+// -----------------------------------------------------------------------------
+#define TCA9555_ADDR 0x26
+
 // -----------------------------------------------------------------------------
 // GPS
 // -----------------------------------------------------------------------------
-
+#ifndef GPS_BAUDRATE
 #define GPS_BAUDRATE 9600
+#endif
 
 #ifndef GPS_THREAD_INTERVAL
-#define GPS_THREAD_INTERVAL 100
+#define GPS_THREAD_INTERVAL 200
 #endif
 
 // convert 24-bit color to 16-bit (56K)
@@ -158,6 +173,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
    also enable HAS_ option not specifically disabled by variant.h */
 #include "architecture.h"
 
+#ifndef DEFAULT_REBOOT_SECONDS
+#define DEFAULT_REBOOT_SECONDS 7
+#endif
+
+#ifndef DEFAULT_SHUTDOWN_SECONDS
+#define DEFAULT_SHUTDOWN_SECONDS 2
+#endif
+
 /* Step #3: mop up with disabled values for HAS_ options not handled by the above two */
 
 #ifndef HAS_WIFI
@@ -187,6 +210,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef HAS_TELEMETRY
 #define HAS_TELEMETRY 0
 #endif
+#ifndef HAS_SENSOR
+#define HAS_SENSOR 0
+#endif
 #ifndef HAS_RADIO
 #define HAS_RADIO 0
 #endif
@@ -205,4 +231,65 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifndef HW_VENDOR
 #error HW_VENDOR must be defined
+#endif
+
+// -----------------------------------------------------------------------------
+// Global switches to turn off features for a minimized build
+// -----------------------------------------------------------------------------
+
+// #define MESHTASTIC_MINIMIZE_BUILD 1
+#ifdef MESHTASTIC_MINIMIZE_BUILD
+#define MESHTASTIC_EXCLUDE_MODULES 1
+#define MESHTASTIC_EXCLUDE_WIFI 1
+#define MESHTASTIC_EXCLUDE_BLUETOOTH 1
+#define MESHTASTIC_EXCLUDE_GPS 1
+#define MESHTASTIC_EXCLUDE_SCREEN 1
+#define MESHTASTIC_EXCLUDE_MQTT 1
+#endif
+
+// Turn off all optional modules
+#ifdef MESHTASTIC_EXCLUDE_MODULES
+#define MESHTASTIC_EXCLUDE_AUDIO 1
+#define MESHTASTIC_EXCLUDE_DETECTIONSENSOR 1
+#define MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR 1
+#define MESHTASTIC_EXCLUDE_EXTERNALNOTIFICATION 1
+#define MESHTASTIC_EXCLUDE_PAXCOUNTER 1
+#define MESHTASTIC_EXCLUDE_POWER_TELEMETRY 1
+#define MESHTASTIC_EXCLUDE_RANGETEST 1
+#define MESHTASTIC_EXCLUDE_REMOTEHARDWARE 1
+#define MESHTASTIC_EXCLUDE_STOREFORWARD 1
+#define MESHTASTIC_EXCLUDE_ATAK 1
+#define MESHTASTIC_EXCLUDE_CANNEDMESSAGES 1
+#define MESHTASTIC_EXCLUDE_NEIGHBORINFO 1
+#define MESHTASTIC_EXCLUDE_TRACEROUTE 1
+#define MESHTASTIC_EXCLUDE_WAYPOINT 1
+#define MESHTASTIC_EXCLUDE_INPUTBROKER 1
+#define MESHTASTIC_EXCLUDE_SERIAL 1
+#endif
+
+// // Turn off wifi even if HW supports wifi (webserver relies on wifi and is also disabled)
+#ifdef MESHTASTIC_EXCLUDE_WIFI
+#define MESHTASTIC_EXCLUDE_WEBSERVER 1
+#undef HAS_WIFI
+#define HAS_WIFI 0
+#endif
+
+// // Turn off Bluetooth
+#ifdef MESHTASTIC_EXCLUDE_BLUETOOTH
+#undef HAS_BLUETOOTH
+#define HAS_BLUETOOTH 0
+#endif
+
+// // Turn off GPS
+#ifdef MESHTASTIC_EXCLUDE_GPS
+#undef HAS_GPS
+#define HAS_GPS 0
+#undef MESHTASTIC_EXCLUDE_RANGETEST
+#define MESHTASTIC_EXCLUDE_RANGETEST 1
+#endif
+
+// Turn off Screen
+#ifdef MESHTASTIC_EXCLUDE_SCREEN
+#undef HAS_SCREEN
+#define HAS_SCREEN 0
 #endif

src/detect/LoRaRadioType.h

@@ -0,0 +1,5 @@
+#pragma once
+
+enum LoRaRadioType { NO_RADIO, STM32WLx_RADIO, SIM_RADIO, RF95_RADIO, SX1262_RADIO, SX1268_RADIO, LLCC68_RADIO, SX1280_RADIO };
+
+extern LoRaRadioType radioType;

src/detect/ScanI2C.cpp

@@ -36,8 +36,8 @@ ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
 
 ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const
 {
-    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423};
-    return firstOfOrNONE(3, types);
+    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423, LSM6DS3};
+    return firstOfOrNONE(4, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::find(ScanI2C::DeviceType) const

src/detect/ScanI2C.h

@@ -23,8 +23,10 @@ class ScanI2C
         BME_680,
         BME_280,
         BMP_280,
+        BMP_085,
         INA260,
         INA219,
+        INA3221,
         MCP9808,
         SHT31,
         SHTC3,
@@ -36,6 +38,9 @@ class ScanI2C
         MPU6050,
         LIS3DH,
         BMA423,
+        BQ24295,
+        LSM6DS3,
+        TCA9555,
 #ifdef HAS_NCP5623
         NCP5623,
 #endif

src/detect/ScanI2CTwoWire.cpp

@@ -2,7 +2,9 @@
 
 #include "concurrency/LockGuard.h"
 #include "configuration.h"
-
+#if defined(ARCH_PORTDUINO)
+#include "linux/LinuxHardwareI2C.h"
+#endif
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
 #include "main.h" // atecc
 #endif
@@ -162,7 +164,14 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
 
     for (addr.address = 1; addr.address < 127; addr.address++) {
         i2cBus->beginTransmission(addr.address);
+#ifdef ARCH_PORTDUINO
+        if (i2cBus->read() != -1)
+            err = 0;
+        else
+            err = 2;
+#else
         err = i2cBus->endTransmission();
+#endif
         type = NONE;
         if (err == 0) {
             LOG_DEBUG("I2C device found at address 0x%x\n", addr.address);
@@ -174,8 +183,13 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
 
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
             case ATECC608B_ADDR:
-                type = ATECC608B;
-                if (atecc.begin(addr.address) == true) {
+#ifdef RP2040_SLOW_CLOCK
+                if (atecc.begin(addr.address, Wire, Serial2) == true)
+#else
+                if (atecc.begin(addr.address) == true)
+#endif
+
+                {
                     LOG_INFO("ATECC608B initialized\n");
                 } else {
                     LOG_WARN("ATECC608B initialization failed\n");
@@ -233,6 +247,10 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
                     LOG_INFO("BME-280 sensor found at address 0x%x\n", (uint8_t)addr.address);
                     type = BME_280;
                     break;
+                case 0x55:
+                    LOG_INFO("BMP-085 or BMP-180 sensor found at address 0x%x\n", (uint8_t)addr.address);
+                    type = BMP_085;
+                    break;
                 default:
                     LOG_INFO("BMP-280 sensor found at address 0x%x\n", (uint8_t)addr.address);
                     type = BMP_280;
@@ -241,6 +259,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
 
             case INA_ADDR:
             case INA_ADDR_ALTERNATE:
+            case INA_ADDR_WAVESHARE_UPS:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFE), 2);
                 LOG_DEBUG("Register MFG_UID: 0x%x\n", registerValue);
                 if (registerValue == 0x5449) {
@@ -251,7 +270,10 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
                     type = INA219;
                 }
                 break;
-
+            case INA3221_ADDR:
+                LOG_INFO("INA3221 sensor found at address 0x%x\n", (uint8_t)addr.address);
+                type = INA3221;
+                break;
             case MCP9808_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x07), 2);
                 if (registerValue == 0x0400) {
@@ -271,12 +293,31 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
                 SCAN_SIMPLE_CASE(LPS22HB_ADDR, LPS22HB, "LPS22HB sensor found\n")
 
                 SCAN_SIMPLE_CASE(QMC6310_ADDR, QMC6310, "QMC6310 Highrate 3-Axis magnetic sensor found\n")
-                SCAN_SIMPLE_CASE(QMI8658_ADDR, QMI8658, "QMI8658 Highrate 6-Axis inertial measurement sensor found\n")
+
+            case QMI8658_ADDR:
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0A), 1); // get ID
+                if (registerValue == 0xC0) {
+                    type = BQ24295;
+                    LOG_INFO("BQ24295 PMU found\n");
+                    break;
+                }
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0F), 1); // get ID
+                if (registerValue == 0x6A) {
+                    type = LSM6DS3;
+                    LOG_INFO("LSM6DS3 accelerometer found at address 0x%x\n", (uint8_t)addr.address);
+                } else {
+                    type = QMI8658;
+                    LOG_INFO("QMI8658 Highrate 6-Axis inertial measurement sensor found\n");
+                }
+                break;
+
                 SCAN_SIMPLE_CASE(QMC5883L_ADDR, QMC5883L, "QMC5883L Highrate 3-Axis magnetic sensor found\n")
 
                 SCAN_SIMPLE_CASE(PMSA0031_ADDR, PMSA0031, "PMSA0031 air quality sensor found\n")
                 SCAN_SIMPLE_CASE(MPU6050_ADDR, MPU6050, "MPU6050 accelerometer found\n");
                 SCAN_SIMPLE_CASE(BMA423_ADDR, BMA423, "BMA423 accelerometer found\n");
+                SCAN_SIMPLE_CASE(LSM6DS3_ADDR, LSM6DS3, "LSM6DS3 accelerometer found at address 0x%x\n", (uint8_t)addr.address);
+                SCAN_SIMPLE_CASE(TCA9555_ADDR, TCA9555, "TCA9555 I2C expander found\n");
 
             default:
                 LOG_INFO("Device found at address 0x%x was not able to be enumerated\n", addr.address);

src/detect/ScanI2CTwoWire.h

@@ -18,6 +18,8 @@ class ScanI2CTwoWire : public ScanI2C
 
     ScanI2C::FoundDevice find(ScanI2C::DeviceType) const override;
 
+    TwoWire *fetchI2CBus(ScanI2C::DeviceAddress) const;
+
     bool exists(ScanI2C::DeviceType) const override;
 
     size_t countDevices() const override;
@@ -51,6 +53,4 @@ class ScanI2CTwoWire : public ScanI2C
     uint16_t getRegisterValue(const RegisterLocation &, ResponseWidth) const;
 
     DeviceType probeOLED(ScanI2C::DeviceAddress) const;
-
-    TwoWire *fetchI2CBus(ScanI2C::DeviceAddress) const;
 };

src/gps/GPS.h

@@ -1,8 +1,19 @@
 #pragma once
+#include "configuration.h"
+#if !MESHTASTIC_EXCLUDE_GPS
 
 #include "GPSStatus.h"
 #include "Observer.h"
+#include "TinyGPS++.h"
 #include "concurrency/OSThread.h"
+#include "input/RotaryEncoderInterruptImpl1.h"
+#include "input/UpDownInterruptImpl1.h"
+#include "modules/PositionModule.h"
+
+// Allow defining the polarity of the ENABLE output.  default is active high
+#ifndef GPS_EN_ACTIVE
+#define GPS_EN_ACTIVE 1
+#endif
 
 struct uBloxGnssModelInfo {
     char swVersion[30];
@@ -12,10 +23,12 @@ struct uBloxGnssModelInfo {
 };
 
 typedef enum {
+    GNSS_MODEL_ATGM336H,
     GNSS_MODEL_MTK,
     GNSS_MODEL_UBLOX,
-    GNSS_MODEL_UC6850,
+    GNSS_MODEL_UC6580,
     GNSS_MODEL_UNKNOWN,
+    GNSS_MODEL_MTK_L76B
 } GnssModel_t;
 
 typedef enum {
@@ -35,32 +48,102 @@ const char *getDOPString(uint32_t dop);
  */
 class GPS : private concurrency::OSThread
 {
+    TinyGPSPlus reader;
+    uint8_t fixQual = 0; // fix quality from GPGGA
+    uint32_t lastChecksumFailCount = 0;
+
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
+    // via optional feature "custom fields", currently disabled (bug #525)
+    TinyGPSCustom gsafixtype; // custom extract fix type from GPGSA
+    TinyGPSCustom gsapdop;    // custom extract PDOP from GPGSA
+    uint8_t fixType = 0;      // fix type from GPGSA
+#endif
   private:
-    uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0, lastWhileActiveMsec = 0;
+    uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0;
+    const int serialSpeeds[6] = {9600, 4800, 38400, 57600, 115200, 9600};
+
+    uint32_t rx_gpio = 0;
+    uint32_t tx_gpio = 0;
+    uint32_t en_gpio = 0;
+    int32_t averageLockTime = 0;
+    uint32_t GPSCycles = 0;
+
+    int speedSelect = 0;
+    int probeTries = 2;
 
     /**
      * hasValidLocation - indicates that the position variables contain a complete
-     *   GPS location, valid and fresh (< gps_update_interval + gps_attempt_time)
+     *   GPS location, valid and fresh (< gps_update_interval + position_broadcast_secs)
      */
     bool hasValidLocation = false; // default to false, until we complete our first read
 
     bool isAwake = false; // true if we want a location right now
 
-    bool wakeAllowed = true; // false if gps must be forced to sleep regardless of what time it is
+    bool isInPowersave = false;
 
     bool shouldPublish = false; // If we've changed GPS state, this will force a publish the next loop()
 
     bool hasGPS = false; // Do we have a GPS we are talking to
 
+    bool GPSInitFinished = false; // Init thread finished?
+    bool GPSInitStarted = false;  // Init thread finished?
+
     uint8_t numSatellites = 0;
 
-    CallbackObserver<GPS, void *> notifySleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareSleep);
     CallbackObserver<GPS, void *> notifyDeepSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
     CallbackObserver<GPS, void *> notifyGPSSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
 
   public:
     /** If !NULL we will use this serial port to construct our GPS */
+#if defined(RPI_PICO_WAVESHARE)
+    static SerialUART *_serial_gps;
+#else
     static HardwareSerial *_serial_gps;
+#endif
+    static uint8_t _message_PMREQ[];
+    static uint8_t _message_PMREQ_10[];
+    static const uint8_t _message_CFG_RXM_PSM[];
+    static const uint8_t _message_CFG_RXM_ECO[];
+    static const uint8_t _message_CFG_PM2[];
+    static const uint8_t _message_GNSS_7[];
+    static const uint8_t _message_GNSS_8[];
+    static const uint8_t _message_JAM_6_7[];
+    static const uint8_t _message_JAM_8[];
+    static const uint8_t _message_NAVX5[];
+    static const uint8_t _message_NAVX5_8[];
+    static const uint8_t _message_NMEA[];
+    static const uint8_t _message_DISABLE_TXT_INFO[];
+    static const uint8_t _message_1HZ[];
+    static const uint8_t _message_GLL[];
+    static const uint8_t _message_GSA[];
+    static const uint8_t _message_GSV[];
+    static const uint8_t _message_VTG[];
+    static const uint8_t _message_RMC[];
+    static const uint8_t _message_AID[];
+    static const uint8_t _message_GGA[];
+    static const uint8_t _message_PMS[];
+    static const uint8_t _message_SAVE[];
+
+    // VALSET Commands for M10
+    static const uint8_t _message_VALSET_PM[];
+    static const uint8_t _message_VALSET_PM_RAM[];
+    static const uint8_t _message_VALSET_PM_BBR[];
+    static const uint8_t _message_VALSET_ITFM_RAM[];
+    static const uint8_t _message_VALSET_ITFM_BBR[];
+    static const uint8_t _message_VALSET_DISABLE_NMEA_RAM[];
+    static const uint8_t _message_VALSET_DISABLE_NMEA_BBR[];
+    static const uint8_t _message_VALSET_DISABLE_TXT_INFO_RAM[];
+    static const uint8_t _message_VALSET_DISABLE_TXT_INFO_BBR[];
+    static const uint8_t _message_VALSET_ENABLE_NMEA_RAM[];
+    static const uint8_t _message_VALSET_ENABLE_NMEA_BBR[];
+    static const uint8_t _message_VALSET_DISABLE_SBAS_RAM[];
+    static const uint8_t _message_VALSET_DISABLE_SBAS_BBR[];
+
+    // CASIC commands for ATGM336H
+    static const uint8_t _message_CAS_CFG_RST_FACTORY[];
+    static const uint8_t _message_CAS_CFG_NAVX_CONF[];
+    static const uint8_t _message_CAS_CFG_RATE_1HZ[];
 
     meshtastic_Position p = meshtastic_Position_init_default;
 
@@ -76,6 +159,17 @@ class GPS : private concurrency::OSThread
      */
     virtual bool setup();
 
+    // re-enable the thread
+    void enable();
+
+    // Disable the thread
+    int32_t disable() override;
+
+    // toggle between enabled/disabled
+    void toggleGpsMode();
+
+    void setGPSPower(bool on, bool standbyOnly, uint32_t sleepTime);
+
     /// Returns true if we have acquired GPS lock.
     virtual bool hasLock();
 
@@ -85,73 +179,25 @@ class GPS : private concurrency::OSThread
     /// Return true if we are connected to a GPS
     bool isConnected() const { return hasGPS; }
 
-    bool isPowerSaving() const { return !config.position.gps_enabled; }
-
-    /**
-     * Restart our lock attempt - try to get and broadcast a GPS reading ASAP
-     * called after the CPU wakes from light-sleep state
-     *
-     * Or set to false, to disallow any sort of waking
-     * */
-    void forceWake(bool on);
-
-    // Some GPS modules (ublock) require factory reset
-    virtual bool factoryReset() { return true; }
+    bool isPowerSaving() const { return config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED; }
 
     // Empty the input buffer as quickly as possible
     void clearBuffer();
 
-  protected:
-    /// Do gps chipset specific init, return true for success
-    virtual bool setupGPS();
+    // Create a ublox packet for editing in memory
+    uint8_t makeUBXPacket(uint8_t class_id, uint8_t msg_id, uint8_t payload_size, const uint8_t *msg);
+    uint8_t makeCASPacket(uint8_t class_id, uint8_t msg_id, uint8_t payload_size, const uint8_t *msg);
 
-    /// If possible force the GPS into sleep/low power mode
-    virtual void sleep();
+    // scratch space for creating ublox packets
+    uint8_t UBXscratch[250] = {0};
 
-    /// wake the GPS into normal operation mode
-    virtual void wake();
+    int rebootsSeen = 0;
 
-    /** Subclasses should look for serial rx characters here and feed it to their GPS parser
-     *
-     * Return true if we received a valid message from the GPS
-     */
-    virtual bool whileIdle() = 0;
+    int getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID, uint32_t waitMillis);
+    GPS_RESPONSE getACK(uint8_t c, uint8_t i, uint32_t waitMillis);
+    GPS_RESPONSE getACK(const char *message, uint32_t waitMillis);
 
-    /** Idle processing while GPS is looking for lock, called once per secondish */
-    virtual void whileActive() {}
-
-    /**
-     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
-     * Override this method to check for new locations
-     *
-     * @return true if we've acquired a time
-     */
-    virtual bool lookForTime() = 0;
-
-    /**
-     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
-     * Override this method to check for new locations
-     *
-     * @return true if we've acquired a new location
-     */
-    virtual bool lookForLocation() = 0;
-
-    /// Record that we have a GPS
-    void setConnected();
-
-    void setNumSatellites(uint8_t n);
-
-  private:
-    /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
-    /// always returns 0 to indicate okay to sleep
-    int prepareSleep(void *unused);
-
-    /// Prepare the GPS for the cpu entering deep sleep, expect to be gone for at least 100s of msecs
-    /// always returns 0 to indicate okay to sleep
-    int prepareDeepSleep(void *unused);
-
-    // Calculate checksum
-    void UBXChecksum(byte *message, size_t length);
+    GPS_RESPONSE getACKCas(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis);
 
     /**
      * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
@@ -159,6 +205,60 @@ class GPS : private concurrency::OSThread
      * calls sleep/wake
      */
     void setAwake(bool on);
+    virtual bool factoryReset();
+
+    // Creates an instance of the GPS class.
+    // Returns the new instance or null if the GPS is not present.
+    static GPS *createGps();
+
+  protected:
+    /**
+     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+     * Override this method to check for new locations
+     *
+     * @return true if we've acquired a time
+     */
+
+    /**
+     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+     * Override this method to check for new locations
+     *
+     * @return true if we've acquired a new location
+     */
+
+    /// Record that we have a GPS
+    void setConnected();
+
+    /** Subclasses should look for serial rx characters here and feed it to their GPS parser
+     *
+     * Return true if we received a valid message from the GPS
+     */
+    virtual bool whileIdle();
+
+    /**
+     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+     * Override this method to check for new locations
+     *
+     * @return true if we've acquired a time
+     */
+    virtual bool lookForTime();
+
+    /**
+     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+     * Override this method to check for new locations
+     *
+     * @return true if we've acquired a new location
+     */
+    virtual bool lookForLocation();
+
+  private:
+    /// Prepare the GPS for the cpu entering deep sleep, expect to be gone for at least 100s of msecs
+    /// always returns 0 to indicate okay to sleep
+    int prepareDeepSleep(void *unused);
+
+    // Calculate checksum
+    void UBXChecksum(uint8_t *message, size_t length);
+    void CASChecksum(uint8_t *message, size_t length);
 
     /** Get how long we should stay looking for each aquisition
      */
@@ -179,9 +279,6 @@ class GPS : private concurrency::OSThread
     String getNMEA();
     GnssModel_t probe(int serialSpeed);
 
-    int getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID, uint32_t waitMillis);
-    GPS_RESPONSE getACK(uint8_t c, uint8_t i, uint32_t waitMillis);
-    GPS_RESPONSE getACK(const char *message, uint32_t waitMillis);
     // delay counter to allow more sats before fixed position stops GPS thread
     uint8_t fixeddelayCtr = 0;
 
@@ -189,8 +286,5 @@ class GPS : private concurrency::OSThread
     GnssModel_t gnssModel = GNSS_MODEL_UNKNOWN;
 };
 
-// Creates an instance of the GPS class.
-// Returns the new instance or null if the GPS is not present.
-GPS *createGps();
-
-extern GPS *gps;
+extern GPS *gps;
+#endif // Exclude GPS

src/gps/GeoCoord.cpp

@@ -376,14 +376,17 @@ void GeoCoord::convertWGS84ToOSGB36(const double lat, const double lon, double &
 }
 
 /// Ported from my old java code, returns distance in meters along the globe
-/// surface (by magic?)
+/// surface (by Haversine formula)
 float GeoCoord::latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b)
 {
-    double pk = (180 / 3.14169);
-    double a1 = lat_a / pk;
-    double a2 = lng_a / pk;
-    double b1 = lat_b / pk;
-    double b2 = lng_b / pk;
+    // Don't do math if the points are the same
+    if (lat_a == lat_b && lng_a == lng_b)
+        return 0.0;
+
+    double a1 = lat_a / DEG_CONVERT;
+    double a2 = lng_a / DEG_CONVERT;
+    double b1 = lat_b / DEG_CONVERT;
+    double b2 = lng_b / DEG_CONVERT;
     double cos_b1 = cos(b1);
     double cos_a1 = cos(a1);
     double t1 = cos_a1 * cos(a2) * cos_b1 * cos(b2);

src/gps/GeoCoord.h

@@ -11,6 +11,7 @@
 
 #define PI 3.1415926535897932384626433832795
 #define OLC_CODE_LEN 11
+#define DEG_CONVERT (180 / PI)
 
 // Helper functions
 // Raises a number to an exponent, handling negative exponents.

src/gps/NMEAGPS.cpp

@@ -1,272 +0,0 @@
-#include "NMEAGPS.h"
-#include "RTC.h"
-#include "configuration.h"
-
-#include <TinyGPS++.h>
-
-// GPS solutions older than this will be rejected - see TinyGPSDatum::age()
-#define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
-#define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
-
-static int32_t toDegInt(RawDegrees d)
-{
-    int32_t degMult = 10000000; // 1e7
-    int32_t r = d.deg * degMult + d.billionths / 100;
-    if (d.negative)
-        r *= -1;
-    return r;
-}
-
-bool NMEAGPS::factoryReset()
-{
-#ifdef PIN_GPS_REINIT
-    // The L76K GNSS on the T-Echo requires the RESET pin to be pulled LOW
-    digitalWrite(PIN_GPS_REINIT, 0);
-    pinMode(PIN_GPS_REINIT, OUTPUT);
-    delay(150); // The L76K datasheet calls for at least 100MS delay
-    digitalWrite(PIN_GPS_REINIT, 1);
-#endif
-
-    // send the UBLOX Factory Reset Command regardless of detect state, something is very wrong, just assume it's UBLOX.
-    // Factory Reset
-    byte _message_reset[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF, 0xFB, 0x00, 0x00, 0x00,
-                             0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x17, 0x2B, 0x7E};
-    _serial_gps->write(_message_reset, sizeof(_message_reset));
-    delay(1000);
-    return true;
-}
-
-bool NMEAGPS::setupGPS()
-{
-    GPS::setupGPS();
-
-#ifdef PIN_GPS_PPS
-    // pulse per second
-    // FIXME - move into shared GPS code
-    pinMode(PIN_GPS_PPS, INPUT);
-#endif
-
-// Currently disabled per issue #525 (TinyGPS++ crash bug)
-// when fixed upstream, can be un-disabled to enable 3D FixType and PDOP
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    // see NMEAGPS.h
-    gsafixtype.begin(reader, NMEA_MSG_GXGSA, 2);
-    gsapdop.begin(reader, NMEA_MSG_GXGSA, 15);
-    LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
-#else
-    LOG_DEBUG("GxGSA NOT available\n");
-#endif
-
-    return true;
-}
-
-/**
- * Perform any processing that should be done only while the GPS is awake and looking for a fix.
- * Override this method to check for new locations
- *
- * @return true if we've acquired a new location
- */
-bool NMEAGPS::lookForTime()
-{
-    auto ti = reader.time;
-    auto d = reader.date;
-    if (ti.isValid() && d.isValid()) { // Note: we don't check for updated, because we'll only be called if needed
-        /* Convert to unix time
-The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
-(midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
-*/
-        struct tm t;
-        t.tm_sec = ti.second();
-        t.tm_min = ti.minute();
-        t.tm_hour = ti.hour();
-        t.tm_mday = d.day();
-        t.tm_mon = d.month() - 1;
-        t.tm_year = d.year() - 1900;
-        t.tm_isdst = false;
-        if (t.tm_mon > -1) {
-            LOG_DEBUG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min,
-                      t.tm_sec);
-            perhapsSetRTC(RTCQualityGPS, t);
-            return true;
-        } else
-            return false;
-    } else
-        return false;
-}
-
-/**
- * Perform any processing that should be done only while the GPS is awake and looking for a fix.
- * Override this method to check for new locations
- *
- * @return true if we've acquired a new location
- */
-bool NMEAGPS::lookForLocation()
-{
-    // By default, TinyGPS++ does not parse GPGSA lines, which give us
-    //   the 2D/3D fixType (see NMEAGPS.h)
-    // At a minimum, use the fixQuality indicator in GPGGA (FIXME?)
-    fixQual = reader.fixQuality();
-
-#ifndef TINYGPS_OPTION_NO_STATISTICS
-    if (reader.failedChecksum() > lastChecksumFailCount) {
-        LOG_WARN("Warning, %u new GPS checksum failures, for a total of %u.\n", reader.failedChecksum() - lastChecksumFailCount,
-                 reader.failedChecksum());
-        lastChecksumFailCount = reader.failedChecksum();
-    }
-#endif
-
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    fixType = atoi(gsafixtype.value()); // will set to zero if no data
-    // LOG_DEBUG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
-#endif
-
-    // check if GPS has an acceptable lock
-    if (!hasLock())
-        return false;
-
-#ifdef GPS_EXTRAVERBOSE
-    LOG_DEBUG("AGE: LOC=%d FIX=%d DATE=%d TIME=%d\n", reader.location.age(),
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-              gsafixtype.age(),
-#else
-              0,
-#endif
-              reader.date.age(), reader.time.age());
-#endif // GPS_EXTRAVERBOSE
-
-    // check if a complete GPS solution set is available for reading
-    //   tinyGPSDatum::age() also includes isValid() test
-    // FIXME
-    if (!((reader.location.age() < GPS_SOL_EXPIRY_MS) &&
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-          (gsafixtype.age() < GPS_SOL_EXPIRY_MS) &&
-#endif
-          (reader.time.age() < GPS_SOL_EXPIRY_MS) && (reader.date.age() < GPS_SOL_EXPIRY_MS))) {
-        LOG_WARN("SOME data is TOO OLD: LOC %u, TIME %u, DATE %u\n", reader.location.age(), reader.time.age(), reader.date.age());
-        return false;
-    }
-
-    // Is this a new point or are we re-reading the previous one?
-    if (!reader.location.isUpdated())
-        return false;
-
-    // We know the solution is fresh and valid, so just read the data
-    auto loc = reader.location.value();
-
-    // Bail out EARLY to avoid overwriting previous good data (like #857)
-    if (toDegInt(loc.lat) > 900000000) {
-#ifdef GPS_EXTRAVERBOSE
-        LOG_DEBUG("Bail out EARLY on LAT %i\n", toDegInt(loc.lat));
-#endif
-        return false;
-    }
-    if (toDegInt(loc.lng) > 1800000000) {
-#ifdef GPS_EXTRAVERBOSE
-        LOG_DEBUG("Bail out EARLY on LNG %i\n", toDegInt(loc.lng));
-#endif
-        return false;
-    }
-
-    p.location_source = meshtastic_Position_LocSource_LOC_INTERNAL;
-
-    // Dilution of precision (an accuracy metric) is reported in 10^2 units, so we need to scale down when we use it
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    p.HDOP = reader.hdop.value();
-    p.PDOP = TinyGPSPlus::parseDecimal(gsapdop.value());
-    // LOG_DEBUG("PDOP=%d, HDOP=%d\n", p.PDOP, p.HDOP);
-#else
-    // FIXME! naive PDOP emulation (assumes VDOP==HDOP)
-    // correct formula is PDOP = SQRT(HDOP^2 + VDOP^2)
-    p.HDOP = reader.hdop.value();
-    p.PDOP = 1.41 * reader.hdop.value();
-#endif
-
-    // Discard incomplete or erroneous readings
-    if (reader.hdop.value() == 0) {
-        LOG_WARN("BOGUS hdop.value() REJECTED: %d\n", reader.hdop.value());
-        return false;
-    }
-
-    p.latitude_i = toDegInt(loc.lat);
-    p.longitude_i = toDegInt(loc.lng);
-
-    p.altitude_geoidal_separation = reader.geoidHeight.meters();
-    p.altitude_hae = reader.altitude.meters() + p.altitude_geoidal_separation;
-    p.altitude = reader.altitude.meters();
-
-    p.fix_quality = fixQual;
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    p.fix_type = fixType;
-#endif
-
-    // positional timestamp
-    struct tm t;
-    t.tm_sec = reader.time.second();
-    t.tm_min = reader.time.minute();
-    t.tm_hour = reader.time.hour();
-    t.tm_mday = reader.date.day();
-    t.tm_mon = reader.date.month() - 1;
-    t.tm_year = reader.date.year() - 1900;
-    t.tm_isdst = false;
-    p.timestamp = mktime(&t);
-
-    // Nice to have, if available
-    if (reader.satellites.isUpdated()) {
-        p.sats_in_view = reader.satellites.value();
-    }
-
-    if (reader.course.isUpdated() && reader.course.isValid()) {
-        if (reader.course.value() < 36000) { // sanity check
-            p.ground_track =
-                reader.course.value() * 1e3; // Scale the heading (in degrees * 10^-2) to match the expected degrees * 10^-5
-        } else {
-            LOG_WARN("BOGUS course.value() REJECTED: %d\n", reader.course.value());
-        }
-    }
-
-    if (reader.speed.isUpdated() && reader.speed.isValid()) {
-        p.ground_speed = reader.speed.kmph();
-    }
-
-    return true;
-}
-
-bool NMEAGPS::hasLock()
-{
-    // Using GPGGA fix quality indicator
-    if (fixQual >= 1 && fixQual <= 5) {
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-        // Use GPGSA fix type 2D/3D (better) if available
-        if (fixType == 3 || fixType == 0) // zero means "no data received"
-#endif
-            return true;
-    }
-
-    return false;
-}
-
-bool NMEAGPS::hasFlow()
-{
-    return reader.passedChecksum() > 0;
-}
-
-bool NMEAGPS::whileIdle()
-{
-    bool isValid = false;
-#ifdef SERIAL_BUFFER_SIZE
-    if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) {
-        LOG_WARN("GPS Buffer full with %u bytes waiting. Flushing to avoid corruption.\n", _serial_gps->available());
-        clearBuffer();
-    }
-#endif
-    // if (_serial_gps->available() > 0)
-    // LOG_DEBUG("GPS Bytes Waiting: %u\n", _serial_gps->available());
-    // First consume any chars that have piled up at the receiver
-    while (_serial_gps->available() > 0) {
-        int c = _serial_gps->read();
-        // LOG_DEBUG("%c", c);
-        isValid |= reader.encode(c);
-    }
-
-    return isValid;
-}

src/gps/NMEAGPS.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include "GPS.h"
-#include "Observer.h"
-#include "TinyGPS++.h"
-
-/**
- * A gps class thatreads from a NMEA GPS stream (and FIXME - eventually keeps the gps powered down except when reading)
- *
- * When new data is available it will notify observers.
- */
-class NMEAGPS : public GPS
-{
-    TinyGPSPlus reader;
-    uint8_t fixQual = 0; // fix quality from GPGGA
-    uint32_t lastChecksumFailCount = 0;
-
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
-    // via optional feature "custom fields", currently disabled (bug #525)
-    TinyGPSCustom gsafixtype; // custom extract fix type from GPGSA
-    TinyGPSCustom gsapdop;    // custom extract PDOP from GPGSA
-    uint8_t fixType = 0;      // fix type from GPGSA
-#endif
-
-  public:
-    virtual bool setupGPS() override;
-
-    virtual bool factoryReset() override;
-
-  protected:
-    /** Subclasses should look for serial rx characters here and feed it to their GPS parser
-     *
-     * Return true if we received a valid message from the GPS
-     */
-    virtual bool whileIdle() override;
-
-    /**
-     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
-     * Override this method to check for new locations
-     *
-     * @return true if we've acquired a time
-     */
-    virtual bool lookForTime() override;
-
-    /**
-     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
-     * Override this method to check for new locations
-     *
-     * @return true if we've acquired a new location
-     */
-    virtual bool lookForLocation() override;
-
-    virtual bool hasLock() override;
-
-    virtual bool hasFlow() override;
-};

src/gps/NMEAWPL.cpp

@@ -1,3 +1,4 @@
+#if !MESHTASTIC_EXCLUDE_GPS
 #include "NMEAWPL.h"
 #include "GeoCoord.h"
 #include "RTC.h"
@@ -74,10 +75,10 @@ uint32_t printWPL(char *buf, size_t bufsz, const meshtastic_Position &pos, const
 uint32_t printGGA(char *buf, size_t bufsz, const meshtastic_Position &pos)
 {
     GeoCoord geoCoord(pos.latitude_i, pos.longitude_i, pos.altitude);
-    tm *t = localtime((time_t *)&pos.timestamp);
+    tm *t = gmtime((time_t *)&pos.timestamp);
     if (getRTCQuality() > 0) { // use the device clock if we got time from somewhere. If not, use the GPS timestamp.
         uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice);
-        t = localtime((time_t *)&rtc_sec);
+        t = gmtime((time_t *)&rtc_sec);
     }
 
     uint32_t len = snprintf(
@@ -93,4 +94,6 @@ uint32_t printGGA(char *buf, size_t bufsz, const meshtastic_Position &pos)
     }
     len += snprintf(buf + len, bufsz - len, "*%02X\r\n", chk);
     return len;
-}
+}
+
+#endif

src/gps/RTC.cpp

@@ -40,7 +40,7 @@ void readFromRTC()
         t.tm_hour = rtc.getHour();
         t.tm_min = rtc.getMinute();
         t.tm_sec = rtc.getSecond();
-        tv.tv_sec = mktime(&t);
+        tv.tv_sec = gm_mktime(&t);
         tv.tv_usec = 0;
         LOG_DEBUG("Read RTC time from RV3028 as %ld\n", tv.tv_sec);
         timeStartMsec = now;
@@ -68,7 +68,7 @@ void readFromRTC()
         t.tm_hour = tc.hour;
         t.tm_min = tc.minute;
         t.tm_sec = tc.second;
-        tv.tv_sec = mktime(&t);
+        tv.tv_sec = gm_mktime(&t);
         tv.tv_usec = 0;
         LOG_DEBUG("Read RTC time from PCF8563 as %ld\n", tv.tv_sec);
         timeStartMsec = now;
@@ -103,9 +103,8 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
 
     bool shouldSet;
     if (q > currentQuality) {
-        currentQuality = q;
         shouldSet = true;
-        LOG_DEBUG("Upgrading time to RTC %ld secs (quality %d)\n", tv->tv_sec, q);
+        LOG_DEBUG("Upgrading time to quality %d\n", q);
     } else if (q == RTCQualityGPS && (now - lastSetMsec) > (12 * 60 * 60 * 1000UL)) {
         // Every 12 hrs we will slam in a new GPS time, to correct for local RTC clock drift
         shouldSet = true;
@@ -114,12 +113,12 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
         shouldSet = false;
 
     if (shouldSet) {
+        currentQuality = q;
         lastSetMsec = now;
 
         // This delta value works on all platforms
         timeStartMsec = now;
         zeroOffsetSecs = tv->tv_sec;
-
         // If this platform has a setable RTC, set it
 #ifdef RV3028_RTC
         if (rtc_found.address == RV3028_RTC) {
@@ -129,7 +128,7 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
 #else
             rtc.initI2C();
 #endif
-            tm *t = localtime(&tv->tv_sec);
+            tm *t = gmtime(&tv->tv_sec);
             rtc.setTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_wday, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
             LOG_DEBUG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                       t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
@@ -143,7 +142,7 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
 #else
             rtc.begin();
 #endif
-            tm *t = localtime(&tv->tv_sec);
+            tm *t = gmtime(&tv->tv_sec);
             rtc.setDateTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
             LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                       t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
@@ -153,7 +152,7 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
 #endif
 
         // nrf52 doesn't have a readable RTC (yet - software not written)
-#ifdef HAS_RTC
+#if HAS_RTC
         readFromRTC();
 #endif
 
@@ -176,7 +175,9 @@ bool perhapsSetRTC(RTCQuality q, struct tm &t)
     The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
     (midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
     */
-    time_t res = mktime(&t);
+    // horrible hack to make mktime TZ agnostic - best practise according to
+    // https://www.gnu.org/software/libc/manual/html_node/Broken_002ddown-Time.html
+    time_t res = gm_mktime(&t);
     struct timeval tv;
     tv.tv_sec = res;
     tv.tv_usec = 0; // time.centisecond() * (10 / 1000);
@@ -190,14 +191,33 @@ bool perhapsSetRTC(RTCQuality q, struct tm &t)
     }
 }
 
+/**
+ * Returns the timezone offset in seconds.
+ *
+ * @return The timezone offset in seconds.
+ */
+int32_t getTZOffset()
+{
+    time_t now;
+    struct tm *gmt;
+    now = time(NULL);
+    gmt = gmtime(&now);
+    gmt->tm_isdst = -1;
+    return (int16_t)difftime(now, mktime(gmt));
+}
+
 /**
  * Returns the current time in seconds since the Unix epoch (January 1, 1970).
  *
  * @return The current time in seconds since the Unix epoch.
  */
-uint32_t getTime()
+uint32_t getTime(bool local)
 {
-    return (((uint32_t)millis() - timeStartMsec) / 1000) + zeroOffsetSecs;
+    if (local) {
+        return (((uint32_t)millis() - timeStartMsec) / 1000) + zeroOffsetSecs + getTZOffset();
+    } else {
+        return (((uint32_t)millis() - timeStartMsec) / 1000) + zeroOffsetSecs;
+    }
 }
 
 /**
@@ -206,7 +226,19 @@ uint32_t getTime()
  * @param minQuality The minimum quality of the RTC time required for it to be considered valid.
  * @return The current time from the RTC if it meets the minimum quality requirement, or 0 if the time is not valid.
  */
-uint32_t getValidTime(RTCQuality minQuality)
+uint32_t getValidTime(RTCQuality minQuality, bool local)
 {
-    return (currentQuality >= minQuality) ? getTime() : 0;
+    return (currentQuality >= minQuality) ? getTime(local) : 0;
+}
+
+time_t gm_mktime(struct tm *tm)
+{
+    setenv("TZ", "GMT0", 1);
+    time_t res = mktime(tm);
+    if (*config.device.tzdef) {
+        setenv("TZ", config.device.tzdef, 1);
+    } else {
+        setenv("TZ", "UTC0", 1);
+    }
+    return res;
 }

src/gps/RTC.h

@@ -29,13 +29,15 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv);
 bool perhapsSetRTC(RTCQuality q, struct tm &t);
 
 /// Return time since 1970 in secs.  While quality is RTCQualityNone we will be returning time based at zero
-uint32_t getTime();
+uint32_t getTime(bool local = false);
 
 /// Return time since 1970 in secs.  If quality is RTCQualityNone return zero
-uint32_t getValidTime(RTCQuality minQuality);
+uint32_t getValidTime(RTCQuality minQuality, bool local = false);
 
 void readFromRTC();
 
+time_t gm_mktime(struct tm *tm);
+
 #define SEC_PER_DAY 86400
 #define SEC_PER_HOUR 3600
 #define SEC_PER_MIN 60

src/gps/cas.h

@@ -0,0 +1,63 @@
+#pragma once
+
+// CASIC binary message definitions
+// Reference: https://www.icofchina.com/d/file/xiazai/2020-09-22/20f1b42b3a11ac52089caf3603b43fb5.pdf
+// ATGM33H-5N: https://www.icofchina.com/pro/mokuai/2016-08-01/4.html
+// (https://www.icofchina.com/d/file/xiazai/2016-12-05/b5c57074f4b1fcc62ba8c7868548d18a.pdf)
+
+// NEMA (Class ID - 0x4e) message IDs
+#define CAS_NEMA_GGA 0x00
+#define CAS_NEMA_GLL 0x01
+#define CAS_NEMA_GSA 0x02
+#define CAS_NEMA_GSV 0x03
+#define CAS_NEMA_RMC 0x04
+#define CAS_NEMA_VTG 0x05
+#define CAS_NEMA_GST 0x07
+#define CAS_NEMA_ZDA 0x08
+#define CAS_NEMA_DHV 0x0D
+
+// Size of a CAS-ACK-(N)ACK message (14 bytes)
+#define CAS_ACK_NACK_MSG_SIZE 0x0E
+
+// CFG-RST (0x06, 0x02)
+// Factory reset
+const uint8_t GPS::_message_CAS_CFG_RST_FACTORY[] = {
+    0xFF, 0x03, // Fields to clear
+    0x01,       // Reset Mode: Controlled Software reset
+    0x03        // Startup Mode: Factory
+};
+
+// CFG_RATE (0x06, 0x01)
+// 1HZ update rate, this should always be the case after
+// factory reset but update it regardless
+const uint8_t GPS::_message_CAS_CFG_RATE_1HZ[] = {
+    0xE8, 0x03, // Update Rate: 0x03E8 = 1000ms
+    0x00, 0x00  // Reserved
+};
+
+// CFG-NAVX (0x06, 0x07)
+// Initial ATGM33H-5N configuration, Updates for Dynamic Mode, Fix Mode, and SV system
+// Qwirk: The ATGM33H-5N-31 should only support GPS+BDS, however it will happily enable
+//  and use GPS+BDS+GLONASS iff the correct CFG_NAVX command is used.
+const uint8_t GPS::_message_CAS_CFG_NAVX_CONF[] = {
+    0x03, 0x01, 0x00, 0x00, // Update Mask: Dynamic Mode, Fix Mode, Nav Settings
+    0x03,                   // Dynamic Mode: Automotive
+    0x03,                   // Fix Mode: Auto 2D/3D
+    0x00,                   // Min SV
+    0x00,                   // Max SVs
+    0x00,                   // Min CNO
+    0x00,                   // Reserved1
+    0x00,                   // Init 3D fix
+    0x00,                   // Min Elevation
+    0x00,                   // Dr Limit
+    0x07,                   // Nav System: 2^0 = GPS, 2^1 = BDS 2^2 = GLONASS: 2^3
+                            // 3=GPS+BDS, 7=GPS+BDS+GLONASS
+    0x00, 0x00,             // Rollover Week
+    0x00, 0x00, 0x00, 0x00, // Fix Altitude
+    0x00, 0x00, 0x00, 0x00, // Fix Height Error
+    0x00, 0x00, 0x00, 0x00, // PDOP Maximum
+    0x00, 0x00, 0x00, 0x00, // TDOP Maximum
+    0x00, 0x00, 0x00, 0x00, // Position Accuracy Max
+    0x00, 0x00, 0x00, 0x00, // Time Accuracy Max
+    0x00, 0x00, 0x00, 0x00  // Static Hold Threshold
+};

src/gps/ubx.h

@@ -0,0 +1,453 @@
+// Power Management
+
+uint8_t GPS::_message_PMREQ[] PROGMEM = {
+    0x00, 0x00, 0x00, 0x00, // 4 bytes duration of request task (milliseconds)
+    0x02, 0x00, 0x00, 0x00  // Bitfield, set backup = 1
+};
+
+uint8_t GPS::_message_PMREQ_10[] PROGMEM = {
+    0x00,                   // version (0 for this version)
+    0x00, 0x00, 0x00,       // Reserved 1
+    0x00, 0x00, 0x00, 0x00, // 4 bytes duration of request task (milliseconds)
+    0x06, 0x00, 0x00, 0x00, // Bitfield, set backup =1 and force =1
+    0x08, 0x00, 0x00, 0x00  // wakeupSources Wake on uartrx
+};
+
+const uint8_t GPS::_message_CFG_RXM_PSM[] PROGMEM = {
+    0x08, // Reserved
+    0x01  // Power save mode
+};
+
+// only for Neo-6
+const uint8_t GPS::_message_CFG_RXM_ECO[] PROGMEM = {
+    0x08, // Reserved
+    0x04  // eco mode
+};
+
+const uint8_t GPS::_message_CFG_PM2[] PROGMEM = {
+    0x01,                   // version
+    0x00,                   // Reserved 1, set to 0x06 by u-Center
+    0x00,                   // Reserved 2
+    0x00,                   // Reserved 1
+    0x00, 0x11, 0x03, 0x00, // flags-> cyclic mode, wait for normal fix ok, do not wake to update RTC, doNotEnterOff,
+                            // LimitPeakCurrent
+    0xE8, 0x03, 0x00, 0x00, // update period 1000 ms
+    0x10, 0x27, 0x00, 0x00, // search period 10s
+    0x00, 0x00, 0x00, 0x00, // Grid offset 0
+    0x01, 0x00,             // onTime 1 second
+    0x00, 0x00,             // min search time 0
+    0x00, 0x00,             // 0x2C, 0x01,  // reserved 4
+    0x00, 0x00,             // 0x00, 0x00,  // reserved 5
+    0x00, 0x00, 0x00, 0x00, // 0x4F, 0xC1, 0x03, 0x00, // reserved 6
+    0x00, 0x00, 0x00, 0x00, // 0x87, 0x02, 0x00, 0x00, // reserved 7
+    0x00,                   // 0xFF,        // reserved 8
+    0x00,                   // 0x00,        // reserved 9
+    0x00, 0x00,             // 0x00, 0x00,  // reserved 10
+    0x00, 0x00, 0x00, 0x00  // 0x64, 0x40, 0x01, 0x00  // reserved 11
+};
+
+// Constallation setup, none required for Neo-6
+
+// For Neo-7 GPS & SBAS
+const uint8_t GPS::_message_GNSS_7[] = {
+    0x00, // msgVer (0 for this version)
+    0x00, // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+    0xff, // numTrkChUse (max number of channels to use, 0xff = max available)
+    0x02, // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
+    // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+    0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x00, 0x01, // GPS
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x01  // SBAS
+};
+
+// It's not critical if the module doesn't acknowledge this configuration.
+// The module should operate adequately with its factory or previously saved settings.
+// It appears that there is a firmware bug in some GPS modules: When an attempt is made
+// to overwrite a saved state with identical values, no ACK/NAK is received, contrary to
+// what is specified in the Ublox documentation.
+// There is also a possibility that the module may be GPS-only.
+
+// For M8 GPS, GLONASS, Galileo, SBAS, QZSS
+const uint8_t GPS::_message_GNSS_8[] = {
+    0x00,                                           // msgVer (0 for this version)
+    0x00,                                           // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+    0xff,                                           // numTrkChUse (max number of channels to use, 0xff = max available)
+    0x05,                                           // numConfigBlocks (number of GNSS systems)
+                                                    // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+    0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, // GPS
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // SBAS
+    0x02, 0x04, 0x08, 0x00, 0x01, 0x00, 0x01, 0x01, // Galileo
+    0x05, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // QZSS
+    0x06, 0x08, 0x0E, 0x00, 0x01, 0x00, 0x01, 0x01  // GLONASS
+};
+/*
+// For M8 GPS, GLONASS, BeiDou, SBAS, QZSS
+const uint8_t GPS::_message_GNSS_8_B[] = {
+ 0x00, // msgVer (0 for this version)
+ 0x00, // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+ 0xff, // numTrkChUse (max number of channels to use, 0xff = max available) read only for protocol >23
+ 0x05, // numConfigBlocks (number of GNSS systems)
+       // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+ 0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, // GPS
+ 0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // SBAS
+ 0x03, 0x08, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, // BeiDou
+ 0x05, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // QZSS
+ 0x06, 0x08, 0x0E, 0x00, 0x01, 0x00, 0x01, 0x01  // GLONASS
+};
+*/
+
+// For M8 we want to enable NMEA version 4.10 messages to allow for Galileo and or BeiDou
+const uint8_t GPS::_message_NMEA[]{
+    0x00,                              // filter flags
+    0x41,                              // NMEA Version
+    0x00,                              // Max number of SVs to report per TaklerId
+    0x02,                              // flags
+    0x00, 0x00, 0x00, 0x00,            // gnssToFilter
+    0x00,                              // svNumbering
+    0x00,                              // mainTalkerId
+    0x00,                              // gsvTalkerId
+    0x01,                              // Message version
+    0x00, 0x00,                        // bdsTalkerId 2 chars 0=default
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Reserved
+};
+// Enable jamming/interference monitor
+
+// For Neo-6, Max-7 and Neo-7
+const uint8_t GPS::_message_JAM_6_7[] = {
+    0xf3, 0xac, 0x62, 0xad, // config1 bbThreshold = 3, cwThreshold = 15, enable = 1, reserved bits 0x16B156
+    0x1e, 0x03, 0x00, 0x00  // config2 antennaSetting Unknown = 0, reserved 3, = 0x00,0x00, reserved 2 = 0x31E
+};
+
+// For M8
+const uint8_t GPS::_message_JAM_8[] = {
+    0xf3, 0xac, 0x62, 0xad, // config1 bbThreshold = 3, cwThreshold = 15, enable1 = 1, reserved bits 0x16B156
+    0x1e, 0x43, 0x00, 0x00  // config2 antennaSetting Unknown = 0, enable2 = 1, generalBits = 0x31E
+};
+
+// Configure navigation engine expert settings:
+// there are many variations of what were Reserved fields for the Neo-6 in later versions
+// ToDo: check UBX-MON-VER for module type and protocol version
+
+// For the Neo-6
+const uint8_t GPS::_message_NAVX5[] = {
+    0x00, 0x00,             // msgVer (0 for this version)
+    0x4c, 0x66,             // mask1
+    0x00, 0x00, 0x00, 0x00, // Reserved 0
+    0x00,                   // Reserved 1
+    0x00,                   // Reserved 2
+    0x03,                   // minSVs (Minimum number of satellites for navigation) = 3
+    0x10,                   // maxSVs (Maximum number of satellites for navigation) = 16
+    0x06,                   // minCNO (Minimum satellite signal level for navigation) = 6 dBHz
+    0x00,                   // Reserved 5
+    0x00,                   // iniFix3D (Initial fix must be 3D) (0 = false 1 = true)
+    0x00,                   // Reserved 6
+    0x00,                   // Reserved 7
+    0x00,                   // Reserved 8
+    0x00, 0x00,             // wknRollover 0 = firmware default
+    0x00, 0x00, 0x00, 0x00, // Reserved 9
+    0x00,                   // Reserved 10
+    0x00,                   // Reserved 11
+    0x00,                   // usePPP (Precice Point Positioning) (0 = false, 1 = true)
+    0x01,                   // useAOP  (AssistNow Autonomous configuration) = 1 (enabled)
+    0x00,                   // Reserved 12
+    0x00,                   // Reserved 13
+    0x00, 0x00,             // aopOrbMaxErr = 0 to reset to firmware default
+    0x00,                   // Reserved 14
+    0x00,                   // Reserved 15
+    0x00, 0x00,             // Reserved 3
+    0x00, 0x00, 0x00, 0x00  // Reserved 4
+};
+// For the M8
+const uint8_t GPS::_message_NAVX5_8[] = {
+    0x02, 0x00,             // msgVer (2 for this version)
+    0x4c, 0x66,             // mask1
+    0x00, 0x00, 0x00, 0x00, // mask2
+    0x00, 0x00,             // Reserved 1
+    0x03,                   // minSVs (Minimum number of satellites for navigation) = 3
+    0x10,                   // maxSVs (Maximum number of satellites for navigation) = 16
+    0x06,                   // minCNO (Minimum satellite signal level for navigation) = 6 dBHz
+    0x00,                   // Reserved 2
+    0x00,                   // iniFix3D (Initial fix must be 3D) (0 = false 1 = true)
+    0x00, 0x00,             // Reserved 3
+    0x00,                   // ackAiding
+    0x00, 0x00,             // wknRollover 0 = firmware default
+    0x00,                   // sigAttenCompMode
+    0x00,                   // Reserved 4
+    0x00, 0x00,             // Reserved 5
+    0x00, 0x00,             // Reserved 6
+    0x00,                   // usePPP (Precice Point Positioning) (0 = false, 1 = true)
+    0x01,                   // aopCfg  (AssistNow Autonomous configuration) = 1 (enabled)
+    0x00, 0x00,             // Reserved 7
+    0x00, 0x00,             // aopOrbMaxErr = 0 to reset to firmware default
+    0x00, 0x00, 0x00, 0x00, // Reserved 8
+    0x00, 0x00, 0x00,       // Reserved 9
+    0x00                    // useAdr
+};
+
+// Set GPS update rate to 1Hz
+// Lowering the update rate helps to save power.
+// Additionally, for some new modules like the M9/M10, an update rate lower than 5Hz
+// is recommended to avoid a known issue with satellites disappearing.
+// The module defaults for M8, M9, M10 are the same as we use here so no update is necessary
+const uint8_t GPS::_message_1HZ[] = {
+    0xE8, 0x03, // Measurement Rate (1000ms for 1Hz)
+    0x01, 0x00, // Navigation rate, always 1 in GPS mode
+    0x01, 0x00  // Time reference
+};
+
+// Disable GLL. GLL - Geographic position (latitude and longitude), which provides the current geographical
+// coordinates.
+const uint8_t GPS::_message_GLL[] = {
+    0xF0, 0x01, // NMEA ID for GLL
+    0x00,       // Rate for DDC
+    0x00,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x00,       // Rate for USB
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Enable GSA. GSA - GPS DOP and active satellites, used for detailing the satellites used in the positioning and
+// the DOP (Dilution of Precision)
+const uint8_t GPS::_message_GSA[] = {
+    0xF0, 0x02, // NMEA ID for GSA
+    0x00,       // Rate for DDC
+    0x01,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x01,       // Rate for USB usefull for native linux
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Disable GSV. GSV - Satellites in view, details the number and location of satellites in view.
+const uint8_t GPS::_message_GSV[] = {
+    0xF0, 0x03, // NMEA ID for GSV
+    0x00,       // Rate for DDC
+    0x00,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x00,       // Rate for USB
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Disable VTG. VTG - Track made good and ground speed, which provides course and speed information relative to
+// the ground.
+const uint8_t GPS::_message_VTG[] = {
+    0xF0, 0x05, // NMEA ID for VTG
+    0x00,       // Rate for DDC
+    0x00,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x00,       // Rate for USB
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Enable RMC. RMC - Recommended Minimum data, the essential gps pvt (position, velocity, time) data.
+const uint8_t GPS::_message_RMC[] = {
+    0xF0, 0x04, // NMEA ID for RMC
+    0x00,       // Rate for DDC
+    0x01,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x01,       // Rate for USB usefull for native linux
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Enable GGA. GGA - Global Positioning System Fix Data, which provides 3D location and accuracy data.
+const uint8_t GPS::_message_GGA[] = {
+    0xF0, 0x00, // NMEA ID for GGA
+    0x00,       // Rate for DDC
+    0x01,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x01,       // Rate for USB, usefull for native linux
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Disable UBX-AID-ALPSRV as it may confuse TinyGPS. The Neo-6 seems to send this message
+// whether the AID Autonomous is enabled or not
+const uint8_t GPS::_message_AID[] = {
+    0x0B, 0x32, // NMEA ID for UBX-AID-ALPSRV
+    0x00,       // Rate for DDC
+    0x00,       // Rate for UART1
+    0x00,       // Rate for UART2
+    0x00,       // Rate for USB
+    0x00,       // Rate for SPI
+    0x00        // Reserved
+};
+
+// Turn off TEXT INFO Messages for all but M10 series
+
+// B5 62 06 02 0A 00 01 00 00 00 03 03 00 03 03 00 1F 20
+const uint8_t GPS::_message_DISABLE_TXT_INFO[] = {
+    0x01,             // Protocol ID for NMEA
+    0x00, 0x00, 0x00, // Reserved
+    0x03,             // I2C
+    0x03,             // I/O Port 1
+    0x00,             // I/O Port 2
+    0x03,             // USB
+    0x03,             // SPI
+    0x00              // Reserved
+};
+
+// The Power Management configuration allows the GPS module to operate in different power modes for optimized
+// power consumption. The modes supported are: 0x00 = Full power: The module operates at full power with no power
+// saving. 0x01 = Balanced: The module dynamically adjusts the tracking behavior to balance power consumption.
+// 0x02 = Interval: The module operates in a periodic mode, cycling between tracking and power saving states.
+// 0x03 = Aggressive with 1 Hz: The module operates in a power saving mode with a 1 Hz update rate.
+// 0x04 = Aggressive with 2 Hz: The module operates in a power saving mode with a 2 Hz update rate.
+// 0x05 = Aggressive with 4 Hz: The module operates in a power saving mode with a 4 Hz update rate.
+// The 'period' field specifies the position update and search period. It is only valid when the powerSetupValue
+// is set to Interval; otherwise, it must be set to '0'. The 'onTime' field specifies the duration of the ON phase
+// and must be smaller than the period. It is only valid when the powerSetupValue is set to Interval; otherwise,
+// it must be set to '0'.
+// This command applies to M8 products
+const uint8_t GPS::_message_PMS[] = {
+    0x00,       // Version (0)
+    0x03,       // Power setup value 3 = Agresssive 1Hz
+    0x00, 0x00, // period: not applicable, set to 0
+    0x00, 0x00, // onTime: not applicable, set to 0
+    0x00, 0x00  // reserved, generated by u-center
+};
+
+const uint8_t GPS::_message_SAVE[] = {
+    0x00, 0x00, 0x00, 0x00, // clearMask: no sections cleared
+    0xFF, 0xFF, 0x00, 0x00, // saveMask: save all sections
+    0x00, 0x00, 0x00, 0x00, // loadMask: no sections loaded
+    0x17                    // deviceMask: BBR, Flash, EEPROM, and SPI Flash
+};
+
+// As the M10 has no flash, the best we can do to preserve the config is to set it in RAM and BBR.
+// BBR will survive a restart, and power off for a while, but modules with small backup
+// batteries or super caps will not retain the config for a long power off time.
+
+// VALSET Commands for M10
+// Please refer to the M10 Protocol Specification:
+// https://content.u-blox.com/sites/default/files/u-blox-M10-SPG-5.10_InterfaceDescription_UBX-21035062.pdf
+// Where the VALSET/VALGET/VALDEL commands are described in detail.
+// and:
+// https://content.u-blox.com/sites/default/files/u-blox-M10-ROM-5.10_ReleaseNotes_UBX-22001426.pdf
+// for interesting insights.
+/*
+CFG-PM2 has been replaced by many CFG-PM commands
+OPERATEMODE E1 2 (0 | 1 | 2)
+POSUPDATEPERIOD U4 1000ms for M10 must be >= 5s try 5
+ACQPERIOD U4 10 seems ok for M10 def ok
+GRIDOFFSET U4 0 seems ok for M10 def ok
+ONTIME U2 1 will try 1
+MINACQTIME U1 0 will try 0 def ok
+MAXACQTIME U1 stick with default of 0 def ok
+DONOTENTEROFF L 1 stay at 1
+WAITTIMEFIX  L 1 stay with 1
+UPDATEEPH L 1 changed to 1 for gps rework default is 1
+EXTINTWAKE L 0 no ext ints
+EXTINTBACKUP L 0 no ext ints
+EXTINTINACTIVE L 0 no ext ints
+EXTINTACTIVITY U4 0 no ext ints
+LIMITPEAKCURRENT L 1 stay with 1
+*/
+// CFG-PMS has been removed
+
+// Ram layer config message:
+// b5 62 06 8a 26 00 00 01 00 00 01 00 d0 20 02 02 00 d0 40 05 00 00 00 05 00 d0 30 01 00 08 00 d0 10 01 09 00 d0 10 01 10 00 d0
+// 10 01 8b de
+
+// BBR layer config message:
+// b5 62 06 8a 26 00 00 02 00 00 01 00 d0 20 02 02 00 d0 40 05 00 00 00 05 00 d0 30 01 00 08 00 d0 10 01 09 00 d0 10 01 10 00 d0
+// 10 01 8c 03
+
+const uint8_t GPS::_message_VALSET_PM_RAM[] = {0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0xd0, 0x20, 0x02, 0x02, 0x00, 0xd0, 0x40,
+                                               0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0xd0, 0x30, 0x01, 0x00, 0x08, 0x00, 0xd0,
+                                               0x10, 0x01, 0x09, 0x00, 0xd0, 0x10, 0x01, 0x10, 0x00, 0xd0, 0x10, 0x01};
+const uint8_t GPS::_message_VALSET_PM_BBR[] = {0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0xd0, 0x20, 0x02, 0x02, 0x00, 0xd0, 0x40,
+                                               0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0xd0, 0x30, 0x01, 0x00, 0x08, 0x00, 0xd0,
+                                               0x10, 0x01, 0x09, 0x00, 0xd0, 0x10, 0x01, 0x10, 0x00, 0xd0, 0x10, 0x01};
+
+/*
+CFG-ITFM replaced by 5 valset messages which can be combined into one for RAM and one for BBR
+
+20410001 bbthreshold U1 3
+20410002 cwthreshold U1 15
+1041000d enable L        0 -> 1
+20410010 ant E1          0
+10410013 enable aux L    0 -> 1
+
+
+b5 62 06 8a 0e 00 00 01 00 00 0d 00 41 10 01 13 00 41 10 01 63 c6
+*/
+const uint8_t GPS::_message_VALSET_ITFM_RAM[] = {0x00, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x41,
+                                                 0x10, 0x01, 0x13, 0x00, 0x41, 0x10, 0x01};
+const uint8_t GPS::_message_VALSET_ITFM_BBR[] = {0x00, 0x02, 0x00, 0x00, 0x0d, 0x00, 0x41,
+                                                 0x10, 0x01, 0x13, 0x00, 0x41, 0x10, 0x01};
+
+// Turn off all NMEA messages:
+// Ram layer config message:
+// b5 62 06 8a 22 00 00 01 00 00 c0 00 91 20 00 ca 00 91 20 00 c5 00 91 20 00 ac 00 91 20 00 b1 00 91 20 00 bb 00 91 20 00 40 8f
+
+// Disable GLL, GSV, VTG messages in BBR layer
+// BBR layer config message:
+// b5 62 06 8a 13 00 00 02 00 00 ca 00 91 20 00 c5 00 91 20 00 b1 00 91 20 00 f8 4e
+
+const uint8_t GPS::_message_VALSET_DISABLE_NMEA_RAM[] = {
+    /*0x00, 0x01, 0x00, 0x00, 0xca, 0x00, 0x91, 0x20, 0x00, 0xc5, 0x00, 0x91, 0x20, 0x00, 0xb1, 0x00, 0x91, 0x20, 0x00 */
+    0x00, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x91, 0x20, 0x00, 0xca, 0x00, 0x91, 0x20, 0x00, 0xc5, 0x00, 0x91,
+    0x20, 0x00, 0xac, 0x00, 0x91, 0x20, 0x00, 0xb1, 0x00, 0x91, 0x20, 0x00, 0xbb, 0x00, 0x91, 0x20, 0x00};
+
+const uint8_t GPS::_message_VALSET_DISABLE_NMEA_BBR[] = {0x00, 0x02, 0x00, 0x00, 0xca, 0x00, 0x91, 0x20, 0x00, 0xc5,
+                                                         0x00, 0x91, 0x20, 0x00, 0xb1, 0x00, 0x91, 0x20, 0x00};
+
+// Turn off text info messages:
+// Ram layer config message:
+// b5 62 06 8a 09 00 00 01 00 00 07 00 92 20 06 59 50
+
+// BBR layer config message:
+// b5 62 06 8a 09 00 00 02 00 00 07 00 92 20 06 5a 58
+
+// Turn NMEA GSA, GGA, RMC messages on:
+// Ram layer config message:
+// b5 62 06 8a 13 00 00 01 00 00 c0 00 91 20 01 bb 00 91 20 01 ac 00 91 20 01 e1 3b
+
+// BBR layer config message:
+// b5 62 06 8a 13 00 00 02 00 00 c0 00 91 20 01 bb 00 91 20 01 ac 00 91 20 01 e2 4d
+
+const uint8_t GPS::_message_VALSET_DISABLE_TXT_INFO_RAM[] = {0x00, 0x01, 0x00, 0x00, 0x07, 0x00, 0x92, 0x20, 0x03};
+const uint8_t GPS::_message_VALSET_DISABLE_TXT_INFO_BBR[] = {0x00, 0x02, 0x00, 0x00, 0x07, 0x00, 0x92, 0x20, 0x03};
+const uint8_t GPS::_message_VALSET_ENABLE_NMEA_RAM[] = {0x00, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x91, 0x20, 0x01, 0xbb,
+                                                        0x00, 0x91, 0x20, 0x01, 0xac, 0x00, 0x91, 0x20, 0x01};
+const uint8_t GPS::_message_VALSET_ENABLE_NMEA_BBR[] = {0x00, 0x02, 0x00, 0x00, 0xc0, 0x00, 0x91, 0x20, 0x01, 0xbb,
+                                                        0x00, 0x91, 0x20, 0x01, 0xac, 0x00, 0x91, 0x20, 0x01};
+const uint8_t GPS::_message_VALSET_DISABLE_SBAS_RAM[] = {0x00, 0x01, 0x00, 0x00, 0x20, 0x00, 0x31,
+                                                         0x10, 0x00, 0x05, 0x00, 0x31, 0x10, 0x00};
+const uint8_t GPS::_message_VALSET_DISABLE_SBAS_BBR[] = {0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x31,
+                                                         0x10, 0x00, 0x05, 0x00, 0x31, 0x10, 0x00};
+/*
+Operational issues with the M10:
+
+PowerSave doesn't work with SBAS, seems like you can have SBAS enabled, but it will never lock
+onto the SBAS sats.
+PowerSave doesn't work with BDS B1C, u-blox says use B1l instead.
+BDS B1l cannot be enabled with BDS B1C or GLONASS L1OF, so GLONASS will work with B1C, but not B1l
+So no powersave with GLONASS and BDS B1l enabled.
+So disable GLONASS and use BDS B1l, which is part of the default M10 config.
+
+GNSS configuration:
+
+Default GNSS configuration is: GPS, Galileo, BDS B1l, with QZSS and SBAS enabled.
+The PMREQ puts the receiver to sleep and wakeup re-acquires really fast and seems to not need
+the PM config. Lets try without it.
+PMREQ sort of works with SBAS, but the awake time is too short to re-acquire any SBAS sats.
+The defination of "Got Fix" doesn't seem to include SBAS. Much more too this...
+Even if it was, it can take minutes (up to 12.5),
+even under good sat visability conditions to re-acquire the SBAS data.
+
+Another effect fo the quick transition to sleep is that no other sats will be acquired so the
+sat count will tend to remain at what the initial fix was.
+*/
+
+// GNSS disable SBAS as recommended by u-blox if using GNSS defaults and power save mode
+/*
+Ram layer config message:
+b5 62 06 8a 0e 00 00 01 00 00 20 00 31 10 00 05 00 31 10 00 46 87
+
+BBR layer config message:
+b5 62 06 8a 0e 00 00 02 00 00 20 00 31 10 00 05 00 31 10 00 47 94
+*/

src/graphics/EInkDisplay2.cpp

@@ -2,105 +2,49 @@
 
 #ifdef USE_EINK
 #include "EInkDisplay2.h"
-#include "GxEPD2_BW.h"
 #include "SPILock.h"
 #include "main.h"
 #include <SPI.h>
 
-// #ifdef HELTEC_WIRELESS_PAPER
-// SPIClass *hspi = NULL;
-// #endif
+/*
+    The macros EINK_DISPLAY_MODEL, EINK_WIDTH, and EINK_HEIGHT are defined as build_flags in a variant's platformio.ini
+    Previously, these macros were defined at the top of this file.
 
-#define COLORED GxEPD_BLACK
-#define UNCOLORED GxEPD_WHITE
+    For archival reasons, note that the following configurations had also been tested during this period:
+    * ifdef RAK4631
+        - 4.2 inch
+          EINK_DISPLAY_MODEL: GxEPD2_420_M01
+          EINK_WIDTH: 300
+          EINK_WIDTH: 400
 
-#if defined(TTGO_T_ECHO)
-#define TECHO_DISPLAY_MODEL GxEPD2_154_D67
-#elif defined(RAK4630)
+        - 2.9 inch
+          EINK_DISPLAY_MODEL: GxEPD2_290_T5D
+          EINK_WIDTH: 296
+          EINK_HEIGHT: 128
 
-// GxEPD2_213_BN - RAK14000 2.13 inch b/w 250x122 - changed from GxEPD2_213_B74 - which was not going to give partial update
-// support
-#define TECHO_DISPLAY_MODEL GxEPD2_213_BN
-
-// 4.2 inch 300x400 - GxEPD2_420_M01
-// #define TECHO_DISPLAY_MODEL GxEPD2_420_M01
-
-// 2.9 inch 296x128 - GxEPD2_290_T5D
-// #define TECHO_DISPLAY_MODEL GxEPD2_290_T5D
-
-// 1.54 inch 200x200 - GxEPD2_154_M09
-// #define TECHO_DISPLAY_MODEL GxEPD2_154_M09
-
-#elif defined(MAKERPYTHON)
-// 2.9 inch 296x128 - GxEPD2_290_T5D
-#define TECHO_DISPLAY_MODEL GxEPD2_290_T5D
-
-#elif defined(PCA10059)
-
-// 4.2 inch 300x400 - GxEPD2_420_M01
-#define TECHO_DISPLAY_MODEL GxEPD2_420_M01
-
-#elif defined(M5_COREINK)
-// M5Stack CoreInk
-// 1.54 inch 200x200 - GxEPD2_154_M09
-#define TECHO_DISPLAY_MODEL GxEPD2_154_M09
-
-#elif defined(HELTEC_WIRELESS_PAPER)
-//#define TECHO_DISPLAY_MODEL GxEPD2_213_T5D
-#define TECHO_DISPLAY_MODEL GxEPD2_213_BN
-#endif
-
-GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT> *adafruitDisplay;
+        - 1.54 inch
+          EINK_DISPLAY_MODEL: GxEPD2_154_M09
+          EINK_WIDTH: 200
+          EINK_HEIGHT: 200
+*/
 
+// Constructor
 EInkDisplay::EInkDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus)
 {
-#if defined(TTGO_T_ECHO)
-    setGeometry(GEOMETRY_RAWMODE, TECHO_DISPLAY_MODEL::WIDTH, TECHO_DISPLAY_MODEL::HEIGHT);
-#elif defined(RAK4630)
+    // Set dimensions in OLEDDisplay base class
+    this->geometry = GEOMETRY_RAWMODE;
+    this->displayWidth = EINK_WIDTH;
+    this->displayHeight = EINK_HEIGHT;
 
-    // GxEPD2_213_BN - RAK14000 2.13 inch b/w 250x122
-    setGeometry(GEOMETRY_RAWMODE, 250, 122);
+    // Round shortest side up to nearest byte, to prevent truncation causing an undersized buffer
+    uint16_t shortSide = min(EINK_WIDTH, EINK_HEIGHT);
+    uint16_t longSide = max(EINK_WIDTH, EINK_HEIGHT);
+    if (shortSide % 8 != 0)
+        shortSide = (shortSide | 7) + 1;
 
-    // GxEPD2_420_M01
-    // setGeometry(GEOMETRY_RAWMODE, 300, 400);
-
-    // GxEPD2_290_T5D
-    // setGeometry(GEOMETRY_RAWMODE, 296, 128);
-
-    // GxEPD2_154_M09
-    // setGeometry(GEOMETRY_RAWMODE, 200, 200);
-
-#elif defined(HELTEC_WIRELESS_PAPER)
-    // setGeometry(GEOMETRY_RAWMODE, 212, 104);
-    setGeometry(GEOMETRY_RAWMODE, 250, 122);
-#elif defined(MAKERPYTHON)
-    // GxEPD2_290_T5D
-    setGeometry(GEOMETRY_RAWMODE, 296, 128);
-
-#elif defined(PCA10059)
-
-    // GxEPD2_420_M01
-    setGeometry(GEOMETRY_RAWMODE, 300, 400);
-
-#elif defined(M5_COREINK)
-
-    // M5Stack_CoreInk 200x200
-    // 1.54 inch 200x200 - GxEPD2_154_M09
-    setGeometry(GEOMETRY_RAWMODE, EPD_HEIGHT, EPD_WIDTH);
-#elif defined(my)
-
-    // GxEPD2_290_T5D
-    setGeometry(GEOMETRY_RAWMODE, 296, 128);
-    LOG_DEBUG("GEOMETRY_RAWMODE, 296, 128\n");
-
-#endif
-    // setGeometry(GEOMETRY_RAWMODE, 128, 64); // old resolution
-    // setGeometry(GEOMETRY_128_64); // We originally used this because I wasn't sure if rawmode worked - it does
+    this->displayBufferSize = longSide * (shortSide / 8);
 }
 
-// FIXME quick hack to limit drawing to a very slow rate
-uint32_t lastDrawMsec;
-
 /**
  * Force a display update if we haven't drawn within the specified msecLimit
  */
@@ -112,57 +56,37 @@ bool EInkDisplay::forceDisplay(uint32_t msecLimit)
     uint32_t now = millis();
     uint32_t sinceLast = now - lastDrawMsec;
 
-    if (adafruitDisplay && (sinceLast > msecLimit || lastDrawMsec == 0)) {
+    if (adafruitDisplay && (sinceLast > msecLimit || lastDrawMsec == 0))
         lastDrawMsec = now;
-
-        // FIXME - only draw bits have changed (use backbuf similar to the other displays)
-        // tft.drawBitmap(0, 0, buffer, 128, 64, TFT_YELLOW, TFT_BLACK);
-        for (uint32_t y = 0; y < displayHeight; y++) {
-            for (uint32_t x = 0; x < displayWidth; x++) {
-
-                // get src pixel in the page based ordering the OLED lib uses FIXME, super inefficient
-                auto b = buffer[x + (y / 8) * displayWidth];
-                auto isset = b & (1 << (y & 7));
-                adafruitDisplay->drawPixel(x, y, isset ? COLORED : UNCOLORED);
-            }
-        }
-
-        LOG_DEBUG("Updating E-Paper... ");
-
-#if defined(TTGO_T_ECHO)
-        // ePaper.Reset(); // wake the screen from sleep
-        adafruitDisplay->display(false); // FIXME, use partial update mode
-#elif defined(RAK4630) || defined(MAKERPYTHON)
-
-        // RAK14000 2.13 inch b/w 250x122 actually now does support partial updates
-
-        // Full update mode (slow)
-        // adafruitDisplay->display(false); // FIXME, use partial update mode
-
-        // Only enable for e-Paper with support for partial updates and comment out above adafruitDisplay->display(false);
-        //  1.54 inch 200x200 - GxEPD2_154_M09
-        //  2.13 inch 250x122 - GxEPD2_213_BN
-        //  2.9 inch 296x128 - GxEPD2_290_T5D
-        //  4.2 inch 300x400 - GxEPD2_420_M01
-        adafruitDisplay->nextPage();
-
-#elif defined(PCA10059) || defined(M5_COREINK)
-        adafruitDisplay->nextPage();
-
-#elif defined(PRIVATE_HW) || defined(my)
-        adafruitDisplay->nextPage();
-
-#endif
-
-        // Put screen to sleep to save power (possibly not necessary because we already did poweroff inside of display)
-        adafruitDisplay->hibernate();
-        LOG_DEBUG("done\n");
-
-        return true;
-    } else {
-        // LOG_DEBUG("Skipping eink display\n");
+    else
         return false;
+
+    // FIXME - only draw bits have changed (use backbuf similar to the other displays)
+    for (uint32_t y = 0; y < displayHeight; y++) {
+        for (uint32_t x = 0; x < displayWidth; x++) {
+            // get src pixel in the page based ordering the OLED lib uses FIXME, super inefficient
+            auto b = buffer[x + (y / 8) * displayWidth];
+            auto isset = b & (1 << (y & 7));
+            adafruitDisplay->drawPixel(x, y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+        }
     }
+
+    // Trigger the refresh in GxEPD2
+    LOG_DEBUG("Updating E-Paper... ");
+    adafruitDisplay->nextPage();
+
+    // End the update process
+    endUpdate();
+
+    LOG_DEBUG("done\n");
+    return true;
+}
+
+// End the update process - virtual method, overriden in derived class
+void EInkDisplay::endUpdate()
+{
+    // Power off display hardware, then deep-sleep (Except Wireless Paper V1.1, no deep-sleep)
+    adafruitDisplay->hibernate();
 }
 
 // Write the buffer to the display memory
@@ -171,8 +95,10 @@ void EInkDisplay::display(void)
     // We don't allow regular 'dumb' display() calls to draw on eink until we've shown
     // at least one forceDisplay() keyframe.  This prevents flashing when we should the critical
     // bootscreen (that we want to look nice)
-    if (lastDrawMsec)
+
+    if (lastDrawMsec) {
         forceDisplay(slowUpdateMsec); // Show the first screen a few seconds after boot, then slower
+    }
 }
 
 // Send a command to the display (low level function)
@@ -187,87 +113,83 @@ void EInkDisplay::setDetected(uint8_t detected)
     (void)detected;
 }
 
-// Connect to the display
+// Connect to the display - variant specific
 bool EInkDisplay::connect()
 {
     LOG_INFO("Doing EInk init\n");
 
-#ifdef PIN_EINK_PWR_ON
-    digitalWrite(PIN_EINK_PWR_ON, HIGH); // If we need to assert a pin to power external peripherals
-    pinMode(PIN_EINK_PWR_ON, OUTPUT);
-#endif
-
 #ifdef PIN_EINK_EN
     // backlight power, HIGH is backlight on, LOW is off
-    digitalWrite(PIN_EINK_EN, LOW);
     pinMode(PIN_EINK_EN, OUTPUT);
+    digitalWrite(PIN_EINK_EN, LOW);
 #endif
 
 #if defined(TTGO_T_ECHO)
     {
-        auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, SPI1);
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, SPI1);
 
-        adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
         adafruitDisplay->init();
         adafruitDisplay->setRotation(3);
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
     }
 #elif defined(RAK4630) || defined(MAKERPYTHON)
     {
         if (eink_found) {
-            auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
-
-            adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
-
+            auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+            adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
             adafruitDisplay->init(115200, true, 10, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
-
-            // RAK14000 2.13 inch b/w 250x122 does actually now support partial updates
+            // RAK14000 2.13 inch b/w 250x122 does actually now support fast refresh
             adafruitDisplay->setRotation(3);
-            // Partial update support for  1.54, 2.13 RAK14000 b/w , 2.9 and 4.2
+            // Fast refresh support for  1.54, 2.13 RAK14000 b/w , 2.9 and 4.2
             // adafruitDisplay->setRotation(1);
             adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
         } else {
             (void)adafruitDisplay;
         }
     }
-#elif defined(HELTEC_WIRELESS_PAPER)
+
+#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER)
     {
-        auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
-        adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
-        // hspi = new SPIClass(HSPI);
-        // hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
-        adafruitDisplay->init(115200, true, 10, false, SPI, SPISettings(6000000, MSBFIRST, SPI_MODE0));
+        // Start HSPI
+        hspi = new SPIClass(HSPI);
+        hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+
+        // VExt already enabled in setup()
+        // RTC GPIO hold disabled in setup()
+
+        // Create GxEPD2 objects
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+
+        // Init GxEPD2
+        adafruitDisplay->init();
         adafruitDisplay->setRotation(3);
-        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
     }
 #elif defined(PCA10059)
     {
-        auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
-        adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
         adafruitDisplay->init(115200, true, 10, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
         adafruitDisplay->setRotation(3);
         adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
     }
 #elif defined(M5_COREINK)
-    auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
-    adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+    auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+    adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
     adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
     adafruitDisplay->setRotation(0);
-    adafruitDisplay->setPartialWindow(0, 0, EPD_WIDTH, EPD_HEIGHT);
-#elif defined(my)
+    adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+#elif defined(my) || defined(ESP32_S3_PICO)
     {
-        auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
-        adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
         adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
         adafruitDisplay->setRotation(1);
-        adafruitDisplay->setPartialWindow(0, 0, EPD_WIDTH, EPD_HEIGHT);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
     }
 #endif
 
-    // adafruitDisplay->setFullWindow();
-    // adafruitDisplay->fillScreen(UNCOLORED);
-    // adafruitDisplay->drawCircle(100, 100, 20, COLORED);
-    // adafruitDisplay->display(false);
-
     return true;
 }
 

src/graphics/EInkDisplay2.h

@@ -1,16 +1,27 @@
 #pragma once
 
+#ifdef USE_EINK
+
+#include "GxEPD2_BW.h"
 #include <OLEDDisplay.h>
 
+#if defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER)
+// Re-enable SPI after deep sleep: rtc_gpio_hold_dis()
+#include "driver/rtc_io.h"
+#endif
+
 /**
  * An adapter class that allows using the GxEPD2 library as if it was an OLEDDisplay implementation.
  *
+ * Note: EInkDynamicDisplay derives from this class.
+ *
  * Remaining TODO:
  * optimize display() to only draw changed pixels (see other OLED subclasses for examples)
  * implement displayOn/displayOff to turn off the TFT device (and backlight)
  * Use the fast NRF52 SPI API rather than the slow standard arduino version
  *
  * turn radio back on - currently with both on spi bus is fucked? or are we leaving chip select asserted?
+ * Suggestion: perhaps similar to HELTEC_WIRELESS_PAPER issue, which resolved with rtc_gpio_hold_dis()
  */
 class EInkDisplay : public OLEDDisplay
 {
@@ -32,7 +43,14 @@ class EInkDisplay : public OLEDDisplay
      *
      * @return true if we did draw the screen
      */
-    bool forceDisplay(uint32_t msecLimit = 1000);
+    virtual bool forceDisplay(uint32_t msecLimit = 1000);
+
+    /**
+     * Run any code needed to complete an update, after the physical refresh has completed.
+     * Split from forceDisplay(), to enable async refresh in derived EInkDynamicDisplay class.
+     *
+     */
+    virtual void endUpdate();
 
     /**
      * shim to make the abstraction happy
@@ -49,4 +67,18 @@ class EInkDisplay : public OLEDDisplay
 
     // Connect to the display
     virtual bool connect() override;
+
+    // AdafruitGFX display object - instantiated in connect(), variant specific
+    GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT> *adafruitDisplay = NULL;
+
+    // If display uses HSPI
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0)
+    SPIClass *hspi = NULL;
+#endif
+
+  private:
+    // FIXME quick hack to limit drawing to a very slow rate
+    uint32_t lastDrawMsec = 0;
 };
+
+#endif

src/graphics/EInkDynamicDisplay.cpp

@@ -0,0 +1,553 @@
+#include "configuration.h"
+
+#if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
+#include "EInkDynamicDisplay.h"
+
+// Constructor
+EInkDynamicDisplay::EInkDynamicDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus)
+    : EInkDisplay(address, sda, scl, geometry, i2cBus), NotifiedWorkerThread("EInkDynamicDisplay")
+{
+    // If tracking ghost pixels, grab memory
+#ifdef EINK_LIMIT_GHOSTING_PX
+    dirtyPixels = new uint8_t[EInkDisplay::displayBufferSize](); // Init with zeros
+#endif
+}
+
+// Destructor
+EInkDynamicDisplay::~EInkDynamicDisplay()
+{
+    // If we were tracking ghost pixels, free the memory
+#ifdef EINK_LIMIT_GHOSTING_PX
+    delete[] dirtyPixels;
+#endif
+}
+
+// Screen requests a BACKGROUND frame
+void EInkDynamicDisplay::display()
+{
+    addFrameFlag(BACKGROUND);
+    update();
+}
+
+// Screen requests a RESPONSIVE frame
+bool EInkDynamicDisplay::forceDisplay(uint32_t msecLimit)
+{
+    addFrameFlag(RESPONSIVE);
+    return update(); // (Unutilized) Base class promises to return true if update ran
+}
+
+// Add flag for the next frame
+void EInkDynamicDisplay::addFrameFlag(frameFlagTypes flag)
+{
+    // OR the new flag into the existing flags
+    this->frameFlags = (frameFlagTypes)(this->frameFlags | flag);
+}
+
+// GxEPD2 code to set fast refresh
+void EInkDynamicDisplay::configForFastRefresh()
+{
+    // Variant-specific code can go here
+#if defined(PRIVATE_HW)
+#else
+    // Otherwise:
+    adafruitDisplay->setPartialWindow(0, 0, adafruitDisplay->width(), adafruitDisplay->height());
+#endif
+}
+
+// GxEPD2 code to set full refresh
+void EInkDynamicDisplay::configForFullRefresh()
+{
+    // Variant-specific code can go here
+#if defined(PRIVATE_HW)
+#else
+    // Otherwise:
+    adafruitDisplay->setFullWindow();
+#endif
+}
+
+// Run any relevant GxEPD2 code, so next update will use correct refresh type
+void EInkDynamicDisplay::applyRefreshMode()
+{
+    // Change from FULL to FAST
+    if (currentConfig == FULL && refresh == FAST) {
+        configForFastRefresh();
+        currentConfig = FAST;
+    }
+
+    // Change from FAST back to FULL
+    else if (currentConfig == FAST && refresh == FULL) {
+        configForFullRefresh();
+        currentConfig = FULL;
+    }
+}
+
+// Update fastRefreshCount
+void EInkDynamicDisplay::adjustRefreshCounters()
+{
+    if (refresh == FAST)
+        fastRefreshCount++;
+
+    else if (refresh == FULL)
+        fastRefreshCount = 0;
+}
+
+// Trigger the display update by calling base class
+bool EInkDynamicDisplay::update()
+{
+    // Detemine the refresh mode to use, and start the update
+    bool refreshApproved = determineMode();
+    if (refreshApproved) {
+        EInkDisplay::forceDisplay(0); // Bypass base class' own rate-limiting system
+        storeAndReset();              // Store the result of this loop for next time. Note: call *before* endOrDetach()
+        endOrDetach();                // endUpdate() right now, or set the async refresh flag (if FULL and HAS_EINK_ASYNCFULL)
+    } else
+        storeAndReset(); // No update, no post-update code, just store the results
+
+    return refreshApproved; // (Unutilized) Base class promises to return true if update ran
+}
+
+// Figure out who runs the post-update code
+void EInkDynamicDisplay::endOrDetach()
+{
+    // If the GxEPD2 version reports that it has the async modifications
+#ifdef HAS_EINK_ASYNCFULL
+    if (previousRefresh == FULL) {
+        asyncRefreshRunning = true; // Set the flag - checked in determineMode(); cleared by onNotify()
+
+        if (previousFrameFlags & BLOCKING)
+            awaitRefresh();
+        else {
+            // Async begins
+            LOG_DEBUG("Async full-refresh begins (dropping frames)\n");
+            notifyLater(intervalPollAsyncRefresh, DUE_POLL_ASYNCREFRESH, true); // Hand-off to NotifiedWorkerThread
+        }
+    }
+
+    // Fast Refresh
+    else if (previousRefresh == FAST)
+        EInkDisplay::endUpdate(); // Still block while updating, but EInkDisplay needs us to call endUpdate() ourselves.
+
+        // Fallback - If using an unmodified version of GxEPD2 for some reason
+#else
+    if (previousRefresh == FULL || previousRefresh == FAST) { // If refresh wasn't skipped (on unspecified..)
+        LOG_WARN(
+            "GxEPD2 version has not been modified to support async refresh; using fallback behavior. Please update lib_deps in "
+            "variant's platformio.ini file\n");
+        EInkDisplay::endUpdate();
+    }
+#endif
+}
+
+// Assess situation, pick a refresh type
+bool EInkDynamicDisplay::determineMode()
+{
+    checkInitialized();
+    checkForPromotion();
+#if defined(HAS_EINK_ASYNCFULL)
+    checkBusyAsyncRefresh();
+#endif
+    checkRateLimiting();
+
+    // If too soon for a new frame, or display busy, abort early
+    if (refresh == SKIPPED)
+        return false; // No refresh
+
+    // -- New frame is due --
+
+    resetRateLimiting(); // Once determineMode() ends, will have to wait again
+    hashImage();         // Generate here, so we can still copy it to previousImageHash, even if we skip the comparison check
+    LOG_DEBUG("determineMode(): "); // Begin log entry
+
+    // Once mode determined, any remaining checks will bypass
+    checkCosmetic();
+    checkDemandingFast();
+    checkFrameMatchesPrevious();
+    checkConsecutiveFastRefreshes();
+#ifdef EINK_LIMIT_GHOSTING_PX
+    checkExcessiveGhosting();
+#endif
+    checkFastRequested();
+
+    if (refresh == UNSPECIFIED)
+        LOG_WARN("There was a flaw in the determineMode() logic.\n");
+
+    // -- Decision has been reached --
+    applyRefreshMode();
+    adjustRefreshCounters();
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // Full refresh clears any ghosting
+    if (refresh == FULL)
+        resetGhostPixelTracking();
+#endif
+
+    // Return - call a refresh or not?
+    if (refresh == SKIPPED)
+        return false; // Don't trigger a refresh
+    else
+        return true; // Do trigger a refresh
+}
+
+// Is this the very first frame?
+void EInkDynamicDisplay::checkInitialized()
+{
+    if (!initialized) {
+        // Undo GxEPD2_BW::partialWindow(), if set by developer in EInkDisplay::connect()
+        configForFullRefresh();
+
+        // Clear any existing image, so we can draw logo with fast-refresh, but also to set GxEPD2_EPD::_initial_write
+        adafruitDisplay->clearScreen();
+
+        LOG_DEBUG("initialized, ");
+        initialized = true;
+
+        // Use a fast-refresh for the next frame; no skipping or else blank screen when waking from deep sleep
+        addFrameFlag(DEMAND_FAST);
+    }
+}
+
+// Was a frame skipped (rate, display busy) that should have been a FAST refresh?
+void EInkDynamicDisplay::checkForPromotion()
+{
+    // If a frame was skipped (rate, display busy), then promote a BACKGROUND frame
+    // Because we DID want a RESPONSIVE/COSMETIC/DEMAND_FULL frame last time, we just didn't get it
+
+    switch (previousReason) {
+    case ASYNC_REFRESH_BLOCKED_DEMANDFAST:
+        addFrameFlag(DEMAND_FAST);
+        break;
+    case ASYNC_REFRESH_BLOCKED_COSMETIC:
+        addFrameFlag(COSMETIC);
+        break;
+    case ASYNC_REFRESH_BLOCKED_RESPONSIVE:
+    case EXCEEDED_RATELIMIT_FAST:
+        addFrameFlag(RESPONSIVE);
+        break;
+    default:
+        break;
+    }
+}
+
+// Is it too soon for another frame of this type?
+void EInkDynamicDisplay::checkRateLimiting()
+{
+    uint32_t now = millis();
+
+    // Sanity check: millis() overflow - just let the update run..
+    if (previousRunMs > now)
+        return;
+
+    // Skip update: too soon for BACKGROUND
+    if (frameFlags == BACKGROUND) {
+        if (now - previousRunMs < EINK_LIMIT_RATE_BACKGROUND_SEC * 1000) {
+            refresh = SKIPPED;
+            reason = EXCEEDED_RATELIMIT_FULL;
+            return;
+        }
+    }
+
+    // No rate-limit for these special cases
+    if (frameFlags & COSMETIC || frameFlags & DEMAND_FAST)
+        return;
+
+    // Skip update: too soon for RESPONSIVE
+    if (frameFlags & RESPONSIVE) {
+        if (now - previousRunMs < EINK_LIMIT_RATE_RESPONSIVE_SEC * 1000) {
+            refresh = SKIPPED;
+            reason = EXCEEDED_RATELIMIT_FAST;
+            LOG_DEBUG("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x\n", frameFlags);
+            return;
+        }
+    }
+}
+
+// Is this frame COSMETIC (splash screens?)
+void EInkDynamicDisplay::checkCosmetic()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // A full refresh is requested for cosmetic purposes: we have a decision
+    if (frameFlags & COSMETIC) {
+        refresh = FULL;
+        reason = FLAGGED_COSMETIC;
+        LOG_DEBUG("refresh=FULL, reason=FLAGGED_COSMETIC, frameFlags=0x%x\n", frameFlags);
+    }
+}
+
+// Is this a one-off special circumstance, where we REALLY want a fast refresh?
+void EInkDynamicDisplay::checkDemandingFast()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // A fast refresh is demanded: we have a decision
+    if (frameFlags & DEMAND_FAST) {
+        refresh = FAST;
+        reason = FLAGGED_DEMAND_FAST;
+        LOG_DEBUG("refresh=FAST, reason=FLAGGED_DEMAND_FAST, frameFlags=0x%x\n", frameFlags);
+    }
+}
+
+// Does the new frame match the currently displayed image?
+void EInkDynamicDisplay::checkFrameMatchesPrevious()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // If frame is *not* a duplicate, abort the check
+    if (imageHash != previousImageHash)
+        return;
+
+#if !defined(EINK_BACKGROUND_USES_FAST)
+    // If BACKGROUND, and last update was FAST: redraw the same image in FULL (for display health + image quality)
+    if (frameFlags == BACKGROUND && fastRefreshCount > 0) {
+        refresh = FULL;
+        reason = REDRAW_WITH_FULL;
+        LOG_DEBUG("refresh=FULL, reason=REDRAW_WITH_FULL, frameFlags=0x%x\n", frameFlags);
+        return;
+    }
+#endif
+
+    // Not redrawn, not COSMETIC, not DEMAND_FAST
+    refresh = SKIPPED;
+    reason = FRAME_MATCHED_PREVIOUS;
+    LOG_DEBUG("refresh=SKIPPED, reason=FRAME_MATCHED_PREVIOUS, frameFlags=0x%x\n", frameFlags);
+}
+
+// Have too many fast-refreshes occured consecutively, since last full refresh?
+void EInkDynamicDisplay::checkConsecutiveFastRefreshes()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // If too many FAST refreshes consecutively - force a FULL refresh
+    if (fastRefreshCount >= EINK_LIMIT_FASTREFRESH) {
+        refresh = FULL;
+        reason = EXCEEDED_LIMIT_FASTREFRESH;
+        LOG_DEBUG("refresh=FULL, reason=EXCEEDED_LIMIT_FASTREFRESH, frameFlags=0x%x\n", frameFlags);
+    }
+}
+
+// No objections, we can perform fast-refresh, if desired
+void EInkDynamicDisplay::checkFastRequested()
+{
+    if (refresh != UNSPECIFIED)
+        return;
+
+    if (frameFlags == BACKGROUND) {
+#ifdef EINK_BACKGROUND_USES_FAST
+        // If we want BACKGROUND to use fast. (FULL only when a limit is hit)
+        refresh = FAST;
+        reason = BACKGROUND_USES_FAST;
+        LOG_DEBUG("refresh=FAST, reason=BACKGROUND_USES_FAST, fastRefreshCount=%lu, frameFlags=0x%x\n", fastRefreshCount,
+                  frameFlags);
+#else
+        // If we do want to use FULL for BACKGROUND updates
+        refresh = FULL;
+        reason = FLAGGED_BACKGROUND;
+        LOG_DEBUG("refresh=FULL, reason=FLAGGED_BACKGROUND\n");
+#endif
+    }
+
+    // Sanity: confirm that we did ask for a RESPONSIVE frame.
+    if (frameFlags & RESPONSIVE) {
+        refresh = FAST;
+        reason = NO_OBJECTIONS;
+        LOG_DEBUG("refresh=FAST, reason=NO_OBJECTIONS, fastRefreshCount=%lu, frameFlags=0x%x\n", fastRefreshCount, frameFlags);
+    }
+}
+
+// Reset the timer used for rate-limiting
+void EInkDynamicDisplay::resetRateLimiting()
+{
+    previousRunMs = millis();
+}
+
+// Generate a hash of this frame, to compare against previous update
+void EInkDynamicDisplay::hashImage()
+{
+    imageHash = 0;
+
+    // Sum all bytes of the image buffer together
+    for (uint16_t b = 0; b < (displayWidth / 8) * displayHeight; b++) {
+        imageHash += buffer[b];
+    }
+}
+
+// Store the results of determineMode() for future use, and reset for next call
+void EInkDynamicDisplay::storeAndReset()
+{
+    previousFrameFlags = frameFlags;
+    previousRefresh = refresh;
+    previousReason = reason;
+
+    // Only store image hash if the display will update
+    if (refresh != SKIPPED) {
+        previousImageHash = imageHash;
+    }
+
+    frameFlags = BACKGROUND;
+    refresh = UNSPECIFIED;
+}
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+// Count how many ghost pixels the new image will display
+void EInkDynamicDisplay::countGhostPixels()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // Start a new count
+    ghostPixelCount = 0;
+
+    // Check new image, bit by bit, for any white pixels at locations marked "dirty"
+    for (uint16_t i = 0; i < displayBufferSize; i++) {
+        for (uint8_t bit = 0; bit < 7; bit++) {
+
+            const bool dirty = (dirtyPixels[i] >> bit) & 1;       // Has pixel location been drawn to since full-refresh?
+            const bool shouldBeBlank = !((buffer[i] >> bit) & 1); // Is pixel location white in the new image?
+
+            // If pixel is (or has been) black since last full-refresh, and now is white: ghosting
+            if (dirty && shouldBeBlank)
+                ghostPixelCount++;
+
+            // Update the dirty status for this pixel - will this location become a ghost if set white in future?
+            if (!dirty && !shouldBeBlank)
+                dirtyPixels[i] |= (1 << bit);
+        }
+    }
+
+    LOG_DEBUG("ghostPixels=%hu, ", ghostPixelCount);
+}
+
+// Check if ghost pixel count exceeds the defined limit
+void EInkDynamicDisplay::checkExcessiveGhosting()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    countGhostPixels();
+
+    // If too many ghost pixels, select full refresh
+    if (ghostPixelCount > EINK_LIMIT_GHOSTING_PX) {
+        refresh = FULL;
+        reason = EXCEEDED_GHOSTINGLIMIT;
+        LOG_DEBUG("refresh=FULL, reason=EXCEEDED_GHOSTINGLIMIT, frameFlags=0x%x\n", frameFlags);
+    }
+}
+
+// Clear the dirty pixels array. Call when full-refresh cleans the display.
+void EInkDynamicDisplay::resetGhostPixelTracking()
+{
+    // Copy the current frame into dirtyPixels[] from the display buffer
+    memcpy(dirtyPixels, EInkDisplay::buffer, EInkDisplay::displayBufferSize);
+}
+#endif // EINK_LIMIT_GHOSTING_PX
+
+// Handle any asyc tasks
+void EInkDynamicDisplay::onNotify(uint32_t notification)
+{
+    // Which task
+    switch (notification) {
+    case DUE_POLL_ASYNCREFRESH:
+        pollAsyncRefresh();
+        break;
+    }
+}
+
+#ifdef HAS_EINK_ASYNCFULL
+// Public: wait for an refresh already in progress, then run the post-update code. See Screen::setScreensaverFrames()
+void EInkDynamicDisplay::joinAsyncRefresh()
+{
+    // If no async refresh running, nothing to do
+    if (!asyncRefreshRunning)
+        return;
+
+    LOG_DEBUG("Joining an async refresh in progress\n");
+
+    // Continually poll the BUSY pin
+    while (adafruitDisplay->epd2.isBusy())
+        yield();
+
+    // If asyncRefreshRunning flag is still set, but display's BUSY pin reports the refresh is done
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+    LOG_DEBUG("Refresh complete\n");
+
+    // Note: this code only works because of a modification to meshtastic/GxEPD2.
+    // It is only equipped to intercept calls to nextPage()
+}
+
+// Called from NotifiedWorkerThread. Run the post-update code if the hardware is ready
+void EInkDynamicDisplay::pollAsyncRefresh()
+{
+    // In theory, this condition should never be met
+    if (!asyncRefreshRunning)
+        return;
+
+    // Still running, check back later
+    if (adafruitDisplay->epd2.isBusy()) {
+        // Schedule next call of pollAsyncRefresh()
+        NotifiedWorkerThread::notifyLater(intervalPollAsyncRefresh, DUE_POLL_ASYNCREFRESH, true);
+        return;
+    }
+
+    // If asyncRefreshRunning flag is still set, but display's BUSY pin reports the refresh is done
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+    LOG_DEBUG("Async full-refresh complete\n");
+
+    // Note: this code only works because of a modification to meshtastic/GxEPD2.
+    // It is only equipped to intercept calls to nextPage()
+}
+
+// Check the status of "async full-refresh"; skip if running
+void EInkDynamicDisplay::checkBusyAsyncRefresh()
+{
+    // No refresh taking place, continue with determineMode()
+    if (!asyncRefreshRunning)
+        return;
+
+    // Full refresh still running
+    if (adafruitDisplay->epd2.isBusy()) {
+        // No refresh
+        refresh = SKIPPED;
+
+        // Set the reason, marking what type of frame we're skipping
+        if (frameFlags & DEMAND_FAST)
+            reason = ASYNC_REFRESH_BLOCKED_DEMANDFAST;
+        else if (frameFlags & COSMETIC)
+            reason = ASYNC_REFRESH_BLOCKED_COSMETIC;
+        else if (frameFlags & RESPONSIVE)
+            reason = ASYNC_REFRESH_BLOCKED_RESPONSIVE;
+        else
+            reason = ASYNC_REFRESH_BLOCKED_BACKGROUND;
+
+        return;
+    }
+}
+
+// Hold control while an async refresh runs
+void EInkDynamicDisplay::awaitRefresh()
+{
+    // Continually poll the BUSY pin
+    while (adafruitDisplay->epd2.isBusy())
+        yield();
+
+    // End the full-refresh process
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+}
+#endif // HAS_EINK_ASYNCFULL
+
+#endif // USE_EINK_DYNAMICDISPLAY

src/graphics/EInkDynamicDisplay.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "configuration.h"
+
+#if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
+
+#include "EInkDisplay2.h"
+#include "GxEPD2_BW.h"
+#include "concurrency/NotifiedWorkerThread.h"
+
+/*
+    Derives from the EInkDisplay adapter class.
+    Accepts suggestions from Screen class about frame type.
+    Determines which refresh type is most suitable.
+    (Full, Fast, Skip)
+*/
+
+class EInkDynamicDisplay : public EInkDisplay, protected concurrency::NotifiedWorkerThread
+{
+  public:
+    // Constructor
+    // ( Parameters unused, passed to EInkDisplay. Maintains compatibility OLEDDisplay class )
+    EInkDynamicDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus);
+    ~EInkDynamicDisplay();
+
+    // What kind of frame is this
+    enum frameFlagTypes : uint8_t {
+        BACKGROUND = (1 << 0),  // For frames via display()
+        RESPONSIVE = (1 << 1),  // For frames via forceDisplay()
+        COSMETIC = (1 << 2),    // For splashes
+        DEMAND_FAST = (1 << 3), // Special case only
+        BLOCKING = (1 << 4),    // Modifier - block while refresh runs
+    };
+    void addFrameFlag(frameFlagTypes flag);
+
+    // Set the correct frame flag, then call universal "update()" method
+    void display() override;
+    bool forceDisplay(uint32_t msecLimit) override; // Shadows base class. Parameter and return val unused.
+
+  protected:
+    enum refreshTypes : uint8_t { // Which refresh operation will be used
+        UNSPECIFIED,
+        FULL,
+        FAST,
+        SKIPPED,
+    };
+    enum reasonTypes : uint8_t { // How was the decision reached
+        NO_OBJECTIONS,
+        ASYNC_REFRESH_BLOCKED_DEMANDFAST,
+        ASYNC_REFRESH_BLOCKED_COSMETIC,
+        ASYNC_REFRESH_BLOCKED_RESPONSIVE,
+        ASYNC_REFRESH_BLOCKED_BACKGROUND,
+        EXCEEDED_RATELIMIT_FAST,
+        EXCEEDED_RATELIMIT_FULL,
+        FLAGGED_COSMETIC,
+        FLAGGED_DEMAND_FAST,
+        EXCEEDED_LIMIT_FASTREFRESH,
+        EXCEEDED_GHOSTINGLIMIT,
+        FRAME_MATCHED_PREVIOUS,
+        BACKGROUND_USES_FAST,
+        FLAGGED_BACKGROUND,
+        REDRAW_WITH_FULL,
+    };
+
+    enum notificationTypes : uint8_t { // What was onNotify() called for
+        NONE = 0,                      // This behavior (NONE=0) is fixed by NotifiedWorkerThread class
+        DUE_POLL_ASYNCREFRESH = 1,
+    };
+    const uint32_t intervalPollAsyncRefresh = 100;
+
+    void onNotify(uint32_t notification) override; // Handle any async tasks - overrides NotifiedWorkerThread
+    void configForFastRefresh();                   // GxEPD2 code to set fast-refresh
+    void configForFullRefresh();                   // GxEPD2 code to set full-refresh
+    bool determineMode();                          // Assess situation, pick a refresh type
+    void applyRefreshMode();                       // Run any relevant GxEPD2 code, so next update will use correct refresh type
+    void adjustRefreshCounters();                  // Update fastRefreshCount
+    bool update();                                 // Trigger the display update - determine mode, then call base class
+    void endOrDetach();                            // Run the post-update code, or delegate it off to checkBusyAsyncRefresh()
+
+    // Checks as part of determineMode()
+    void checkInitialized();              // Is this the very first frame?
+    void checkForPromotion();             // Was a frame skipped (rate, display busy) that should have been a FAST refresh?
+    void checkRateLimiting();             // Is this frame too soon?
+    void checkCosmetic();                 // Was the COSMETIC flag set?
+    void checkDemandingFast();            // Was the DEMAND_FAST flag set?
+    void checkFrameMatchesPrevious();     // Does the new frame match the existing display image?
+    void checkConsecutiveFastRefreshes(); // Too many fast-refreshes consecutively?
+    void checkFastRequested();            // Was the flag set for RESPONSIVE, or only BACKGROUND?
+
+    void resetRateLimiting(); // Set previousRunMs - this now counts as an update, for rate-limiting
+    void hashImage();         // Generate a hashed version of this frame, to compare against previous update
+    void storeAndReset();     // Keep results of determineMode() for later, tidy-up for next call
+
+    // What we are determining for this frame
+    frameFlagTypes frameFlags = BACKGROUND; // Frame characteristics - determineMode() input
+    refreshTypes refresh = UNSPECIFIED;     // Refresh type - determineMode() output
+    reasonTypes reason = NO_OBJECTIONS;     // Reason - why was refresh type used
+
+    // What happened last time determineMode() ran
+    frameFlagTypes previousFrameFlags = BACKGROUND; // (Previous) Frame flags
+    refreshTypes previousRefresh = UNSPECIFIED;     // (Previous) Outcome
+    reasonTypes previousReason = NO_OBJECTIONS;     // (Previous) Reason
+
+    bool initialized = false;          // Have we drawn at least one frame yet?
+    uint32_t previousRunMs = -1;       // When did determineMode() last run (rather than rejecting for rate-limiting)
+    uint32_t imageHash = 0;            // Hash of the current frame. Don't bother updating if nothing has changed!
+    uint32_t previousImageHash = 0;    // Hash of the previous update's frame
+    uint32_t fastRefreshCount = 0;     // How many fast-refreshes consecutively since last full refresh?
+    refreshTypes currentConfig = FULL; // Which refresh type is GxEPD2 currently configured for
+
+    // Optional - track ghosting, pixel by pixel
+#ifdef EINK_LIMIT_GHOSTING_PX
+    void countGhostPixels();        // Count any pixels which have moved from black to white since last full-refresh
+    void checkExcessiveGhosting();  // Check if ghosting exceeds defined limit
+    void resetGhostPixelTracking(); // Clear the dirty pixels array. Call when full-refresh cleans the display.
+    uint8_t *dirtyPixels;           // Any pixels that have been black since last full-refresh (dynamically allocated mem)
+    uint32_t ghostPixelCount = 0;   // Number of pixels with problematic ghosting. Retained here for LOG_DEBUG use
+#endif
+
+    // Conditional - async full refresh - only with modified meshtastic/GxEPD2
+#if defined(HAS_EINK_ASYNCFULL)
+  public:
+    void joinAsyncRefresh(); // Main thread joins an async refresh already in progress. Blocks, then runs post-update code
+
+  protected:
+    void pollAsyncRefresh();          // Run the post-update code if the hardware is ready
+    void checkBusyAsyncRefresh();     // Check if display is busy running an async full-refresh (rejecting new frames)
+    void awaitRefresh();              // Hold control while an async refresh runs
+    void endUpdate() override {}      // Disable base-class behavior of running post-update immediately after forceDisplay()
+    bool asyncRefreshRunning = false; // Flag, checked by checkBusyAsyncRefresh()
+#else
+  public:
+    void joinAsyncRefresh() {} // Dummy method
+
+  protected:
+    void pollAsyncRefresh() {} // Dummy method. In theory, not reachable
+#endif
+};
+
+// Hide the ugly casts used in Screen.cpp
+#define EINK_ADD_FRAMEFLAG(display, flag) static_cast<EInkDynamicDisplay *>(display)->addFrameFlag(EInkDynamicDisplay::flag)
+#define EINK_JOIN_ASYNCREFRESH(display) static_cast<EInkDynamicDisplay *>(display)->joinAsyncRefresh()
+
+#else // !USE_EINK_DYNAMICDISPLAY
+// Dummy-macro, removes the need for include guards
+#define EINK_ADD_FRAMEFLAG(display, flag)
+#define EINK_JOIN_ASYNCREFRESH(display)
+#endif

src/graphics/RAKled.h

@@ -1,5 +1,3 @@
-#include "main.h"
-
 #ifdef HAS_NCP5623
 #include <NCP5623.h>
 extern NCP5623 rgb;