I swear

move temporary reboot code to blink thread

.gitattributes

@@ -0,0 +1,4 @@
+* text=auto eol=lf
+*.{cmd,[cC][mM][dD]} text eol=crlf
+*.{bat,[bB][aA][tT]} text eol=crlf
+*.{sh,[sS][hH]} text eol=lf

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,27 @@
+name: Feature Request
+description: Request a new feature
+title: "[Feature Request]: "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your request this will not gurantee that we will implement it, but it will be reviewed.
+  - type: dropdown
+    id: soc
+    attributes:
+      label: Platform
+      description: What device platform will support your feature?
+      multiple: true
+      options:
+        - NRF52
+        - ESP32
+    validations:
+      required: true
+  - type: textarea
+    id: body
+    attributes:
+      label: Description
+      description: Please provide details about your enhancement.
+    validations:
+      required: true

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

@@ -0,0 +1,41 @@
+name: "Setup Build Base Composite Action"
+description: "Base build actions for Meshtastic Platform IO steps"
+
+runs:
+  using: "composite"
+  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: Install cppcheck
+      shell: bash
+      run: |
+        sudo apt-get install -y cppcheck
+
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.x
+
+    - name: Cache python libs
+      uses: actions/cache@v3
+      id: cache-pip # needed in if test
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip
+
+    - name: Upgrade python tools
+      shell: bash
+      run: |
+        python -m pip install --upgrade pip
+        pip install -U platformio adafruit-nrfutil
+        pip install -U meshtastic --pre
+
+    - name: Upgrade platformio
+      shell: bash
+      run: |
+        pio upgrade

.github/workflows/build_esp32.yml

@@ -0,0 +1,61 @@
+name: Build ESP32
+
+on:
+  workflow_call:
+    inputs:
+      board:
+        required: true
+        type: string
+
+jobs:
+  build-esp32:
+    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@master
+        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
+
+      - name: Build ESP32
+        run: bin/build-esp32.sh ${{ inputs.board }}
+
+      - name: Pull OTA Firmware
+        uses: dsaltares/fetch-gh-release-asset@master
+        with:
+          repo: "meshtastic/firmware-ota"
+          file: "firmware.bin"
+          target: "release/bleota.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_nrf52.yml

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

.github/workflows/build_rpi2040.yml

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

.github/workflows/main_matrix.yml

@@ -2,18 +2,17 @@ name: CI
 on:
   # # Triggers the workflow on push but only for the master branch
   push:
-    branches: [master]
+    branches: [master, develop]
     paths-ignore:
       - "**.md"
-      - "**.yml"
       - "version.properties"
 
   # Note: This is different from "pull_request". Need to specify ref when doing checkouts.
   pull_request_target:
-    branches: [master]
+    branches: [master, develop]
     paths-ignore:
       - "**.md"
-      - "**.yml"
+      #- "**.yml"
 
   workflow_dispatch:
 
@@ -24,57 +23,26 @@ jobs:
       matrix:
         include:
           - board: rak11200
-          - board: tlora-v2
-          - board: tlora-v1
-          - board: tlora_v1_3
           - board: tlora-v2-1-1.6
           - board: tbeam
-          - board: heltec-v1
-          - board: heltec-v2.0
           - board: heltec-v2.1
-          - board: tbeam0.7
           - board: meshtastic-diy-v1
           - board: rak4631
-          - board: rak4631_eink
           - board: t-echo
-          - board: nano-g1
           - board: station-g1
-          - board: m5stack-core
           - board: m5stack-coreink
+          - board: tbeam-s3-core
+          - board: tlora-t3s3-v1
 
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout code
+      - uses: actions/checkout@v3
-        uses: actions/checkout@v3
+      - name: Build base
-        with:
+        id: base
-          submodules: "recursive"
+        uses: ./.github/actions/setup-base
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - name: Install cppcheck
+      - name: Trunk Check
-        run: |
+        uses: trunk-io/trunk-action@v1
-          sudo apt-get install -y cppcheck
-
-      - name: Setup Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.x
-
-      - name: Cache python libs
-        uses: actions/cache@v1
-        id: cache-pip # needed in if test
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip
-
-      - name: Upgrade python tools and install platformio
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio
-
-      - name: Upgrade platformio
-        run: |
-          pio upgrade
 
       - name: Check ${{ matrix.board }}
         run: bin/check-all.sh ${{ matrix.board }}
@@ -89,76 +57,25 @@ jobs:
           - board: tlora-v1
           - board: tlora_v1_3
           - board: tlora-v2-1-1.6
+          - board: tlora-v2-1-1.8
           - board: tbeam
           - board: heltec-v1
           - board: heltec-v2.0
           - board: heltec-v2.1
+          - board: heltec-v3
+          - board: heltec-wsl-v3
           - board: tbeam0.7
           - board: meshtastic-diy-v1
+          - board: meshtastic-dr-dev
           - board: nano-g1
           - board: station-g1
           - board: m5stack-core
           - board: m5stack-coreink
-
+          - board: tbeam-s3-core
-    runs-on: ubuntu-latest
+          - board: tlora-t3s3-v1
-    steps:
+    uses: ./.github/workflows/build_esp32.yml
-      - name: Checkout code
-        uses: actions/checkout@v3
     with:
-          submodules: "recursive"
+      board: ${{ matrix.board }}
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Setup Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.x
-
-      - name: Cache python libs
-        uses: actions/cache@v1
-        id: cache-pip # needed in if test
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip
-
-      - name: Upgrade python tools
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio adafruit-nrfutil littlefs-python
-          pip install -U --pre meshtastic
-
-      - name: Upgrade platformio
-        run: |
-          pio upgrade
-
-      - name: Pull web ui
-        uses: dsaltares/fetch-gh-release-asset@master
-        with:
-          repo: "meshtastic/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: Build ESP32
-        run: bin/build-esp32.sh ${{ matrix.board }}
-
-      - name: Get release version string
-        run: echo "::set-output name=version::$(./bin/buildinfo.py long)"
-        id: version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: firmware-${{ matrix.board }}-${{ steps.version.outputs.version }}.zip
-          path: |
-            release/*.bin
-            release/*.elf
-          retention-days: 90
 
   build-nrf52:
     strategy:
@@ -170,112 +87,81 @@ jobs:
           - board: rak4631_eink
           - board: t-echo
           - board: pca10059_diy_eink
-
+          - board: feather_diy
-    runs-on: ubuntu-latest
+    uses: ./.github/workflows/build_nrf52.yml
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
     with:
-          submodules: "recursive"
+      board: ${{ matrix.board }}
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - name: Setup Python
+  build-rpi2040:
-        uses: actions/setup-python@v2
+    strategy:
+      fail-fast: false
+      max-parallel: 2
+      matrix:
+        include:
+          - board: pico
+    uses: ./.github/workflows/build_rpi2040.yml
     with:
-          python-version: 3.x
+      board: ${{ matrix.board }}
-
-      - name: Cache python libs
-        uses: actions/cache@v1
-        id: cache-pip # needed in if test
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip
-
-      - name: Upgrade python tools
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio adafruit-nrfutil
-          pip install -U --pre meshtastic
-
-      - name: Upgrade platformio
-        run: |
-          pio upgrade
-
-      - name: Build NRF52
-        run: bin/build-nrf52.sh ${{ matrix.board }}
-
-      - name: Get release version string
-        run: echo "::set-output name=version::$(./bin/buildinfo.py long)"
-        id: version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: firmware-${{ matrix.board }}-${{ steps.version.outputs.version }}.zip
-          path: |
-            release/*.uf2
-            release/*.elf
-          retention-days: 90
 
   build-native:
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout code
+      - uses: actions/checkout@v3
-        uses: actions/checkout@v3
+      - name: Build base
-        with:
+        id: base
-          submodules: "recursive"
+        uses: ./.github/actions/setup-base
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Setup Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.x
-
-      - name: Cache python libs
-        uses: actions/cache@v1
-        id: cache-pip # needed in if test
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip
-
-      - name: Upgrade python tools
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio adafruit-nrfutil
-          pip install -U --pre meshtastic
-
-      - name: Upgrade platformio
-        run: |
-          pio upgrade
 
       # We now run integration test before other build steps (to quickly see runtime failures)
-      - name: Build for native
+      #- name: Build for native
-        run: platformio run -e native
+      #  run: platformio run -e native
-      - name: Integration test
+      #- name: Integration test
-        run: |
+      # run: |
-          .pio/build/native/program &
+      #.pio/build/native/program
-          sleep 20 # 5 seconds was not enough
+      #& sleep 20 # 5 seconds was not enough
-          echo "Simulator started, launching python test..."
+      #echo "Simulator started, launching python test..."
-          python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
+      #python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
 
       - name: Build Native
         run: bin/build-native.sh
 
       - name: Get release version string
-        run: echo "::set-output name=version::$(./bin/buildinfo.py long)"
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
         id: version
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: firmware-native-${{ steps.version.outputs.version }}.zip
           path: |
-            release/meshtasticd_linux_amd64
             release/device-*.sh
             release/device-*.bat
-          retention-days: 90
+
+      - name: Docker login
+        uses: docker/login-action@v2
+        with:
+          username: meshtastic
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Docker setup
+        uses: docker/setup-buildx-action@v2
+
+      - name: Docker build and push tagged versions
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: meshtastic/device-simulator:${{ steps.version.outputs.version }}
+
+      - name: Docker build and push
+        if: github.ref == 'refs/heads/master'
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: meshtastic/device-simulator:latest
 
   after-checks:
     runs-on: ubuntu-latest
@@ -289,7 +175,7 @@ jobs:
 
   gather-artifacts:
     runs-on: ubuntu-latest
-    needs: [build-esp32, build-nrf52, build-native]
+    needs: [build-esp32, build-nrf52, build-native, build-rpi2040]
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
@@ -297,30 +183,30 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           path: ./
 
       - name: Get release version string
-        run: echo "::set-output name=version::$(./bin/buildinfo.py long)"
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
         id: version
 
       - name: Move files up
-        run: mv -b -t ./ ./*tbeam-*/littlefs*.bin ./*tbeam-*/system-info.bin ./**/firmware*.bin ./**/*.uf2 ./**/*.elf ./**/meshtasticd_linux_amd64 ./*native*/*device-*.sh ./*native*/*device-*.bat
+        run: mv -b -t ./ ./*tbeam-2*/littlefs*.bin ./*tbeam-2*/bleota.bin ./**/firmware*.bin ./*t-echo*/Meshtastic_nRF52_factory_erase.uf2 ./**/firmware-*.uf2 ./**/firmware-*-ota.zip ./**/*.elf ./*native*/*device-*.sh ./*native*/*device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: firmware-${{ steps.version.outputs.version }}
           path: |
             ./*.bin
             ./*.uf2
-            ./meshtasticd_linux_amd64
+            ./firmware-*-ota.zip
             ./device-*.sh
             ./device-*.bat
           retention-days: 90
 
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           name: firmware-${{ steps.version.outputs.version }}
           path: ./output
@@ -329,15 +215,20 @@ jobs:
       - name: Show artifacts
         run: ls -lR
 
+      - name: Device scripts permissions
+        run: |
+          chmod +x ./output/device-install.sh
+          chmod +x ./output/device-update.sh
+
       - name: Zip firmware
-        run: zip -j -r ./firmware-${{ steps.version.outputs.version }}.zip ./output
+        run: zip -j -9 -r ./firmware-${{ steps.version.outputs.version }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: debug-elfs-${{ steps.version.outputs.version }}.zip
           path: ./*.elf
-          retention-days: 90
+          retention-days: 30
 
       - name: Create request artifacts
         if: ${{ github.event_name == 'pull_request_target' || github.event_name == 'pull_request' }}
@@ -350,3 +241,88 @@ jobs:
           artifacts-branch: device
           artifacts-dir: pr
           artifacts: ./firmware-${{ steps.version.outputs.version }}.zip
+
+  release-artifacts:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' }}
+    needs: [gather-artifacts, after-checks]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.x
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: firmware-${{ steps.version.outputs.version }}
+          path: ./output
+
+      - name: Device scripts permissions
+        run: |
+          chmod +x ./output/device-install.sh
+          chmod +x ./output/device-update.sh
+
+      - name: Zip firmware
+        run: zip -j -9 -r ./firmware-${{ steps.version.outputs.version }}.zip ./output
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: debug-elfs-${{ steps.version.outputs.version }}.zip
+          path: ./elfs
+
+      - name: Zip Elfs
+        run: zip -j -9 -r ./debug-elfs-${{ steps.version.outputs.version }}.zip ./elfs
+
+      # For diagnostics
+      - name: Show artifacts
+        run: ls -lR
+
+      - name: Create release
+        uses: actions/create-release@v1
+        id: create_release
+        with:
+          draft: true
+          prerelease: true
+          release_name: Meshtastic Firmware ${{ steps.version.outputs.version }}
+          tag_name: v${{ steps.version.outputs.version }}
+          body: |
+            Autogenerated by github action, developer should edit as required before publishing...
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+
+      - name: Add bins to release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./firmware-${{ steps.version.outputs.version }}.zip
+          asset_name: firmware-${{ steps.version.outputs.version }}.zip
+          asset_content_type: application/zip
+
+      - name: Add debug elfs to release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./debug-elfs-${{ steps.version.outputs.version }}.zip
+          asset_name: debug-elfs-${{ steps.version.outputs.version }}.zip
+          asset_content_type: application/zip
+
+      - name: Bump version.properties
+        run: >-
+          bin/bump_version.py
+
+      - name: Create version.properties pull request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          add-paths: |
+            version.properties

.github/workflows/nightly.yml

@@ -0,0 +1,19 @@
+name: Nightly
+on:
+  schedule:
+    - cron: 0 8 * * 1-5
+  workflow_dispatch: {}
+
+jobs:
+  trunk_check:
+    name: Trunk Check Upload
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Trunk Check
+        uses: trunk-io/trunk-action@v1
+        with:
+          trunk-token: ${{ secrets.TRUNK_TOKEN }}

.github/workflows/release.yml

@@ -1,92 +0,0 @@
-name: Make Release
-on:
-  # Can optionally take parameters from the github UI, more info here https://github.blog/changelog/2020-07-06-github-actions-manual-triggers-with-workflow_dispatch/#:~:text=You%20can%20now%20create%20workflows,the%20workflow%20is%20run%20on.
-  workflow_dispatch:
-  #  inputs:
-
-  # Only want to run if version.properties is bumped in master
-  push:
-    branches:
-      - master
-    paths:
-      - "version.properties"
-
-jobs:
-  release-build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          submodules: "recursive"
-
-      - name: Setup Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.x
-
-      # Will be available in steps.version.outputs.version
-      - name: Get release version string
-        run: echo "::set-output name=version::$(./bin/buildinfo.py long)"
-        id: version
-      # Note: we don't use caches on release builds because we don't want to accidentally not have a virgin build machine
-
-      - name: Upgrade python tools
-        # We actually want to run this every time
-        # if: steps.cache-pip.outputs.cache-hit != 'true'
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio meshtastic adafruit-nrfutil littlefs-python
-
-      - name: Upgrade platformio
-        run: |
-          pio upgrade
-
-      - name: Pull web ui
-        uses: dsaltares/fetch-gh-release-asset@master
-        with:
-          repo: "meshtastic/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: Build everything
-        run: bin/build-all.sh
-
-      - name: Create release
-        uses: actions/create-release@v1
-        id: create_release
-        with:
-          draft: true
-          prerelease: true
-          release_name: ${{ steps.version.outputs.version }} alpha
-          tag_name: v${{ steps.version.outputs.version }}
-          body: |
-            Autogenerated by github action, developer should edit as required before publishing...
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-
-      - name: Add bins to release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: release/archive/firmware-${{ steps.version.outputs.version }}.zip
-          asset_name: firmware-${{ steps.version.outputs.version }}.zip
-          asset_content_type: application/zip
-
-      - name: Add debug elfs to release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: release/archive/elfs-${{ steps.version.outputs.version }}.zip
-          asset_name: debug-elfs-${{ steps.version.outputs.version }}.zip
-          asset_content_type: application/zip

.github/workflows/sec_sast_flawfinder.yml

@@ -0,0 +1,40 @@
+---
+name: Flawfinder Scan
+
+on:
+  push:
+    branches: [master, develop]
+    paths-ignore:
+      - "**.md"
+      - "version.properties"
+
+jobs:
+  flawfinder:
+    runs-on: ubuntu-latest
+    name: Flawfinder
+
+    steps:
+      # step 1
+      - name: clone application source code
+        uses: actions/checkout@v3
+
+      # step 2
+      - name: flawfinder_scan
+        uses: david-a-wheeler/flawfinder@2.0.19
+        with:
+          arguments: "--sarif ./"
+          output: "flawfinder_report.sarif"
+
+      # step 3
+      - name: save report as pipeline artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: flawfinder_report.sarif
+          path: flawfinder_report.sarif
+
+      # step 4
+      - name: publish code scanning alerts
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: flawfinder_report.sarif
+          category: flawfinder

.github/workflows/sec_sast_semgrep_cron.yml

@@ -0,0 +1,42 @@
+---
+name: Semgrep Full Scan
+
+on:
+  workflow_dispatch:
+    branches:
+      - master
+  schedule:
+    - cron: "0 1 * * 6"
+
+jobs:
+  semgrep-full:
+    runs-on: ubuntu-latest
+    container:
+      image: returntocorp/semgrep
+
+    steps:
+      # step 1
+      - name: clone application source code
+        uses: actions/checkout@v3
+
+      # step 2
+      - name: full scan
+        run: |
+          semgrep \
+            --sarif --output report.sarif \
+            --metrics=off \
+            --config="p/default"
+
+      # step 3
+      - name: save report as pipeline artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: report.sarif
+          path: report.sarif
+
+      # step 4
+      - name: publish code scanning alerts
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: report.sarif
+          category: semgrep

.github/workflows/sec_sast_semgrep_pull.yml

@@ -0,0 +1,25 @@
+---
+name: Semgrep Differential Scan
+on: pull_request
+
+jobs:
+  semgrep-diff:
+    runs-on: ubuntu-latest
+    container:
+      image: returntocorp/semgrep
+
+    steps:
+      # step 1
+      - name: clone application source code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      # step 2
+      - name: differential scan
+        run: |
+          semgrep scan \
+            --error \
+            --metrics=off \
+            --baseline-commit ${{ github.event.pull_request.base.sha }} \
+            --config="p/default"

.github/workflows/update_protobufs.yml

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

.gitignore

@@ -29,3 +29,4 @@ __pycache__
 
 venv/
 release/
+.vscode/extensions.json

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "protobufs"]
 	path = protobufs
-	url = https://github.com/meshtastic/Meshtastic-protobufs.git
+	url = https://github.com/meshtastic/protobufs.git

.semgrepignore

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

.trunk/.gitignore

@@ -0,0 +1,7 @@
+*out
+*logs
+*actions
+*notifications
+plugins
+user_trunk.yaml
+user.yaml

.trunk/configs/.hadolint.yaml

@@ -0,0 +1,4 @@
+# Following source doesn't work in most setups
+ignored:
+  - SC1090
+  - SC1091

.trunk/configs/.markdownlint.yaml

@@ -0,0 +1,10 @@
+# Autoformatter friendly markdownlint config (all formatting rules disabled)
+default: true
+blank_lines: false
+bullet: false
+html: false
+indentation: false
+line_length: false
+spaces: false
+url: false
+whitespace: false

.trunk/configs/.shellcheckrc

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

.trunk/configs/svgo.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  plugins: [
+    {
+      name: "preset-default",
+      params: {
+        overrides: {
+          removeViewBox: false, // https://github.com/svg/svgo/issues/1128
+          sortAttrs: true,
+          removeOffCanvasPaths: true,
+        },
+      },
+    },
+  ],
+};

.trunk/trunk.yaml

@@ -0,0 +1,33 @@
+version: 0.1
+cli:
+  version: 1.3.1
+plugins:
+  sources:
+    - id: trunk
+      ref: v0.0.8
+      uri: https://github.com/trunk-io/plugins
+lint:
+  enabled:
+    - git-diff-check
+    - gitleaks@8.15.2
+    - clang-format@14.0.0
+    - prettier@2.8.3
+  disabled:
+    - shellcheck@0.9.0
+    - shfmt@3.5.0
+    - oxipng@8.0.0
+    - actionlint@1.6.22
+    - markdownlint@0.33.0
+    - hadolint@2.12.0
+    - svgo@3.0.2
+runtimes:
+  enabled:
+    - go@1.18.3
+    - node@18.12.1
+actions:
+  disabled:
+    - trunk-announce
+    - trunk-check-pre-push
+    - trunk-fmt-pre-commit
+  enabled:
+    - trunk-upgrade-available

.vscode/extensions.json

@@ -2,10 +2,8 @@
     // See http://go.microsoft.com/fwlink/?LinkId=827846
     // for the documentation about the extensions.json format
     "recommendations": [
+        "ms-vscode.cpptools",
         "platformio.platformio-ide",
-        "xaver.clang-format"
+        "trunk.io"
     ],
-    "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack"
-    ]
 }

.vscode/settings.json

@@ -1,78 +1,4 @@
 {
-    "files.associations": {
+  "editor.formatOnSave": true,
-        "type_traits": "cpp",
+  "editor.defaultFormatter": "trunk.io"
-        "array": "cpp",
-        "*.tcc": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "deque": "cpp",
-        "unordered_map": "cpp",
-        "unordered_set": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "algorithm": "cpp",
-        "functional": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "fstream": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "memory": "cpp",
-        "new": "cpp",
-        "ostream": "cpp",
-        "numeric": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "cinttypes": "cpp",
-        "utility": "cpp",
-        "typeinfo": "cpp",
-        "string": "cpp",
-        "*.xbm": "cpp",
-        "list": "cpp",
-        "atomic": "cpp",
-        "memory_resource": "cpp",
-        "optional": "cpp",
-        "string_view": "cpp",
-        "cassert": "cpp",
-        "iterator": "cpp",
-        "shared_mutex": "cpp",
-        "iostream": "cpp",
-        "esp_nimble_hci.h": "c",
-        "map": "cpp"
-    },
-    "cSpell.words": [
-        "Blox",
-        "EINK",
-        "HFSR",
-        "Meshtastic",
-        "NEMAGPS",
-        "NMEAGPS",
-        "RDEF",
-        "Ublox",
-        "bkpt",
-        "cfsr",
-        "descs",
-        "ocrypto",
-        "protobufs",
-        "wifi"
-    ],
-    "C_Cpp.dimInactiveRegions": true,
-    "cmake.configureOnOpen": true,
-    "protoc": {
-        "compile_on_save": false,
-    }
 }

.vscode/tasks.json

@@ -4,9 +4,7 @@
     {
       "type": "PlatformIO",
       "task": "Build",
-			"problemMatcher": [
+      "problemMatcher": ["$platformio"],
-				"$platformio"
-			],
       "group": {
         "kind": "build",
         "isDefault": true

Dockerfile

@@ -0,0 +1,41 @@
+FROM debian:bullseye-slim AS builder
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=Etc/UTC
+
+# http://bugs.python.org/issue19846
+# > At the moment, setting "LANG=C" on a Linux system *fundamentally breaks Python 3*, and that's not OK.
+ENV LANG C.UTF-8
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+# Install build deps
+USER root
+RUN apt-get update && \
+	apt-get -y install wget python3 g++ zip python3-venv git vim ca-certificates
+
+# create a non-priveleged user & group
+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'"
+
+HEALTHCHECK NONE

README.md

@@ -1,8 +1,8 @@
 # Meshtastic Firmware
 
-![GitHub release downloads](https://img.shields.io/github/downloads/meshtastic/meshtastic-device/total)
+![GitHub release downloads](https://img.shields.io/github/downloads/meshtastic/firmware/total)
-[![CI](https://img.shields.io/github/workflow/status/meshtastic/Meshtastic-device/CI?label=actions&logo=github&color=yellow)](https://github.com/meshtastic/repo/actions/workflows/main_matrix.yml)
+[![CI](https://img.shields.io/github/actions/workflow/status/meshtastic/firmware/main_matrix.yml?branch=master&label=actions&logo=github&color=yellow)](https://github.com/meshtastic/firmware/actions/workflows/ci.yml)
-[![CLA assistant](https://cla-assistant.io/readme/badge/meshtastic/Meshtastic-device)](https://cla-assistant.io/meshtastic/Meshtastic-device)
+[![CLA assistant](https://cla-assistant.io/readme/badge/meshtastic/firmware)](https://cla-assistant.io/meshtastic/firmware)
 [![Fiscal Contributors](https://opencollective.com/meshtastic/tiers/badge.svg?label=Fiscal%20Contributors&color=deeppink)](https://opencollective.com/meshtastic/)
 [![Vercel](https://img.shields.io/static/v1?label=Powered%20by&message=Vercel&style=flat&logo=vercel&color=000000)](https://vercel.com?utm_source=meshtastic&utm_campaign=oss)
 
@@ -10,10 +10,9 @@
 
 This repository contains the device firmware for the Meshtastic project.
 
-
+**[Building Instructions](https://meshtastic.org/docs/development/firmware/build)**
-**[Building Instructions](https://meshtastic.org/docs/developers/Firmware/build)**
 **[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)**
 
 ## Stats
 
-![Alt](https://repobeats.axiom.co/api/embed/99a2cf5622bb4807f9e8c3b86589f1133cce58a2.svg 'Repobeats analytics image')
+![Alt](https://repobeats.axiom.co/api/embed/a92f097d9197ae853e780ec53d7d126e545629ab.svg "Repobeats analytics image")

arch/esp32/esp32.ini

@@ -0,0 +1,54 @@
+; Common settings for ESP targes, mixin with extends = esp32_base
+[esp32_base]
+extends = arduino_base
+platform = platformio/espressif32@^5.2.0
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
+upload_speed = 921600
+debug_init_break = tbreak setup
+monitor_filters = esp32_exception_decoder
+board_build.filesystem = littlefs
+
+# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
+# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
+# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
+build_flags =
+  ${arduino_base.build_flags}
+  -Wall
+  -Wextra
+  -Isrc/platform/esp32
+  -std=c++11
+  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
+  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
+  -DAXP_DEBUG_PORT=Serial
+  -DCONFIG_BT_NIMBLE_ENABLED
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DDEBUG_HEAP
+
+lib_deps =
+  ${arduino_base.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
+  https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
+  caveman99/ESP32 Codec2@^1.0.1
+
+lib_ignore = 
+  segger_rtt
+  ESP32 BLE Arduino
+
+; leave this commented out to avoid breaking Windows
+;upload_port = /dev/ttyUSB0
+;monitor_port = /dev/ttyUSB0
+
+; Please don't delete these lines. JM uses them.
+;upload_port = /dev/cu.SLAB_USBtoUART
+;monitor_port = /dev/cu.SLAB_USBtoUART
+
+; customize the partition table
+; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
+board_build.partitions = partition-table.csv

arch/esp32/esp32s2.ini

@@ -0,0 +1,47 @@
+[esp32s2_base]
+extends = arduino_base
+platform = platformio/espressif32@^5.2.0
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/> -<nimble/>
+upload_speed = 961200
+monitor_speed = 115200
+debug_init_break = tbreak setup
+monitor_filters = esp32_exception_decoder
+board_build.filesystem = littlefs
+
+# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
+# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
+# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
+build_flags =
+  ${arduino_base.build_flags} 
+  -Wall 
+  -Wextra 
+  -Isrc/platform/esp32 
+  -std=c++11 
+  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG 
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG 
+  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
+  -DAXP_DEBUG_PORT=Serial 
+  -DCONFIG_BT_NIMBLE_ENABLED 
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DHAS_BLUETOOTH=0
+  -DDEBUG_HEAP
+  
+lib_deps =
+  ${arduino_base.lib_deps}
+  ${networking_base.lib_deps}
+  ${environmental_base.lib_deps}
+  https://github.com/meshtastic/esp32_https_server.git#23665b3adc080a311dcbb586ed5941b5f94d6ea2
+  https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
+  caveman99/ESP32 Codec2@^1.0.1
+
+lib_ignore = 
+  segger_rtt
+  ESP32 BLE Arduino
+
+; customize the partition table
+; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
+board_build.partitions = partition-table.csv
+

arch/esp32/esp32s3.ini

@@ -0,0 +1,47 @@
+[esp32s3_base]
+extends = arduino_base
+platform = platformio/espressif32@^5.2.0
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
+upload_speed = 961200
+monitor_speed = 115200
+debug_init_break = tbreak setup
+monitor_filters = esp32_exception_decoder
+board_build.filesystem = littlefs
+
+# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
+# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
+# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
+build_flags =
+  ${arduino_base.build_flags} 
+  -Wall 
+  -Wextra 
+  -Isrc/platform/esp32 
+  -std=c++11 
+  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG 
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG 
+  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
+  -DAXP_DEBUG_PORT=Serial 
+  -DCONFIG_BT_NIMBLE_ENABLED 
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DDEBUG_HEAP
+  
+lib_deps =
+  ${arduino_base.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
+  https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
+  caveman99/ESP32 Codec2@^1.0.1
+
+lib_ignore = 
+  segger_rtt
+  ESP32 BLE Arduino
+
+; customize the partition table
+; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
+board_build.partitions = partition-table.csv
+

arch/nrf52/nrf52.ini

@@ -0,0 +1,18 @@
+[nrf52_base]
+; Instead of the standard nordicnrf52 platform, we use our fork which has our added variant files
+platform = platformio/nordicnrf52@^9.4.0
+
+extends = arduino_base
+build_type = debug ; I'm debugging with ICE a lot now
+build_flags = 
+  ${arduino_base.build_flags} -Wno-unused-variable 
+  -Isrc/platform/nrf52
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<platform/stm32wl> -<nimble/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<mqtt/> -<platform/rp2040> -<mesh/eth/>
+lib_ignore =
+  BluetoothOTA
+  
+; Note: By default no lora device is created for this build - it uses a simulated interface
+[env:feather_nrf52832]
+extends = nrf52_base
+board = adafruit_feather_nrf52832  

arch/nrf52/nrf52840.ini

@@ -0,0 +1,14 @@
+[nrf52840_base]
+extends = nrf52_base
+build_flags = ${nrf52_base.build_flags} 
+lib_deps =
+  ${arduino_base.lib_deps}
+  ${environmental_base.lib_deps}
+  https://github.com/Kongduino/Adafruit_nRFCrypto.git#e31a8825ea3300b163a0a3c1ddd5de34e10e1371
+
+; Note: By default no lora device is created for this build - it uses a simulated interface
+[env:nrf52840dk]
+extends = nrf52840_base
+board = nrf52840_dk
+
+

arch/portduino/portduino.ini

@@ -0,0 +1,21 @@
+; 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#096b3c3e9c5c8e19d4c3b6cd803fffef2a9be4c5
+framework = arduino
+build_src_filter = 
+  ${env.build_src_filter} 
+  -<platform/esp32/> 
+  -<nimble/> 
+  -<platform/nrf52/> 
+  -<platform/stm32wl/> 
+  -<platform/rp2040>
+  -<mesh/http/>
+  -<mesh/eth/>
+  -<modules/esp32>
+  -<modules/Telemetry>
+  +<../variants/portduino>
+lib_deps =
+  ${env.lib_deps}
+  ${networking_base.lib_deps}
+  rweather/Crypto@^0.4.0
+build_flags = ${arduino_base.build_flags} -Isrc/platform/portduino

arch/rp2040/rp2040.ini

@@ -0,0 +1,21 @@
+; Common settings for rp2040 Processor based targets
+[rp2040_base]
+platform = https://github.com/maxgerhardt/platform-raspberrypi.git#20c7dbfcfe6677c5305fa28ecf5e3870321cb157
+platform_packages = 
+  earlephilhower/toolchain-rp2040-earlephilhower@^5.100300.221223
+extends = arduino_base
+board_build.core = earlephilhower
+board_build.filesystem_size = 0.5m
+build_flags = 
+  ${arduino_base.build_flags} -Wno-unused-variable 
+  -Isrc/platform/rp2040
+  -D__PLAT_RP2040__
+#  -D _POSIX_THREADS
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<mqtt/> -<platform/nrf52/> -<platform/stm32wl> -<mesh/eth/>
+lib_ignore =
+  BluetoothOTA
+lib_deps =
+  ${arduino_base.lib_deps}
+  ${environmental_base.lib_deps}
+  https://github.com/kokke/tiny-AES-c.git#f06ac37fc31dfdaca2e0d9bec83f90d5663c319b

arch/stm32/stm32wl5e.ini

@@ -0,0 +1,18 @@
+[stm32wl5e_base]
+platform = platformio/ststm32@^15.4.1
+board = generic_wl5e
+framework = arduino
+build_type = debug
+build_flags = 
+  ${arduino_base.build_flags}
+  -Isrc/platform/stm32wl -g
+  -DHAL_SUBGHZ_MODULE_ENABLED
+#  Arduino/PlatformIO framework-arduinoststm32 package does not presently have SUBGHZSPI support
+#  -DPIN_SPI_MOSI=PINSUBGHZSPIMOSI -DPIN_SPI_MISO=PINSUBGHZSPIMISO -DPIN_SPI_SCK=PINSUBGHZSPISCK
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<mqtt/> -<graphics> -<input> -<buzz> -<modules/Telemetry> -<platform/nrf52> -<platform/portduino> -<platform/rp2040>
+lib_deps =
+  ${env.lib_deps}
+  https://github.com/kokke/tiny-AES-c.git#f06ac37fc31dfdaca2e0d9bec83f90d5663c319b
+lib_ignore = 
+  mathertel/OneButton@^2.0.3

bin/build-all.sh

@@ -1,109 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-VERSION=`bin/buildinfo.py long`
-SHORT_VERSION=`bin/buildinfo.py short`
-
-BOARDS_ESP32="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"
-#BOARDS_ESP32=tbeam
-
-# FIXME note nrf52840dk build is for some reason only generating a BIN file but not a HEX file nrf52840dk-geeksville is fine
-BOARDS_NRF52="rak4631 rak4631_eink t-echo pca10059_diy_eink"
-#BOARDS_NRF52=""
-
-OUTDIR=release/latest
-
-# We keep all old builds (and their map files in the archive dir)
-ARCHIVEDIR=release/archive 
-
-rm -f $OUTDIR/firmware*
-
-mkdir -p $OUTDIR/bins $ARCHIVEDIR
-rm -r $OUTDIR/bins/* || true
-mkdir -p $OUTDIR/bins/universal $OUTDIR/elfs/universal
-
-# build the named environment and copy the bins to the release directory
-function do_build() {
-	BOARD=$1
-	isNrf=$3
-	
-    echo "Building for $BOARD ($isNrf) with $PLATFORMIO_BUILD_FLAGS"
-    rm -f .pio/build/$BOARD/firmware.*
-
-    # The shell vars the build tool expects to find
-    export APP_VERSION=$VERSION
-
-    basename=universal/firmware-$BOARD-$VERSION
-
-    pio run --environment $BOARD # -v
-    SRCELF=.pio/build/$BOARD/firmware.elf
-    cp $SRCELF $OUTDIR/elfs/$basename.elf
-
-    if [ "$isNrf" = "false" ]
-    then
-        echo "Copying ESP32 bin file"
-        SRCBIN=.pio/build/$BOARD/firmware.bin
-        cp $SRCBIN $OUTDIR/bins/$basename.bin
-    else
-        echo "Generating NRF52 uf2 file"
-        SRCHEX=.pio/build/$BOARD/firmware.hex
-        bin/uf2conv.py $SRCHEX -c -o $OUTDIR/bins/$basename.uf2 -f 0xADA52840
-    fi
-}
-
-function do_boards() {
-	declare boards=$1
-	declare isNrf=$2
-	for board in $boards; do
-		# Build universal
-        echo "about to build $board $isNrf"
-		do_build $board "" "$isNrf" 
-	done
-}
-
-# Make sure our submodules are current
-git submodule update 
-
-# Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio lib update 
-
-do_boards "$BOARDS_ESP32" "false"
-do_boards "$BOARDS_NRF52" "true"
-
-pio run --environment native
-cp .pio/build/native/program $OUTDIR/bins/universal/meshtasticd_linux_amd64
-
-echo "Building Filesystem for ESP32 targets"
-pio run --environment tbeam -t buildfs
-cp .pio/build/tbeam/spiffs.bin $OUTDIR/bins/universal/littlefs-$VERSION.bin
-
-# keep the bins in archive also
-cp $OUTDIR/bins/universal/littlefs* $OUTDIR/bins/universal/firmware* $OUTDIR/elfs/universal/firmware* $ARCHIVEDIR
-
-echo Updating android bins $OUTDIR/forandroid
-rm -rf $OUTDIR/forandroid
-mkdir -p $OUTDIR/forandroid
-cp -a $OUTDIR/bins/universal/*.bin $OUTDIR/forandroid/
-
-cat >$OUTDIR/curfirmwareversion.xml <<XML
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- This file is kept in source control because it reflects the last stable
-release.  It is used by the android app for forcing software updates.  Do not edit.
-Generated by bin/buildall.sh -->
-
-<resources>
-    <string name="cur_firmware_version" translatable="false">$VERSION</string>
-    <string name="short_firmware_version" translatable="false">$SHORT_VERSION</string>
-</resources>
-XML
-
-echo Generating $ARCHIVEDIR/firmware-$VERSION.zip
-rm -f $ARCHIVEDIR/firmware-$VERSION.zip
-zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/littlefs-$VERSION.bin $OUTDIR/bins/universal/firmware-*-$VERSION.* $OUTDIR/bins/universal/meshtasticd* images/system-info.bin bin/device-install.* bin/device-update.*
-echo Generating $ARCHIVEDIR/elfs-$VERSION.zip
-rm -f $ARCHIVEDIR/elfs-$VERSION.zip
-zip --junk-paths $ARCHIVEDIR/elfs-$VERSION.zip $OUTDIR/elfs/universal/firmware-*-$VERSION.*
-
-echo BUILT ALL

bin/build-esp32.sh

@@ -10,11 +10,8 @@ OUTDIR=release/
 rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
-# Make sure our submodules are current
-git submodule update 
-
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio lib update 
+platformio pkg update 
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f .pio/build/$1/firmware.*
@@ -29,13 +26,15 @@ SRCELF=.pio/build/$1/firmware.elf
 cp $SRCELF $OUTDIR/$basename.elf
 
 echo "Copying ESP32 bin file"
-SRCBIN=.pio/build/$1/firmware.bin
+SRCBIN=.pio/build/$1/firmware.factory.bin
 cp $SRCBIN $OUTDIR/$basename.bin
 
+echo "Copying ESP32 update bin file"
+SRCBIN=.pio/build/$1/firmware.bin
+cp $SRCBIN $OUTDIR/$basename-update.bin
+
 echo "Building Filesystem for ESP32 targets"
 pio run --environment tbeam -t buildfs
-cp .pio/build/tbeam/spiffs.bin $OUTDIR/littlefs-$VERSION.bin
+cp .pio/build/tbeam/littlefs.bin $OUTDIR/littlefs-$VERSION.bin
-cp images/system-info.bin $OUTDIR/system-info.bin
-
 cp bin/device-install.* $OUTDIR
 cp bin/device-update.* $OUTDIR

bin/build-native.sh

@@ -12,11 +12,8 @@ rm -f $OUTDIR/firmware*
 mkdir -p $OUTDIR/
 rm -r $OUTDIR/* || true
 
-# Make sure our submodules are current
-git submodule update 
-
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio lib update 
+platformio pkg update 
 
 pio run --environment native
 cp .pio/build/native/program $OUTDIR/meshtasticd_linux_amd64

bin/build-nrf52.sh

@@ -10,11 +10,8 @@ OUTDIR=release/
 rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
-# Make sure our submodules are current
-git submodule update 
-
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio lib update 
+platformio pkg update 
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f .pio/build/$1/firmware.*
@@ -26,7 +23,9 @@ basename=firmware-$1-$VERSION
 
 pio run --environment $1 # -v
 SRCELF=.pio/build/$1/firmware.elf
+DFUPKG=.pio/build/$1/firmware.zip
 cp $SRCELF $OUTDIR/$basename.elf
+cp $DFUPKG $OUTDIR/$basename-ota.zip
 
 echo "Generating NRF52 uf2 file"
 SRCHEX=.pio/build/$1/firmware.hex
@@ -34,3 +33,4 @@ bin/uf2conv.py $SRCHEX -c -o $OUTDIR/$basename.uf2 -f 0xADA52840
 
 cp bin/device-install.* $OUTDIR
 cp bin/device-update.* $OUTDIR
+cp bin/*.uf2 $OUTDIR

bin/build-rpi2040.sh

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

bin/bump_version.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+"""Bump the version number"""
+
+lines = None
+
+with open('version.properties', 'r', encoding='utf-8') as f:
+    lines = f.readlines()
+
+with open('version.properties', 'w', encoding='utf-8') as f:
+    for line in lines:
+        if line.lstrip().startswith("build = "):
+            words = line.split(" = ")
+            ver = f'build = {int(words[1]) + 1}'
+            f.write(f'{ver}\n')
+        else:
+            f.write(line)

bin/check-dependencies.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# Note: This is a prototype for how we could add static code analysis to the CI.
+
+set -e
+
+if [[ $# -gt 0 ]]; then
+    # 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"
+fi
+
+echo "BOARDS:${BOARDS}"
+
+CHECK=""
+for BOARD in $BOARDS; do
+     CHECK="${CHECK} -e ${BOARD}"
+done
+
+echo $CHECK
+
+pio pkg outdated -e $CHECK

bin/device-install.bat

@@ -26,14 +26,17 @@ IF "__%FILENAME%__" == "____" (
     echo "Missing FILENAME"
 	goto HELP
 )
-IF EXIST %FILENAME% (
+IF EXIST %FILENAME% IF x%FILENAME:update=%==x%FILENAME% (
     echo Trying to flash update %FILENAME%, but first erasing and writing system information"
 	%PYTHON% -m esptool --baud 115200 erase_flash
-	%PYTHON% -m esptool --baud 115200 write_flash 0x1000 system-info.bin
+	%PYTHON% -m esptool --baud 115200 write_flash 0x00 %FILENAME%
+	%PYTHON% -m esptool --baud 115200 write_flash 0x260000 bleota.bin
     for %%f in (littlefs-*.bin) do (
-        %PYTHON% -m esptool --baud 115200 write_flash 0x00390000 %%f
+        %PYTHON% -m esptool --baud 115200 write_flash 0x300000 %%f
     )
-	%PYTHON% -m esptool --baud 115200 write_flash 0x10000 %FILENAME%
+) else (
+    echo "Invalid file: %FILENAME%"
+	goto HELP
 ) else (
     echo "Invalid file: %FILENAME%"
 	goto HELP

bin/device-install.sh

@@ -14,6 +14,7 @@ Flash image file to device, but first erasing and writing system information"
     -p ESPTOOL_PORT  Set the environment variable for ESPTOOL_PORT.  If not set, ESPTOOL iterates all ports (Dangerous).
     -P PYTHON        Specify alternate python interpreter to use to invoke esptool. (Default: "$PYTHON")
     -f FILENAME      The .bin file to flash.  Custom to your device type and region.
+
 EOF
 }
 
@@ -44,15 +45,16 @@ shift "$((OPTIND-1))"
     shift
 }
 
-if [ -f "${FILENAME}" ]; then
+if [ -f "${FILENAME}" ] && [ ! -z "${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 0x1000 system-info.bin
+	"$PYTHON" -m esptool  write_flash 0x00 ${FILENAME}
-	"$PYTHON" -m esptool  write_flash 0x00390000 littlefs-*.bin
+    "$PYTHON" -m esptool  write_flash 0x260000 bleota.bin
-	"$PYTHON" -m esptool  write_flash 0x10000 ${FILENAME}
+	"$PYTHON" -m esptool  write_flash 0x300000 littlefs-*.bin
+
 else
-	echo "Invalid file: ${FILENAME}"
 	show_help
+	echo "Invalid file: ${FILENAME}"
 fi
 
 exit 0

bin/device-update.bat

@@ -10,7 +10,7 @@ echo.
 echo     -h               Display this help and exit
 echo     -p ESPTOOL_PORT  Set the environment variable for ESPTOOL_PORT.  If not set, ESPTOOL iterates all ports (Dangerrous).
 echo     -P PYTHON        Specify alternate python interpreter to use to invoke esptool. (Default: %PYTHON%)
-echo     -f FILENAME      The .bin file to flash.  Custom to your device type and region.
+echo     -f FILENAME      The *update.bin file to flash.  Custom to your device type.
 goto EOF
 
 :GETOPTS
@@ -26,11 +26,12 @@ IF "__%FILENAME%__" == "____" (
     echo "Missing FILENAME"
 	goto HELP
 )
-IF EXIST %FILENAME% (
+IF EXIST %FILENAME% IF NOT x%FILENAME:update=%==x%FILENAME% (
     echo Trying to flash update %FILENAME%
     %PYTHON% -m esptool --baud 115200 write_flash 0x10000 %FILENAME%
-    echo Erasing the otadata partition, which will turn off flash flippy-flop and force the first image to be used
+) else (
-    %PYTHON% -m esptool --baud 115200 erase_region 0xe000 0x2000
+    echo "Invalid file: %FILENAME%"
+	goto HELP
 ) else (
     echo "Invalid file: %FILENAME%"
 	goto HELP

bin/device-update.sh

@@ -11,7 +11,8 @@ Flash image file to device, leave existing system intact."
     -h               Display this help and exit
     -p ESPTOOL_PORT  Set the environment variable for ESPTOOL_PORT.  If not set, ESPTOOL iterates all ports (Dangerrous).
     -P PYTHON        Specify alternate python interpreter to use to invoke esptool. (Default: "$PYTHON")
-    -f FILENAME      The .bin file to flash.  Custom to your device type and region.
+    -f FILENAME      The *update.bin file to flash.  Custom to your device type.
+    
 EOF
 }
 
@@ -42,14 +43,12 @@ shift "$((OPTIND-1))"
     shift
 }
 
-if [ -f "${FILENAME}" ]; then
+if [ -f "${FILENAME}" ] && [ -z "${FILENAME##*"update"*}" ]; then
-	echo "Trying to flash update ${FILENAME}."
+	printf "Trying to flash update ${FILENAME}"
 	$PYTHON -m esptool --baud 115200 write_flash 0x10000 ${FILENAME}
-	echo "Erasing the otadata partition, which will turn off flash flippy-flop and force the first image to be used"
-	$PYTHON -m esptool --baud 115200 erase_region 0xe000 0x2000
 else
-	echo "Invalid file: ${FILENAME}"
 	show_help
+	echo "Invalid file: ${FILENAME}"
 fi
 
 exit 0

bin/mklittlefs.py

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-import getopt
-import sys
-import os
-from littlefs import LittleFS
-from pathlib import Path
-
-print( "Building LittleFS image..." )
-
-argList = sys.argv[1:]
-arxx = { argList[i]: argList[i+1] for i in range(0, len(argList)-1, 2) }
-
-dataPath = arxx["-c"]
-blockSize = int(arxx["-b"])
-blockCount = int(arxx["-s"]) / blockSize
-
-cwd = os.getcwd()
-
-os.chdir(dataPath)
-
-fileList = []
-dirList = []
-
-for (dirpath, dirnames, filenames) in os.walk('.'):
-    for f in filenames:
-        if (f[:1] != '.'):
-            fileList.append( os.path.join(dirpath, f) )
-    for d in dirnames:
-        if (d[:1] != '.'):
-            dirList.append( os.path.join(dirpath, d) )
-
-fs = LittleFS(block_size=blockSize, block_count=blockCount) # create a 448kB partition
-
-for curDir in dirList:
-    print( "Creating dir " + curDir )
-    fs.mkdir( curDir )
-        
-for curFile in fileList:
-    print( "Adding file " + curFile )
-    with open( curFile, 'rb' ) as f:
-        data = f.read()
-
-    with fs.open( curFile, 'wb') as fh:
-        fh.write( data )
-
-outName = argList[-1]
-
-os.chdir(cwd)
-
-with open(outName, 'wb') as fh:
-    fh.write(fs.context.buffer)

bin/platformio-custom.py

@@ -1,24 +1,70 @@
-
-
 import subprocess
 import configparser
 import traceback
 import sys
+from os.path import join
 from readprops import readProps
 
 Import("env")
-env.Replace( MKSPIFFSTOOL=env.get("PROJECT_DIR") + '/bin/mklittlefs.py' )
+platform = env.PioPlatform()
-try:
+
-    import littlefs
+def esp32_create_combined_bin(source, target, env):
-except ImportError:
+    # this sub is borrowed from ESPEasy build toolchain. It's licensed under GPL V3
-    env.Execute("$PYTHONEXE -m pip install littlefs-python")
+    # https://github.com/letscontrolit/ESPEasy/blob/mega/tools/pio/post_esp32.py
+    print("Generating combined binary for serial flashing")
+
+    app_offset = 0x10000
+
+    new_file_name = env.subst("$BUILD_DIR/${PROGNAME}.factory.bin")
+    sections = env.subst(env.get("FLASH_EXTRA_IMAGES"))
+    firmware_name = env.subst("$BUILD_DIR/${PROGNAME}.bin")
+    chip = env.get("BOARD_MCU")
+    flash_size = env.BoardConfig().get("upload.flash_size")
+    flash_freq = env.BoardConfig().get("build.f_flash", '40m')
+    flash_freq = flash_freq.replace('000000L', 'm')
+    flash_mode = env.BoardConfig().get("build.flash_mode", "dio")
+    memory_type = env.BoardConfig().get("build.arduino.memory_type", "qio_qspi")
+    if flash_mode == "qio" or flash_mode == "qout":
+        flash_mode = "dio"
+    if memory_type == "opi_opi" or memory_type == "opi_qspi":
+        flash_mode = "dout"
+    cmd = [
+        "--chip",
+        chip,
+        "merge_bin",
+        "-o",
+        new_file_name,
+        "--flash_mode",
+        flash_mode,
+        "--flash_freq",
+        flash_freq,
+        "--flash_size",
+        flash_size,
+    ]
+
+    print("    Offset | File")
+    for section in sections:
+        sect_adr, sect_file = section.split(" ", 1)
+        print(f" -  {sect_adr} | {sect_file}")
+        cmd += [sect_adr, sect_file]
+
+    print(f" - {hex(app_offset)} | {firmware_name}")
+    cmd += [hex(app_offset), firmware_name]
+
+    print('Using esptool.py arguments: %s' % ' '.join(cmd))
+
+    esptool.main(cmd)
+
+if (platform.name == "espressif32"):
+    sys.path.append(join(platform.get_package_dir("tool-esptoolpy")))
+    import esptool
+    env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_create_combined_bin)    
 
 Import("projenv")
 
 prefsLoc = projenv["PROJECT_DIR"] + "/version.properties"
 verObj = readProps(prefsLoc)
 print("Using meshtastic platformio-custom.py, firmware version " + verObj['long'])
-# print("path is" + ','.join(sys.path))
 
 # General options that are passed to the C and C++ compilers
 projenv.Append(CCFLAGS=[

bin/promote-release.sh

@@ -9,9 +9,6 @@ VERSION=`bin/buildinfo.py long`
 # Must have a V prefix to trigger github
 git tag "v${VERSION}"
 
-# Commented out per https://github.com/meshtastic/Meshtastic-device/issues/947
-#git push root "v${VERSION}" # push the tag
-
 git push origin "v${VERSION}" # push the tag
 
 echo "Tag ${VERSION} pushed to github, github actions should now be building the draft release.  If it seems good, click to publish it"

bin/regen-protos.bat

@@ -1 +1,5 @@
-cd protobufs && ..\nanopb-0.4.6\generator-bin\protoc.exe --nanopb_out=-v:..\src\mesh\generated -I=..\protobufs *.proto
+cd protobufs && ..\nanopb-0.4.7\generator-bin\protoc.exe --nanopb_out=-v:..\src\mesh\generated -I=..\protobufs ..\protobufs\meshtastic\*.proto
+
+@REM cd ../src/mesh/generated/meshtastic
+@REM sed -i 's/#include "meshtastic/#include "./g' *
+@REM sed -i 's/meshtastic_//g' *

bin/regen-protos.sh

@@ -2,13 +2,18 @@
 
 set -e
 
-echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.6 to be located in the"
+echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.7 to be located in the"
-echo "meshtastic-device root directory if the following step fails, you should download the correct"
+echo "firmware root directory if the following step fails, you should download the correct"
-echo "prebuilt binaries for your computer into nanopb-0.4.6"
+echo "prebuilt binaries for your computer into nanopb-0.4.7"
 
 # the nanopb tool seems to require that the .options file be in the current directory!
 cd protobufs
-../nanopb-0.4.6/generator-bin/protoc --nanopb_out=-v:../src/mesh/generated -I=../protobufs *.proto
+../nanopb-0.4.7/generator-bin/protoc --nanopb_out=-v:../src/mesh/generated/ -I=../protobufs meshtastic/*.proto
+
+# 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."

boards/eink0.1.json

@@ -7,12 +7,7 @@
     "cpu": "cortex-m4",
     "extra_flags": "-DARDUINO_NRF52840_TTGO_EINK -DNRF52840_XXAA",
     "f_cpu": "64000000L",
-    "hwids": [
+    "hwids": [["0x239A", "0x4405"]],
-      [
-        "0x239A",
-        "0x4405"
-      ]
-    ],
     "usb_product": "TTGO_eink",
     "mcu": "nrf52840",
     "variant": "eink0.1",
@@ -30,19 +25,13 @@
       "settings_addr": "0xFF000"
     }
   },
-  "connectivity": [
+  "connectivity": ["bluetooth"],
-    "bluetooth"
-  ],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
-    "onboard_tools": [
+    "onboard_tools": ["jlink"],
-      "jlink"
-    ],
     "svd_path": "nrf52840.svd"
   },
-  "frameworks": [
+  "frameworks": ["arduino"],
-    "arduino"
-  ],
   "name": "TTGO eink (Adafruit BSP)",
   "upload": {
     "maximum_ram_size": 248832,
@@ -50,11 +39,7 @@
     "require_upload_port": true,
     "speed": 115200,
     "protocol": "jlink",
-    "protocols": [
+    "protocols": ["jlink", "nrfjprog", "stlink"]
-      "jlink",
-      "nrfjprog",
-      "stlink"
-    ]
   },
   "url": "FIXME",
   "vendor": "TTGO"

boards/generic_wl5e.json

@@ -0,0 +1,27 @@
+{
+  "build": {
+    "core": "stm32",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DSTM32WLxx -DSTM32WLE5xx -DARDUINO_GENERIC_WLE5CCUX",
+    "f_cpu": "48000000L",
+    "mcu": "stm32wle5ccu",
+    "variant": "STM32WLxx/WL54CCU_WL55CCU_WLE4C(8-B-C)U_WLE5C(8-B-C)U",
+    "product_line": "STM32WLE5xx"
+  },
+  "debug": {
+    "default_tools": ["stlink"],
+    "jlink_device": "STM32WLE5CC",
+    "openocd_target": "stm32wlx",
+    "svd_path": "STM32WLE5_CM4.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "BB-STM32WL",
+  "upload": {
+    "maximum_ram_size": 65536,
+    "maximum_size": 262144,
+    "protocol": "cmsis-dap",
+    "protocols": ["cmsis-dap"]
+  },
+  "url": "https://www.st.com/en/microcontrollers-microprocessors/stm32wl-series.html",
+  "vendor": "ST"
+}

boards/lora_isp4520.json

@@ -19,16 +19,12 @@
       "sd_fwid": "0x00B7"
     }
   },
-  "connectivity": [
+  "connectivity": ["bluetooth"],
-    "bluetooth"
-  ],
   "debug": {
     "jlink_device": "nRF52832_xxAA",
     "svd_path": "nrf52.svd"
   },
-  "frameworks": [
+  "frameworks": ["arduino"],
-    "arduino"
-  ],
   "name": "lora ISP4520",
   "upload": {
     "maximum_ram_size": 65536,
@@ -36,12 +32,7 @@
     "require_upload_port": true,
     "speed": 115200,
     "protocol": "nrfutil",
-    "protocols": [
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"]
-      "jlink",
-      "nrfjprog",
-      "nrfutil",
-      "stlink"
-    ]
   },
   "url": "",
   "vendor": "PsiSoft"

boards/nordic_pca10059.json

@@ -8,22 +8,10 @@
     "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
     "f_cpu": "64000000L",
     "hwids": [
-            [
+      ["0x239A", "0x8029"],
-                "0x239A",
+      ["0x239A", "0x0029"],
-                "0x8029"
+      ["0x239A", "0x002A"],
-            ],
+      ["0x239A", "0x802A"]
-            [
-                "0x239A",
-                "0x0029"
-            ],
-            [
-                "0x239A",
-                "0x002A"
-            ],
-            [
-                "0x239A",
-                "0x802A"
-            ]
     ],
     "usb_product": "PCA10059",
     "mcu": "nrf52840",
@@ -41,28 +29,19 @@
       "settings_addr": "0xFF000"
     }
   },
-    "connectivity": [
+  "connectivity": ["bluetooth"],
-        "bluetooth"
-    ],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "svd_path": "nrf52840.svd"
   },
-    "frameworks": [
+  "frameworks": ["arduino"],
-        "arduino"
-    ],
   "name": "nRF52840 Dongle",
   "upload": {
     "maximum_ram_size": 248832,
     "maximum_size": 815104,
     "speed": 115200,
     "protocol": "nrfutil",
-        "protocols": [
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
-            "jlink",
-            "nrfjprog",
-            "nrfutil",
-            "stlink"
-        ],
     "use_1200bps_touch": true,
     "require_upload_port": true,
     "wait_for_upload_port": true

boards/nrf52840_dk.json

@@ -43,5 +43,4 @@
   },
   "url": "https://meshtastic.org/",
   "vendor": "Nordic Semi"
-  }
+}
-  

boards/t-echo.json

@@ -7,12 +7,7 @@
     "cpu": "cortex-m4",
     "extra_flags": "-DARDUINO_NRF52840_TTGO_EINK -DNRF52840_XXAA",
     "f_cpu": "64000000L",
-    "hwids": [
+    "hwids": [["0x239A", "0x4405"]],
-      [
-        "0x239A",
-        "0x4405"
-      ]
-    ],
     "usb_product": "TTGO_eink",
     "mcu": "nrf52840",
     "variant": "t-echo",
@@ -30,31 +25,20 @@
       "settings_addr": "0xFF000"
     }
   },
-  "connectivity": [
+  "connectivity": ["bluetooth"],
-    "bluetooth"
-  ],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
-    "onboard_tools": [
+    "onboard_tools": ["jlink"],
-      "jlink"
-    ],
     "svd_path": "nrf52840.svd"
   },
-  "frameworks": [
+  "frameworks": ["arduino"],
-    "arduino"
-  ],
   "name": "TTGO eink (Adafruit BSP)",
   "upload": {
     "maximum_ram_size": 248832,
     "maximum_size": 815104,
     "speed": 115200,
     "protocol": "nrfutil",
-      "protocols": [
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
-          "jlink",
-          "nrfjprog",
-          "nrfutil",
-          "stlink"
-      ],
     "use_1200bps_touch": true,
     "require_upload_port": true,
     "wait_for_upload_port": true

boards/tbeam-s3-core.json

@@ -0,0 +1,37 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DLILYGO_TBEAM_S3_CORE",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "dio",
+    "hwids": [["0X303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "tbeam-s3-core"
+  },
+  "connectivity": ["wifi"],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino"],
+  "name": "LilyGo TBeam-S3-Core",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "http://www.lilygo.cn/",
+  "vendor": "LilyGo"
+}

boards/tlora-t3s3-v1.json

@@ -0,0 +1,37 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DLILYGO_T3S3_V1",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "dio",
+    "hwids": [["0X303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "tlora-t3s3-v1"
+  },
+  "connectivity": ["wifi"],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "LilyGo TLora-T3S3-V1",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "http://www.lilygo.cn/",
+  "vendor": "LilyGo"
+}

boards/wiscore_rak11200.json

@@ -1,6 +1,6 @@
 {
   "build": {
-    "arduino":{
+    "arduino": {
       "ldscript": "esp32_out.ld"
     },
     "core": "esp32",
@@ -11,26 +11,14 @@
     "mcu": "esp32",
     "variant": "WisCore_RAK11200_Board"
   },
-  "connectivity": [
+  "connectivity": ["wifi", "bluetooth", "ethernet", "can"],
-    "wifi",
+  "frameworks": ["arduino", "espidf"],
-    "bluetooth",
-    "ethernet",
-    "can"
-  ],
-  "frameworks": [
-    "arduino",
-    "espidf"
-  ],
   "name": "WisCore RAK11200 Board",
   "upload": {
     "flash_size": "4MB",
     "maximum_ram_size": 327680,
     "maximum_size": 4194304,
-    "protocols": [
+    "protocols": ["esptool", "espota", "ftdi"],
-      "esptool",
-      "espota",
-      "ftdi"
-    ],
     "require_upload_port": true,
     "speed": 460800
   },

boards/wiscore_rak4600.json

@@ -8,22 +8,10 @@
     "extra_flags": "-DNRF52832_XXAA -DNRF52",
     "f_cpu": "64000000L",
     "hwids": [
-      [
+      ["0x239A", "0x8029"],
-        "0x239A",
+      ["0x239A", "0x0029"],
-        "0x8029"
+      ["0x239A", "0x002A"],
-      ],
+      ["0x239A", "0x802A"]
-      [
-        "0x239A",
-        "0x0029"
-      ],
-      [
-        "0x239A",
-        "0x002A"
-      ],
-      [
-        "0x239A",
-        "0x802A"
-      ]
     ],
     "usb_product": "Feather nRF52832 Express",
     "mcu": "nrf52832",
@@ -41,17 +29,12 @@
       "variant": "nrf52_adafruit_feather"
     }
   },
-  "connectivity": [
+  "connectivity": ["bluetooth"],
-    "bluetooth"
-  ],
   "debug": {
     "jlink_device": "nRF52832_xxAA",
     "svd_path": "nrf52.svd"
   },
-  "frameworks": [
+  "frameworks": ["arduino", "zephyr"],
-    "arduino",
-    "zephyr"
-  ],
   "name": "Adafruit Bluefruit nRF52832 Feather",
   "upload": {
     "maximum_ram_size": 65536,
@@ -59,12 +42,7 @@
     "require_upload_port": true,
     "speed": 115200,
     "protocol": "nrfutil",
-    "protocols": [
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"]
-      "jlink",
-      "nrfjprog",
-      "nrfutil",
-      "stlink"
-    ]
   },
   "url": "https://www.adafruit.com/product/3406",
   "vendor": "Adafruit"

boards/wiscore_rak4631.json

@@ -8,22 +8,10 @@
     "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
     "f_cpu": "64000000L",
     "hwids": [
-            [
+      ["0x239A", "0x8029"],
-                "0x239A",
+      ["0x239A", "0x0029"],
-                "0x8029"
+      ["0x239A", "0x002A"],
-            ],
+      ["0x239A", "0x802A"]
-            [
-                "0x239A",
-                "0x0029"
-            ],
-            [
-                "0x239A",
-                "0x002A"
-            ],
-            [
-                "0x239A",
-                "0x802A"
-            ]
     ],
     "usb_product": "WisCore RAK4631 Board",
     "mcu": "nrf52840",
@@ -41,28 +29,19 @@
       "settings_addr": "0xFF000"
     }
   },
-    "connectivity": [
+  "connectivity": ["bluetooth"],
-        "bluetooth"
-    ],
   "debug": {
     "jlink_device": "nRF52840_xxAA",
     "svd_path": "nrf52840.svd"
   },
-    "frameworks": [
+  "frameworks": ["arduino"],
-        "arduino"
-    ],
   "name": "WisCore RAK4631 Board",
   "upload": {
     "maximum_ram_size": 248832,
     "maximum_size": 815104,
     "speed": 115200,
     "protocol": "nrfutil",
-        "protocols": [
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
-            "jlink",
-            "nrfjprog",
-            "nrfutil",
-            "stlink"
-        ],
     "use_1200bps_touch": true,
     "require_upload_port": true,
     "wait_for_upload_port": true

docker-compose.yml

@@ -0,0 +1,13 @@
+version: "3.7"
+
+services:
+  meshtastic-node:
+    build: .
+    deploy:
+      mode: replicated
+      replicas: 4
+    networks:
+      - mesh
+
+networks:
+  mesh:

partition-table.csv

@@ -1,8 +1,8 @@
 # FIXME! using the genpartitions based table doesn't work on TTGO so for now I stay with my old memory map
 # This is a layout for 4MB of flash
 # Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
+nvs,      data, nvs,     0x009000, 0x005000,
-otadata,  data, ota,     0xe000,  0x2000,
+otadata,  data, ota,     0x00e000, 0x002000,
-app0,     app,  ota_0,   0x10000, 0x1c0000,
+app,      app,  ota_0,   0x010000, 0x250000,
-app1,     app,  ota_1,   0x1d0000,0x1c0000,
+flashApp, app,  ota_1,   0x260000, 0x0A0000,
-spiffs,   data, spiffs,  0x390000,0x070000,
+spiffs,   data, spiffs,  0x300000, 0x100000,

platformio.ini

@@ -2,13 +2,14 @@
 ; 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
 ;default_envs = heltec-v1
 ;default_envs = heltec-v2.0
 ;default_envs = heltec-v2.1
 ;default_envs = tlora-v1
-;default_envs = tlora-v1
 ;default_envs = tlora_v1_3
 ;default_envs = tlora-v2
 ;default_envs = tlora-v2-1-1.6
@@ -20,9 +21,13 @@ default_envs = tbeam
 ;default_envs = pca10059_diy_eink
 ;default_envs = meshtastic-diy-v1
 ;default_envs = meshtastic-diy-v1.1
+;default_envs = meshtastic-dr-dev
 ;default_envs = m5stack-coreink
+;default_envs = rak4631
 
-extra_configs = variants/*/platformio.ini
+extra_configs =
+  arch/*/*.ini
+  variants/*/platformio.ini
 
 [env]
 extra_scripts = bin/platformio-custom.py 
@@ -31,47 +36,63 @@ extra_scripts = bin/platformio-custom.py
 ; note: TINYGPS_OPTION_NO_CUSTOM_FIELDS is VERY important.  We don't use custom fields and somewhere in that pile
 ; of code is a heap corruption bug!
 ; FIXME: fix lib/BluetoothOTA dependency back on src/ so we can remove -Isrc
+; The Radiolib stuff will speed up building considerably. Exclud all the stuff we dont need.
 build_flags = -Wno-missing-field-initializers
   -Wno-format 
-  -Isrc -Isrc/mesh -Isrc/gps -Isrc/buzz -Wl,-Map,.pio/build/output.map 
+  -Isrc -Isrc/mesh -Isrc/mesh/generated -Isrc/gps -Isrc/buzz -Wl,-Map,.pio/build/output.map 
   -DUSE_THREAD_NAMES
   -DTINYGPS_OPTION_NO_CUSTOM_FIELDS
   -DPB_ENABLE_MALLOC=1
+  -DRADIOLIB_EXCLUDE_CC1101
+  -DRADIOLIB_EXCLUDE_NRF24
+  -DRADIOLIB_EXCLUDE_RF69
+  -DRADIOLIB_EXCLUDE_SX1231
+  -DRADIOLIB_EXCLUDE_SI443X
+  -DRADIOLIB_EXCLUDE_RFM2X
+  -DRADIOLIB_EXCLUDE_AFSK
+  -DRADIOLIB_EXCLUDE_HELLSCHREIBER
+  -DRADIOLIB_EXCLUDE_MORSE
+  -DRADIOLIB_EXCLUDE_RTTY
+  -DRADIOLIB_EXCLUDE_SSTV
 
 monitor_speed = 115200
 
 lib_deps =
-  https://github.com/meshtastic/esp8266-oled-ssd1306.git#53580644255b48ebb7a737343c6b4e71c7e11cf2 ; ESP8266_SSD1306 
+  https://github.com/meshtastic/esp8266-oled-ssd1306.git#da1ede4dfcd91074283b029080759fd744120909 ; ESP8266_SSD1306 
   mathertel/OneButton@^2.0.3 ; OneButton library for non-blocking button debounce
-  1202 ; CRC32, explicitly needed because dependency is missing in the ble ota update lib
+  https://github.com/meshtastic/arduino-fsm.git#7db3702bf0cfe97b783d6c72595e3f38e0b19159
-  https://github.com/meshtastic/arduino-fsm.git
+  https://github.com/meshtastic/TinyGPSPlus.git#127ad674ef85f0201cb68a065879653ed94792c4
-  https://github.com/meshtastic/TinyGPSPlus.git
-  Wire ; explicitly needed here because the AXP202 library forgets to add it
-  SPI
   https://github.com/meshtastic/ArduinoThread.git#72921ac222eed6f526ba1682023cee290d9aa1b3
   nanopb/Nanopb@^0.4.6
+  erriez/ErriezCRC32@^1.0.1
+;  jgromes/RadioLib@^5.5.1
+  https://github.com/jgromes/RadioLib.git#7a25b27c3183ffe3627c5c221243c378d8951da7
 
 ; Used for the code analysis in PIO Home / Inspect
 check_tool = cppcheck
 check_skip_packages = yes
+check_flags =
+  -DAPP_VERSION=1.0.0
+  --suppressions-list=suppressions.txt
+  --inline-suppr
 
 ; Common settings for conventional (non Portduino) Arduino targets
 [arduino_base]
 framework = arduino
 lib_deps =
   ${env.lib_deps}
-  ; Portduino is using meshtastic fork for now
+  mprograms/QMC5883LCompass@^1.1.1
-  https://github.com/jgromes/RadioLib.git
+  end2endzone/NonBlockingRTTTL@^1.3.0
+  https://github.com/meshtastic/SparkFun_ATECCX08a_Arduino_Library.git#52b5282639d08a8cbd4b748363089eed6102dc76
 
-build_flags = ${env.build_flags} -Os 
+build_flags = ${env.build_flags} -Os -DRADIOLIB_SPI_PARANOID=0
-# -DRADIOLIB_GODMODE
+build_src_filter = ${env.build_src_filter} -<platform/portduino/>
-build_src_filter = ${env.build_src_filter} -<portduino/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT 
 [networking_base]
 lib_deps =
-  PubSubClient
+  knolleary/PubSubClient@^2.8
-  meshtastic/json11@^1.0.2
+  arduino-libraries/NTPClient@^3.1.0
 
 ; Common libs for environmental measurements in telemetry module 
 ; (not included in native / portduino)
@@ -79,89 +100,12 @@ lib_deps =
 lib_deps =
   adafruit/Adafruit BusIO@^1.11.4
   adafruit/Adafruit Unified Sensor@^1.1.4
-  paulstoffregen/OneWire@^2.3.5
+  adafruit/Adafruit BMP280 Library@^2.6.6
-  robtillaart/DS18B20@^0.1.11
-  adafruit/Adafruit BMP280 Library@^2.6.3
   adafruit/Adafruit BME280 Library@^2.2.2
   adafruit/Adafruit BME680 Library@^2.0.1
   adafruit/Adafruit MCP9808 Library@^2.0.0
   adafruit/Adafruit INA260 Library@^1.5.0
   adafruit/Adafruit INA219@^1.2.0
-; Common settings for ESP targes, mixin with extends = esp32_base
+  adafruit/Adafruit SHTC3 Library@^1.0.0
-[esp32_base]
+  adafruit/Adafruit LPS2X@^2.0.4
-extends = arduino_base
+  adafruit/Adafruit SHT31 Library@^2.2.0
-platform = espressif32@3.5.0
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<nrf52/> -<stm32wl>
-upload_speed = 115200
-debug_init_break = tbreak setup
-
-# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
-# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
-# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
-# -DUSE_NEW_ESP32_BLUETOOTH will enable the new NimBLE C++ api
-build_flags =
-  ${arduino_base.build_flags} -Wall -Wextra -Isrc/esp32 -Isrc/esp32-mfix-esp32-psram-cache-issue -lnimble -std=c++11 
-  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
-  -DAXP_DEBUG_PORT=Serial -DUSE_NEW_ESP32_BLUETOOTH -DCONFIG_BT_NIMBLE_ENABLED -DCONFIG_NIMBLE_CPP_LOG_LEVEL=1
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${networking_base.lib_deps}
-  ${environmental_base.lib_deps}
-  https://github.com/meshtastic/esp32_https_server.git
-  h2zero/NimBLE-Arduino@1.4.0
-  arduino-libraries/NTPClient@^3.1.0
-  lorol/LittleFS_esp32@^1.0.6
-  https://github.com/meshtastic/AXP202X_Library.git#8404abb6d4b486748636bc6ad72d2a47baaf5460
-
-lib_ignore = 
-  segger_rtt
-  ESP32 BLE Arduino
-platform_packages =
-    framework-arduinoespressif32@https://github.com/meshtastic/arduino-esp32.git#4cde0f5d412d2695184f32e8a47e9bea57b45276
-
-; leave this commented out to avoid breaking Windows
-;upload_port = /dev/ttyUSB0
-;monitor_port = /dev/ttyUSB0
-
-; Please don't delete these lines. JM uses them.
-;upload_port = /dev/cu.SLAB_USBtoUART
-;monitor_port = /dev/cu.SLAB_USBtoUART
-
-; customize the partition table
-; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
-board_build.partitions = partition-table.csv
-
-[nrf52_base]
-; Instead of the standard nordicnrf52 platform, we use our fork which has our added variant files
-; platform = nordicnrf52 ;pending https://github.com/platformio/builder-framework-arduino-nrf5/pull/7
-platform = https://github.com/meshtastic/platform-nordicnrf52.git#merge
-
-extends = arduino_base
-build_type = debug ; I'm debugging with ICE a lot now
-; note: liboberon provides the AES256 implementation for NRF52 (though not using the hardware acceleration of the NRF52840 - FIXME)
-build_flags = 
-  ${arduino_base.build_flags} -Wno-unused-variable 
-  -Isrc/nrf52
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<esp32/> -<stm32wl> -<nimble/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mqtt/>
-lib_ignore =
-  BluetoothOTA
-
-[nrf52840_base]
-extends = nrf52_base
-build_flags = ${nrf52_base.build_flags} 
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${environmental_base.lib_deps}
-  https://github.com/Kongduino/Adafruit_nRFCrypto.git
-
-; Note: By default no lora device is created for this build - it uses a simulated interface
-[env:nrf52840dk]
-extends = nrf52840_base
-board = nrf52840_dk
-
-; Note: By default no lora device is created for this build - it uses a simulated interface
-[env:feather_nrf52832]
-extends = nrf52_base
-board = adafruit_feather_nrf52832

src/BluetoothCommon.cpp

@@ -1,5 +1,5 @@
-#include "configuration.h"
 #include "BluetoothCommon.h"
+#include "configuration.h"
 
 // NRF52 wants these constants as byte arrays
 // Generated here https://yupana-engineering.com/online-uuid-to-c-array-converter - but in REVERSE BYTE ORDER
@@ -7,7 +7,7 @@ const uint8_t MESH_SERVICE_UUID_16[16u] = {0xfd, 0xea, 0x73, 0xe2, 0xca, 0x5d, 0
                                            0x1f, 0x46, 0xa8, 0x15, 0x18, 0xb2, 0xa1, 0x6b};
 const uint8_t TORADIO_UUID_16[16u] = {0xe7, 0x01, 0x44, 0x12, 0x66, 0x78, 0xdd, 0xa1,
                                       0xad, 0x4d, 0x9e, 0x12, 0xd2, 0x76, 0x5c, 0xf7};
-const uint8_t FROMRADIO_UUID_16[16u] = {0xd5, 0x54, 0xe4, 0xc5, 0x25, 0xc5, 0x31, 0xa5,
+const uint8_t FROMRADIO_UUID_16[16u] = {0x02, 0x00, 0x12, 0xac, 0x42, 0x02, 0x78, 0xb8,
-                                        0x55, 0x4a, 0x02, 0xee, 0xc2, 0xbc, 0xa2, 0x8b};
+                                        0xed, 0x11, 0x93, 0x49, 0x9e, 0xe6, 0x55, 0x2c};
 const uint8_t FROMNUM_UUID_16[16u] = {0x53, 0x44, 0xe3, 0x47, 0x75, 0xaa, 0x70, 0xa6,
                                       0x66, 0x4f, 0x00, 0xa8, 0x8c, 0xa1, 0x9d, 0xed};

src/BluetoothCommon.h

@@ -9,7 +9,7 @@
 #define MESH_SERVICE_UUID "6ba1b218-15a8-461f-9fa8-5dcae273eafd"
 
 #define TORADIO_UUID "f75c76d2-129e-4dad-a1dd-7866124401e7"
-#define FROMRADIO_UUID "8ba2bcc2-ee02-4a55-a531-c525c5e454d5"
+#define FROMRADIO_UUID "2c55e69e-4993-11ed-b878-0242ac120002"
 #define FROMNUM_UUID "ed9da18c-a800-4f66-a670-aa7547e34453"
 
 // NRF52 wants these constants as byte arrays

src/ButtonThread.h

@@ -7,10 +7,6 @@
 #include "power.h"
 #include <OneButton.h>
 
-#ifdef ARCH_ESP32
-#include "nimble/BluetoothUtil.h"
-#endif
-
 namespace concurrency
 {
 /**
@@ -55,6 +51,7 @@ class ButtonThread : public concurrency::OSThread
         pinMode(BUTTON_PIN, INPUT_PULLUP_SENSE);
 #endif
         userButton.attachClick(userButtonPressed);
+        userButton.setClickTicks(300);
         userButton.attachDuringLongPress(userButtonPressedLong);
         userButton.attachDoubleClick(userButtonDoublePressed);
         userButton.attachMultiClick(userButtonMultiPressed);
@@ -101,8 +98,8 @@ class ButtonThread : public concurrency::OSThread
         userButtonTouch.tick();
         canSleep &= userButtonTouch.isIdle();
 #endif
-        // if (!canSleep) DEBUG_MSG("Supressing sleep!\n");
+        // if (!canSleep) LOG_DEBUG("Supressing sleep!\n");
-        // else DEBUG_MSG("sleep ok\n");
+        // else LOG_DEBUG("sleep ok\n");
 
         return 5;
     }
@@ -111,29 +108,28 @@ class ButtonThread : public concurrency::OSThread
     static void touchPressed()
     {
         screen->forceDisplay();
-        DEBUG_MSG("touch press!\n");
+        LOG_DEBUG("touch press!\n");
     }
 
     static void userButtonPressed()
     {
-        // DEBUG_MSG("press!\n");
+        // LOG_DEBUG("press!\n");
 #ifdef BUTTON_PIN
-        if ((BUTTON_PIN != moduleConfig.canned_message.inputbroker_pin_press) ||
+        if ((BUTTON_PIN != moduleConfig.canned_message.inputbroker_pin_press) || !moduleConfig.canned_message.enabled) {
-            !moduleConfig.canned_message.enabled) {
             powerFSM.trigger(EVENT_PRESS);
         }
 #endif
     }
     static void userButtonPressedLong()
     {
-        // DEBUG_MSG("Long press!\n");
+        // LOG_DEBUG("Long press!\n");
 #ifdef ARCH_ESP32
         screen->adjustBrightness();
 #endif
         // If user button is held down for 5 seconds, shutdown the device.
         if ((millis() - longPressTime > 5 * 1000) && (longPressTime > 0)) {
-#ifdef TBEAM_V10
+#ifdef HAS_PMU
-            if (axp192_found == true) {
+            if (pmu_found == true) {
                 setLed(false);
                 power->shutdown();
             }
@@ -142,7 +138,7 @@ class ButtonThread : public concurrency::OSThread
             // may wake the board immediatedly.
             if ((!shutdown_on_long_stop) && (millis() > 30 * 1000)) {
                 screen->startShutdownScreen();
-                DEBUG_MSG("Shutdown from long press");
+                LOG_INFO("Shutdown from long press");
                 playBeep();
 #ifdef PIN_LED1
                 ledOff(PIN_LED1);
@@ -157,33 +153,37 @@ class ButtonThread : public concurrency::OSThread
             }
 #endif
         } else {
-            // DEBUG_MSG("Long press %u\n", (millis() - longPressTime));
+            // LOG_DEBUG("Long press %u\n", (millis() - longPressTime));
         }
     }
 
     static void userButtonDoublePressed()
     {
-#ifdef ARCH_ESP32
+#if defined(USE_EINK) && defined(PIN_EINK_EN)
-        disablePin();
-#elif defined(USE_EINK)
         digitalWrite(PIN_EINK_EN, digitalRead(PIN_EINK_EN) == LOW);
 #endif
+        screen->print("Sent ad-hoc ping\n");
+        service.refreshMyNodeInfo();
+        service.sendNetworkPing(NODENUM_BROADCAST, true);
     }
 
     static void userButtonMultiPressed()
     {
-#ifdef ARCH_ESP32
+#if defined(GPS_POWER_TOGGLE)
-        clearNVS();
+        if (config.position.gps_enabled) {
-#endif
+            LOG_DEBUG("Flag set to false for gps power\n");
-#ifdef ARCH_NRF52
+        } else {
-        clearBonds();
+            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) {
-            DEBUG_MSG("Long press start!\n");
+            LOG_DEBUG("Long press start!\n");
             longPressTime = millis();
         }
     }
@@ -191,7 +191,7 @@ class ButtonThread : public concurrency::OSThread
     static void userButtonPressedLongStop()
     {
         if (millis() > 30 * 1000) {
-            DEBUG_MSG("Long press stop!\n");
+            LOG_DEBUG("Long press stop!\n");
             longPressTime = 0;
             if (shutdown_on_long_stop) {
                 playShutdownMelody();

src/DebugConfiguration.h

@@ -13,17 +13,33 @@
 #define SERIAL_BAUD 115200 // Serial debug baud rate
 #endif
 
+#define MESHTASTIC_LOG_LEVEL_DEBUG "DEBUG"
+#define MESHTASTIC_LOG_LEVEL_INFO "INFO "
+#define MESHTASTIC_LOG_LEVEL_WARN "WARN "
+#define MESHTASTIC_LOG_LEVEL_ERROR "ERROR"
+#define MESHTASTIC_LOG_LEVEL_TRACE "TRACE"
+
 #include "SerialConsole.h"
 
 #define DEBUG_PORT (*console) // Serial debug port
 
 #ifdef USE_SEGGER
-#define DEBUG_MSG(...) SEGGER_RTT_printf(0, __VA_ARGS__)
+#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__)
+#define LOG_ERROR(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #else
 #ifdef DEBUG_PORT
-#define DEBUG_MSG(...) DEBUG_PORT.logDebug(__VA_ARGS__)
+#define LOG_DEBUG(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_DEBUG, __VA_ARGS__)
+#define LOG_INFO(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_INFO, __VA_ARGS__)
+#define LOG_WARN(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_WARN, __VA_ARGS__)
+#define LOG_ERROR(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_ERROR, __VA_ARGS__)
+#define LOG_TRACE(...) DEBUG_PORT.log(MESHTASTIC_LOG_TRACE, __VA_ARGS__)
 #else
-#define DEBUG_MSG(...)
+#define LOG_DEBUG(...)
+#define LOG_INFO(...)
+#define LOG_WARN(...)
+#define LOG_ERROR(...)
 #endif
 #endif
 

src/FSCommon.cpp

@@ -1,21 +1,31 @@
-#include "configuration.h"
 #include "FSCommon.h"
+#include "configuration.h"
 
+#ifdef HAS_SDCARD
+#include <SD.h>
+#include <SPI.h>
 
-bool copyFile(const char* from, const char* to)
+#ifdef SDCARD_USE_SPI1
+SPIClass SPI1(HSPI);
+#define SDHandler SPI1
+#endif
+
+#endif // HAS_SDCARD
+
+bool copyFile(const char *from, const char *to)
 {
 #ifdef FSCom
     unsigned char cbuffer[16];
 
     File f1 = FSCom.open(from, FILE_O_READ);
-    if (!f1){
+    if (!f1) {
-        DEBUG_MSG("Failed to open file");
+        LOG_ERROR("Failed to open source file %s\n", from);
         return false;
     }
 
     File f2 = FSCom.open(to, FILE_O_WRITE);
     if (!f2) {
-        DEBUG_MSG("Failed to open file");
+        LOG_ERROR("Failed to open destination file %s\n", to);
         return false;
     }
 
@@ -30,94 +40,173 @@ bool copyFile(const char* from, const char* to)
 #endif
 }
 
-bool renameFile(const char* pathFrom, const char* pathTo)
+bool renameFile(const char *pathFrom, const char *pathTo)
 {
 #ifdef FSCom
-    if (copyFile(pathFrom, pathTo) && FSCom.remove(pathFrom) ) {
+#ifdef ARCH_ESP32
+    // rename was fixed for ESP32 IDF LittleFS in April
+    return FSCom.rename(pathFrom, pathTo);
+#else
+    if (copyFile(pathFrom, pathTo) && FSCom.remove(pathFrom)) {
         return true;
-    } else{
+    } else {
         return false;
     }
 #endif
+#endif
 }
 
-void listDir(const char * dirname, uint8_t levels)
+void listDir(const char *dirname, uint8_t levels, boolean del = false)
 {
 #ifdef FSCom
-    File root = FSCom.open(dirname);
+#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-    if(!root){
+    char buffer[255];
+#endif
+    File root = FSCom.open(dirname, FILE_O_READ);
+    if (!root) {
         return;
     }
-    if(!root.isDirectory()){
+    if (!root.isDirectory()) {
         return;
     }
 
     File file = root.openNextFile();
-    while(file){
+    while (file) {
-        if(file.isDirectory() && !String(file.name()).endsWith(".")) {
+        if (file.isDirectory() && !String(file.name()).endsWith(".")) {
-            if(levels){
+            if (levels) {
-                listDir(file.name(), levels -1);
+#ifdef ARCH_ESP32
+                listDir(file.path(), levels - 1, del);
+                if (del) {
+                    LOG_DEBUG("Removing %s\n", file.path());
+                    strncpy(buffer, file.path(), sizeof(buffer));
+                    file.close();
+                    FSCom.rmdir(buffer);
+                } else {
+                    file.close();
+                }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+                listDir(file.name(), levels - 1, del);
+                if (del) {
+                    LOG_DEBUG("Removing %s\n", file.name());
+                    strncpy(buffer, file.name(), sizeof(buffer));
+                    file.close();
+                    FSCom.rmdir(buffer);
+                } else {
+                    file.close();
+                }
+#else
+                listDir(file.name(), levels - 1, del);
+                file.close();
+#endif
             }
         } else {
-            DEBUG_MSG("  %s (%i Bytes)\n", file.name(), file.size());
+#ifdef ARCH_ESP32
-        }
+            if (del) {
+                LOG_DEBUG("Deleting %s\n", file.path());
+                strncpy(buffer, file.path(), sizeof(buffer));
                 file.close();
+                FSCom.remove(buffer);
+            } else {
+                LOG_DEBUG(" %s (%i Bytes)\n", file.path(), file.size());
+                file.close();
+            }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+            if (del) {
+                LOG_DEBUG("Deleting %s\n", file.name());
+                strncpy(buffer, file.name(), sizeof(buffer));
+                file.close();
+                FSCom.remove(buffer);
+            } else {
+                LOG_DEBUG(" %s (%i Bytes)\n", file.name(), file.size());
+                file.close();
+            }
+#else
+            LOG_DEBUG(" %s (%i Bytes)\n", file.name(), file.size());
+            file.close();
+#endif
+        }
         file = root.openNextFile();
     }
-    file.close();
+#ifdef ARCH_ESP32
+    if (del) {
+        LOG_DEBUG("Removing %s\n", root.path());
+        strncpy(buffer, root.path(), sizeof(buffer));
+        root.close();
+        FSCom.rmdir(buffer);
+    } else {
+        root.close();
+    }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+    if (del) {
+        LOG_DEBUG("Removing %s\n", root.name());
+        strncpy(buffer, root.name(), sizeof(buffer));
+        root.close();
+        FSCom.rmdir(buffer);
+    } else {
+        root.close();
+    }
+#else
+    root.close();
+#endif
 #endif
 }
 
-void rmDir(const char * dirname)
+void rmDir(const char *dirname)
 {
 #ifdef FSCom
-    File file = FSCom.open(dirname);
+#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-    if(!file){
+    listDir(dirname, 10, true);
-        return;
+#elif defined(ARCH_NRF52)
-    }
+    // nRF52 implementation of LittleFS has a recursive delete function
-    if(!file.isDirectory()){
+    FSCom.rmdir_r(dirname);
-        file.close();
+#endif
-        FSCom.remove(file.name());
-      //  DEBUG_MSG("Remove FILE  %s\n", file.name());
-        return;
-    }
-
-    file.rewindDirectory();
-    while (true) {
-        File entry = file.openNextFile();
-        if (!entry) {
-          break;
-        }
-        char dirpath[100];   // array to hold the result.
-        strcpy(dirpath, dirname); // copy string one into the result.
-        strcat(dirpath,"/"); // append string two to the result.
-        strcat(dirpath,entry.name()); // append string two to the result.
-        if(entry.isDirectory() && !String(entry.name()).endsWith(".")) {
-            entry.close();
-         //   DEBUG_MSG("Descend DIR  %s\n", dirpath);
-            rmDir(dirpath);
-        } else {
-            entry.close();
-         //   DEBUG_MSG("Remove FILE  %s\n", entry.name());
-            FSCom.remove(entry.name());
-        }
-    }
-    FSCom.rmdir(dirname);
-   // DEBUG_MSG("Remove DIR  %s\n", dirname);
-    file.close();
 #endif
 }
 
 void fsInit()
 {
 #ifdef FSCom
-    if (!FSBegin())
+    if (!FSBegin()) {
-    {
+        LOG_ERROR("Filesystem mount Failed.\n");
-        DEBUG_MSG("ERROR filesystem mount Failed. Formatting...\n");
+        // assert(0); This auto-formats the partition, so no need to fail here.
-        assert(0); // FIXME - report failure to phone
     }
-
+#ifdef ARCH_ESP32
-    DEBUG_MSG("Filesystem files:\n");
+    LOG_DEBUG("Filesystem files (%d/%d Bytes):\n", FSCom.usedBytes(), FSCom.totalBytes());
+#else
+    LOG_DEBUG("Filesystem files:\n");
+#endif
     listDir("/", 10);
 #endif
 }
+
+void setupSDCard()
+{
+#ifdef HAS_SDCARD
+    SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
+
+    if (!SD.begin(SDCARD_CS, SDHandler)) {
+        LOG_DEBUG("No SD_MMC card detected\n");
+        return;
+    }
+    uint8_t cardType = SD.cardType();
+    if (cardType == CARD_NONE) {
+        LOG_DEBUG("No SD_MMC card attached\n");
+        return;
+    }
+    LOG_DEBUG("SD_MMC Card Type: ");
+    if (cardType == CARD_MMC) {
+        LOG_DEBUG("MMC\n");
+    } else if (cardType == CARD_SD) {
+        LOG_DEBUG("SDSC\n");
+    } else if (cardType == CARD_SDHC) {
+        LOG_DEBUG("SDHC\n");
+    } else {
+        LOG_DEBUG("UNKNOWN\n");
+    }
+
+    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
+    LOG_DEBUG("SD Card Size: %lluMB\n", cardSize);
+    LOG_DEBUG("Total space: %llu MB\n", SD.totalBytes() / (1024 * 1024));
+    LOG_DEBUG("Used space: %llu MB\n", SD.usedBytes() / (1024 * 1024));
+#endif
+}

src/FSCommon.h

@@ -13,11 +13,20 @@
 #define FILE_O_READ "r"
 #endif
 
+#if defined(ARCH_RP2040)
+// RP2040
+#include "LittleFS.h"
+#define FSCom LittleFS
+#define FSBegin() FSCom.begin() // set autoformat
+#define FILE_O_WRITE "w"
+#define FILE_O_READ "r"
+#endif
+
 #if defined(ARCH_ESP32)
 // ESP32 version
-#include "LITTLEFS.h"
+#include "LittleFS.h"
-#define FSCom LITTLEFS
+#define FSCom LittleFS
-#define FSBegin() FSCom.begin(true)
+#define FSBegin() FSCom.begin(true) // format on failure
 #define FILE_O_WRITE "w"
 #define FILE_O_READ "r"
 #endif
@@ -26,11 +35,13 @@
 // NRF52 version
 #include "InternalFileSystem.h"
 #define FSCom InternalFS
-#define FSBegin() FSCom.begin()
+#define FSBegin() FSCom.begin() // InternalFS formats on failure
 using namespace Adafruit_LittleFS_Namespace;
 #endif
 
 void fsInit();
-bool renameFile(const char* pathFrom, const char* pathTo);
+bool copyFile(const char *from, const char *to);
-void listDir(const char * dirname, uint8_t levels);
+bool renameFile(const char *pathFrom, const char *pathTo);
-void rmDir(const char * dirname);
+void listDir(const char *dirname, uint8_t levels, boolean del);
+void rmDir(const char *dirname);
+void setupSDCard();

src/GPSStatus.h

@@ -20,32 +20,19 @@ class GPSStatus : public Status
     bool hasLock = false;     // default to false, until we complete our first read
     bool isConnected = false; // Do we have a GPS we are talking to
 
-    Position p = Position_init_default;
+    bool isPowerSaving = false; // Are we in power saving state
+
+    meshtastic_Position p = meshtastic_Position_init_default;
 
   public:
     GPSStatus() { statusType = STATUS_TYPE_GPS; }
 
-    // proposed for deprecation
-    GPSStatus(bool hasLock, bool isConnected, int32_t latitude, int32_t longitude, int32_t altitude, uint32_t dop,
-              uint32_t heading, uint32_t numSatellites)
-        : Status()
-    {
-        this->hasLock = hasLock;
-        this->isConnected = isConnected;
-
-        this->p.latitude_i = latitude;
-        this->p.longitude_i = longitude;
-        this->p.altitude = altitude;
-        this->p.PDOP = dop;
-        this->p.ground_track = heading;
-        this->p.sats_in_view = numSatellites;
-    }
-
     // preferred method
-    GPSStatus(bool hasLock, bool isConnected, const Position &pos) : Status()
+    GPSStatus(bool hasLock, bool isConnected, bool isPowerSaving, const meshtastic_Position &pos) : Status()
     {
         this->hasLock = hasLock;
         this->isConnected = isConnected;
+        this->isPowerSaving = isPowerSaving;
 
         // all-in-one struct copy
         this->p = pos;
@@ -60,13 +47,15 @@ class GPSStatus : public Status
 
     bool getIsConnected() const { return isConnected; }
 
+    bool getIsPowerSaving() const { return isPowerSaving; }
+
     int32_t getLatitude() const
     {
         if (config.position.fixed_position) {
 #ifdef GPS_EXTRAVERBOSE
-            DEBUG_MSG("WARNING: Using fixed latitude\n");
+            LOG_WARN("Using fixed latitude\n");
 #endif
-            NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
+            meshtastic_NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
             return node->position.latitude_i;
         } else {
             return p.latitude_i;
@@ -77,9 +66,9 @@ class GPSStatus : public Status
     {
         if (config.position.fixed_position) {
 #ifdef GPS_EXTRAVERBOSE
-            DEBUG_MSG("WARNING: Using fixed longitude\n");
+            LOG_WARN("Using fixed longitude\n");
 #endif
-            NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
+            meshtastic_NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
             return node->position.longitude_i;
         } else {
             return p.longitude_i;
@@ -90,30 +79,40 @@ class GPSStatus : public Status
     {
         if (config.position.fixed_position) {
 #ifdef GPS_EXTRAVERBOSE
-            DEBUG_MSG("WARNING: Using fixed altitude\n");
+            LOG_WARN("Using fixed altitude\n");
 #endif
-            NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
+            meshtastic_NodeInfo *node = nodeDB.getNode(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
     {
 #ifdef GPS_EXTRAVERBOSE
-        DEBUG_MSG("GPSStatus.match() new pos@%x to old pos@%x\n", newStatus->p.pos_timestamp, p.pos_timestamp);
+        LOG_DEBUG("GPSStatus.match() new pos@%x to old pos@%x\n", newStatus->p.pos_timestamp, p.pos_timestamp);
 #endif
         return (newStatus->hasLock != hasLock || newStatus->isConnected != isConnected ||
-                newStatus->p.latitude_i != p.latitude_i || newStatus->p.longitude_i != p.longitude_i ||
+                newStatus->isPowerSaving != isPowerSaving || newStatus->p.latitude_i != p.latitude_i ||
-                newStatus->p.altitude != p.altitude || newStatus->p.altitude_hae != p.altitude_hae ||
+                newStatus->p.longitude_i != p.longitude_i || newStatus->p.altitude != p.altitude ||
-                newStatus->p.PDOP != p.PDOP || newStatus->p.ground_track != p.ground_track ||
+                newStatus->p.altitude_hae != p.altitude_hae || newStatus->p.PDOP != p.PDOP ||
+                newStatus->p.ground_track != p.ground_track || newStatus->p.ground_speed != p.ground_speed ||
                 newStatus->p.sats_in_view != p.sats_in_view);
     }
 
@@ -122,9 +121,9 @@ class GPSStatus : public Status
         // Only update the status if values have actually changed
         bool isDirty = matches(newStatus);
 
-        if (isDirty && p.pos_timestamp && (newStatus->p.pos_timestamp == p.pos_timestamp)) {
+        if (isDirty && p.timestamp && (newStatus->p.timestamp == p.timestamp)) {
             // We can NEVER be in two locations at the same time! (also PR #886)
-            DEBUG_MSG("BUG!! positional timestamp unchanged from prev solution\n");
+            LOG_ERROR("BUG: Positional timestamp unchanged from prev solution\n");
         }
 
         initialized = true;
@@ -136,11 +135,11 @@ class GPSStatus : public Status
         if (isDirty) {
             if (hasLock) {
                 // In debug logs, identify position by @timestamp:stage (stage 3 = notify)
-                DEBUG_MSG("New GPS pos@%x:3 lat=%f, lon=%f, alt=%d, pdop=%.2f, track=%.2f, sats=%d\n", p.pos_timestamp,
+                LOG_DEBUG("New GPS pos@%x:3 lat=%f, lon=%f, alt=%d, pdop=%.2f, track=%.2f, speed=%.2f, sats=%d\n", p.timestamp,
                           p.latitude_i * 1e-7, p.longitude_i * 1e-7, p.altitude, p.PDOP * 1e-2, p.ground_track * 1e-5,
-                          p.sats_in_view);
+                          p.ground_speed * 1e-2, p.sats_in_view);
             } else
-                DEBUG_MSG("No GPS lock\n");
+                LOG_DEBUG("No GPS lock\n");
             onNewStatus.notifyObservers(this);
         }
         return 0;

src/NodeStatus.h

@@ -1,16 +1,18 @@
 #pragma once
-#include <Arduino.h>
 #include "Status.h"
 #include "configuration.h"
+#include <Arduino.h>
 
-namespace meshtastic {
+namespace meshtastic
+{
 
-    /// Describes the state of the NodeDB system.
+/// Describes the state of the NodeDB system.
-    class NodeStatus : public Status
+class NodeStatus : public Status
-    {
+{
 
   private:
-        CallbackObserver<NodeStatus, const NodeStatus *> statusObserver = CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);
+    CallbackObserver<NodeStatus, const NodeStatus *> statusObserver =
+        CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);
 
     uint8_t numOnline = 0;
     uint8_t numTotal = 0;
@@ -20,10 +22,8 @@ namespace meshtastic {
   public:
     bool forceUpdate = false;
 
-        NodeStatus() {
+    NodeStatus() { statusType = STATUS_TYPE_NODE; }
-            statusType = STATUS_TYPE_NODE;
+    NodeStatus(uint8_t numOnline, uint8_t numTotal, bool forceUpdate = false) : Status()
-        }
-        NodeStatus( uint8_t numOnline, uint8_t numTotal, bool forceUpdate = false ) : Status()
     {
         this->forceUpdate = forceUpdate;
         this->numOnline = numOnline;
@@ -32,34 +32,20 @@ namespace meshtastic {
     NodeStatus(const NodeStatus &);
     NodeStatus &operator=(const NodeStatus &);
 
-        void observe(Observable<const NodeStatus *> *source)
+    void observe(Observable<const NodeStatus *> *source) { statusObserver.observe(source); }
-        {
-            statusObserver.observe(source);
-        }
 
-        uint8_t getNumOnline() const
+    uint8_t getNumOnline() const { return numOnline; }
-        { 
-            return numOnline; 
-        }
 
-        uint8_t getNumTotal() const
+    uint8_t getNumTotal() const { return numTotal; }
-        { 
-            return numTotal; 
-        }
 
-        uint8_t getLastNumTotal() const
+    uint8_t getLastNumTotal() const { return lastNumTotal; }
-        {
-            return lastNumTotal;
-        }
 
     bool matches(const NodeStatus *newStatus) const
     {
-            return (
+        return (newStatus->getNumOnline() != numOnline || newStatus->getNumTotal() != numTotal);
-                newStatus->getNumOnline() != numOnline ||
-                newStatus->getNumTotal() != numTotal
-            );
     }
-        int updateStatus(const NodeStatus *newStatus) {
+    int updateStatus(const NodeStatus *newStatus)
+    {
         // Only update the status if values have actually changed
         lastNumTotal = numTotal;
         bool isDirty;
@@ -69,15 +55,14 @@ namespace meshtastic {
             numOnline = newStatus->getNumOnline();
             numTotal = newStatus->getNumTotal();
         }
-            if(isDirty || newStatus->forceUpdate) {
+        if (isDirty || newStatus->forceUpdate) {
-                DEBUG_MSG("Node status update: %d online, %d total\n", numOnline, numTotal);            
+            LOG_DEBUG("Node status update: %d online, %d total\n", numOnline, numTotal);
             onNewStatus.notifyObservers(this);
         }
         return 0;
     }
+};
 
-    };
+} // namespace meshtastic
-
-}
 
 extern meshtastic::NodeStatus *nodeStatus;

src/OSTimer.cpp

@@ -1,5 +1,5 @@
-#include "configuration.h"
 #include "OSTimer.h"
+#include "configuration.h"
 
 /**
  * Schedule a callback to run.  The callback must _not_ block, though it is called from regular thread level (not ISR)

src/Observer.cpp

@@ -1,3 +1,2 @@
-#include "configuration.h"
 #include "Observer.h"
-
+#include "configuration.h"

src/Observer.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <Arduino.h>
-#include <assert.h>
 #include <list>
 
 template <class T> class Observable;

src/Power.cpp

@@ -1,18 +1,17 @@
 #include "power.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
+#include "buzz/buzz.h"
 #include "configuration.h"
 #include "main.h"
 #include "sleep.h"
 #include "utils.h"
-#include "buzz/buzz.h"
 
-#ifdef TBEAM_V10
+#ifdef HAS_PMU
-// FIXME. nasty hack cleanup how we load axp192
+#include "XPowersAXP192.tpp"
-#undef AXP192_SLAVE_ADDRESS
+#include "XPowersAXP2101.tpp"
-#include "axp20x.h"
+#include "XPowersLibInterface.hpp"
-
+XPowersLibInterface *PMU = NULL;
-AXP20X_Class axp;
 #else
 // Copy of the base class defined in axp20x.h.
 // I'd rather not inlude axp20x.h as it brings Wire dependency.
@@ -22,20 +21,20 @@ class HasBatteryLevel
     /**
      * Battery state of charge, from 0 to 100 or -1 for unknown
      */
-    virtual int getBattPercentage() { return -1; }
+    virtual int getBatteryPercent() { return -1; }
 
     /**
      * The raw voltage of the battery or NAN if unknown
      */
-    virtual float getBattVoltage() { return NAN; }
+    virtual uint16_t getBattVoltage() { return 0; }
 
     /**
      * return true if there is a battery installed in this unit
      */
     virtual bool isBatteryConnect() { return false; }
 
-    virtual bool isVBUSPlug() { return false; }
+    virtual bool isVbusIn() { return false; }
-    virtual bool isChargeing() { return false; }
+    virtual bool isCharging() { return false; }
 };
 #endif
 
@@ -77,7 +76,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
      *
      * FIXME - use a lipo lookup table, the current % full is super wrong
      */
-    virtual int getBattPercentage() override
+    virtual int getBatteryPercent() override
     {
         float v = getBattVoltage();
 
@@ -96,33 +95,33 @@ class AnalogBatteryLevel : public HasBatteryLevel
     /**
      * The raw voltage of the batteryin millivolts or NAN if unknown
      */
-    virtual float getBattVoltage() override
+    virtual uint16_t getBattVoltage() override
     {
 
 #ifndef ADC_MULTIPLIER
 #define ADC_MULTIPLIER 2.0
 #endif
 
+#ifndef BATTERY_SENSE_SAMPLES
+#define BATTERY_SENSE_SAMPLES 30
+#endif
+
 #ifdef BATTERY_PIN
         // Override variant or default ADC_MULTIPLIER if we have the override pref
-        float operativeAdcMultiplier = config.power.adc_multiplier_override > 0
+        float operativeAdcMultiplier =
-                                           ? config.power.adc_multiplier_override
+            config.power.adc_multiplier_override > 0 ? config.power.adc_multiplier_override : ADC_MULTIPLIER;
-                                           : ADC_MULTIPLIER;
         // Do not call analogRead() often.
         const uint32_t min_read_interval = 5000;
         if (millis() - last_read_time_ms > min_read_interval) {
             last_read_time_ms = millis();
 
-#ifdef BATTERY_SENSE_SAMPLES
+            // Set the number of samples, it has an effect of increasing sensitivity, especially in complex electromagnetic
-//Set the number of samples, it has an effect of increasing sensitivity, especially in complex electromagnetic environment.
+            // environment.
             uint32_t raw = 0;
-            for(uint32_t i=0; i<BATTERY_SENSE_SAMPLES;i++){
+            for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
                 raw += analogRead(BATTERY_PIN);
             }
-            raw = raw/BATTERY_SENSE_SAMPLES;
+            raw = raw / BATTERY_SENSE_SAMPLES;
-#else
-            uint32_t raw = analogRead(BATTERY_PIN);
-#endif
 
             float scaled;
 #ifndef VBAT_RAW_TO_SCALED
@@ -130,36 +129,58 @@ class AnalogBatteryLevel : public HasBatteryLevel
 #else
             scaled = VBAT_RAW_TO_SCALED(raw); // defined in variant.h
 #endif
-            // DEBUG_MSG("battery gpio %d raw val=%u scaled=%u\n", BATTERY_PIN, raw, (uint32_t)(scaled));
+            // 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;
         }
 #else
-        return NAN;
+        return 0;
 #endif
     }
 
     /**
      * return true if there is a battery installed in this unit
      */
-    virtual bool isBatteryConnect() override { return getBattPercentage() != -1; }
+    virtual bool isBatteryConnect() override
+    {
+        return getBatteryPercent() != -1;
+    }
 
     /// If we see a battery voltage higher than physics allows - assume charger is pumping
     /// in power
-    virtual bool isVBUSPlug() override { return getBattVoltage() > chargingVolt; }
+    virtual bool isVbusIn() override
+    {
+        return getBattVoltage() > chargingVolt;
+    }
 
     /// Assume charging if we have a battery and external power is connected.
     /// we can't be smart enough to say 'full'?
-    virtual bool isChargeing() override { return isBatteryConnect() && isVBUSPlug(); }
+    virtual bool isCharging() override
+    {
+        return isBatteryConnect() && isVbusIn();
+    }
 
   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 = 4200, emptyVolt = 3270, chargingVolt = 4210, noBatVolt = 2230;
+    const float fullVolt = BAT_FULLVOLT, emptyVolt = BAT_EMPTYVOLT, chargingVolt = BAT_CHARGINGVOLT, noBatVolt = BAT_NOBATVOLT;
     float last_read_value = 0.0;
     uint32_t last_read_time_ms = 0;
 };
@@ -170,12 +191,15 @@ Power::Power() : OSThread("Power")
 {
     statusHandler = {};
     low_voltage_counter = 0;
+#ifdef DEBUG_HEAP
+    lastheap = ESP.getFreeHeap();
+#endif
 }
 
 bool Power::analogInit()
 {
 #ifdef BATTERY_PIN
-    DEBUG_MSG("Using analog input %d for battery level\n", BATTERY_PIN);
+    LOG_DEBUG("Using analog input %d for battery level\n", BATTERY_PIN);
 
     // disable any internal pullups
     pinMode(BATTERY_PIN, INPUT);
@@ -208,7 +232,7 @@ bool Power::analogInit()
 
 bool Power::setup()
 {
-    bool found = axp192Init();
+    bool found = axpChipInit();
 
     if (!found) {
         found = analogInit();
@@ -221,10 +245,17 @@ bool Power::setup()
 
 void Power::shutdown()
 {
-#ifdef TBEAM_V10
+    screen->setOn(false);
-    DEBUG_MSG("Shutting down\n");
+#if defined(USE_EINK) && defined(PIN_EINK_EN)
-    axp.setChgLEDMode(AXP20X_LED_OFF);
+    digitalWrite(PIN_EINK_EN, LOW); // power off backlight first
-    axp.shutdown();
+#endif
+
+#ifdef HAS_PMU
+    LOG_INFO("Shutting down\n");
+    if (PMU) {
+        PMU->setChargingLedMode(XPOWERS_CHG_LED_OFF);
+        PMU->shutdown();
+    }
 #elif defined(ARCH_NRF52)
     playBeep();
     ledOff(PIN_LED1);
@@ -245,8 +276,8 @@ void Power::readPowerStatus()
         if (hasBattery) {
             batteryVoltageMv = batteryLevel->getBattVoltage();
             // If the AXP192 returns a valid battery percentage, use it
-            if (batteryLevel->getBattPercentage() >= 0) {
+            if (batteryLevel->getBatteryPercent() >= 0) {
-                batteryChargePercent = batteryLevel->getBattPercentage();
+                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
@@ -259,11 +290,28 @@ void Power::readPowerStatus()
 
         // Notify any status instances that are observing us
         const PowerStatus powerStatus2 =
-            PowerStatus(hasBattery ? OptTrue : OptFalse, batteryLevel->isVBUSPlug() ? OptTrue : OptFalse,
+            PowerStatus(hasBattery ? OptTrue : OptFalse, batteryLevel->isVbusIn() ? OptTrue : OptFalse,
-                        batteryLevel->isChargeing() ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
+                        batteryLevel->isCharging() ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
-        DEBUG_MSG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
+        LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
                   powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
         newStatus.notifyObservers(&powerStatus2);
+#ifdef DEBUG_HEAP
+        if (lastheap != ESP.getFreeHeap()) {
+            LOG_DEBUG("Threads running:");
+            int running = 0;
+            for (int i = 0; i < MAX_THREADS; i++) {
+                auto thread = concurrency::mainController.get(i);
+                if ((thread != nullptr) && (thread->enabled)) {
+                    LOG_DEBUG(" %s", thread->ThreadName.c_str());
+                    running++;
+                }
+            }
+            LOG_DEBUG("\n");
+            LOG_DEBUG("Heap status: %d/%d bytes free (%d), running %d/%d threads\n", ESP.getFreeHeap(), ESP.getHeapSize(),
+                      ESP.getFreeHeap() - lastheap, running, concurrency::mainController.size(false));
+            lastheap = ESP.getFreeHeap();
+        }
+#endif
 
 // If we have a battery at all and it is less than 10% full, force deep sleep if we have more than 3 low readings in a row
 // Supect fluctuating voltage on the RAK4631 to force it to deep sleep even if battery is at 85% after only a few days
@@ -271,8 +319,12 @@ void Power::readPowerStatus()
         if (powerStatus2.getHasBattery() && !powerStatus2.getHasUSB()) {
             if (batteryLevel->getBattVoltage() < MIN_BAT_MILLIVOLTS) {
                 low_voltage_counter++;
-                if (low_voltage_counter > 3)
+                LOG_DEBUG("Warning RAK4631 Low voltage counter: %d/10\n", low_voltage_counter);
-                    powerFSM.trigger(EVENT_LOW_BATTERY);
+                if (low_voltage_counter > 10) {
+                    // We can't trigger deep sleep on NRF52, it's freezing the board
+                    // powerFSM.trigger(EVENT_LOW_BATTERY);
+                    LOG_DEBUG("Low voltage detected, but not triggering deep sleep\n");
+                }
             } else {
                 low_voltage_counter = 0;
             }
@@ -293,41 +345,47 @@ int32_t Power::runOnce()
 {
     readPowerStatus();
 
-#ifdef TBEAM_V10
+#ifdef HAS_PMU
     // WE no longer use the IRQ line to wake the CPU (due to false wakes from sleep), but we do poll
     // the IRQ status by reading the registers over I2C
-    axp.readIRQ();
+    if (PMU) {
 
-    if (axp.isVbusRemoveIRQ()) {
+        PMU->getIrqStatus();
-        DEBUG_MSG("USB unplugged\n");
+
+        if (PMU->isVbusRemoveIrq()) {
+            LOG_INFO("USB unplugged\n");
             powerFSM.trigger(EVENT_POWER_DISCONNECTED);
         }
-    if (axp.isVbusPlugInIRQ()) {
+
-        DEBUG_MSG("USB plugged In\n");
+        if (PMU->isVbusInsertIrq()) {
+            LOG_INFO("USB plugged In\n");
             powerFSM.trigger(EVENT_POWER_CONNECTED);
         }
+
         /*
         Other things we could check if we cared...
 
-    if (axp.isChargingIRQ()) {
+        if (PMU->isBatChagerStartIrq()) {
-        DEBUG_MSG("Battery start charging\n");
+            LOG_DEBUG("Battery start charging\n");
         }
-    if (axp.isChargingDoneIRQ()) {
+        if (PMU->isBatChagerDoneIrq()) {
-        DEBUG_MSG("Battery fully charged\n");
+            LOG_DEBUG("Battery fully charged\n");
         }
-    if (axp.isBattPlugInIRQ()) {
+        if (PMU->isBatInsertIrq()) {
-        DEBUG_MSG("Battery inserted\n");
+            LOG_DEBUG("Battery inserted\n");
         }
-    if (axp.isBattRemoveIRQ()) {
+        if (PMU->isBatRemoveIrq()) {
-        DEBUG_MSG("Battery removed\n");
+            LOG_DEBUG("Battery removed\n");
-    }
-    if (axp.isPEKShortPressIRQ()) {
-        DEBUG_MSG("PEK short button press\n");
         }
         */
-    axp.clearIRQ();
+        if (PMU->isPekeyLongPressIrq()) {
-#endif
+            LOG_DEBUG("PEK long button press\n");
+            screen->setOn(false);
+        }
 
+        PMU->clearIrqStatus();
+    }
+#endif
     // Only read once every 20 seconds once the power status for the app has been initialized
     return (statusHandler && statusHandler->isInitialized()) ? (1000 * 20) : RUN_SAME;
 }
@@ -340,128 +398,251 @@ int32_t Power::runOnce()
  share the same i2c bus, instead use ssd1306 sleep mode DCDC2 -> unused DCDC3 0.7-3.5V @ 700mA max -> ESP32 (keep this on!) LDO1
  30mA -> charges GPS backup battery // charges the tiny J13 battery by the GPS to power the GPS ram (for a couple of days), can
  not be turned off LDO2 200mA -> LORA LDO3 200mA -> GPS
+ *
  */
-bool Power::axp192Init()
+bool Power::axpChipInit()
 {
-#ifdef TBEAM_V10
-    if (axp192_found) {
-        if (!axp.begin(Wire, AXP192_SLAVE_ADDRESS)) {
-            batteryLevel = &axp;
 
-            DEBUG_MSG("AXP192 Begin PASS\n");
+#ifdef HAS_PMU
 
-            // axp.setChgLEDMode(LED_BLINK_4HZ);
+    TwoWire *w = NULL;
-            DEBUG_MSG("DCDC1: %s\n", axp.isDCDC1Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("DCDC2: %s\n", axp.isDCDC2Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("LDO2: %s\n", axp.isLDO2Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("LDO3: %s\n", axp.isLDO3Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("DCDC3: %s\n", axp.isDCDC3Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("Exten: %s\n", axp.isExtenEnable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("----------------------------------------\n");
 
-            axp.setPowerOutPut(AXP192_LDO2, AXP202_ON); // LORA radio
+    // Use macro to distinguish which wire is used by PMU
-            // axp.setPowerOutPut(AXP192_LDO3, AXP202_ON); // GPS main power - now turned on in setGpsPower
+#ifdef PMU_USE_WIRE1
-            axp.setPowerOutPut(AXP192_DCDC2, AXP202_ON);
+    w = &Wire1;
-            axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON);
+#else
-            axp.setPowerOutPut(AXP192_DCDC1, AXP202_ON);
+    w = &Wire;
-            axp.setDCDC1Voltage(3300); // for the OLED power
+#endif
 
-            DEBUG_MSG("DCDC1: %s\n", axp.isDCDC1Enable() ? "ENABLE" : "DISABLE");
+    /**
-            DEBUG_MSG("DCDC2: %s\n", axp.isDCDC2Enable() ? "ENABLE" : "DISABLE");
+     * It is not necessary to specify the wire pin,
-            DEBUG_MSG("LDO2: %s\n", axp.isLDO2Enable() ? "ENABLE" : "DISABLE");
+     * just input the wire, because the wire has been initialized in main.cpp
-            DEBUG_MSG("LDO3: %s\n", axp.isLDO3Enable() ? "ENABLE" : "DISABLE");
+     */
-            DEBUG_MSG("DCDC3: %s\n", axp.isDCDC3Enable() ? "ENABLE" : "DISABLE");
+    if (!PMU) {
-            DEBUG_MSG("Exten: %s\n", axp.isExtenEnable() ? "ENABLE" : "DISABLE");
+        PMU = new XPowersAXP2101(*w);
-
+        if (!PMU->init()) {
-            switch (config.power.charge_current) {
+            LOG_WARN("Failed to find AXP2101 power management\n");
-            case Config_PowerConfig_ChargeCurrent_MAUnset:
+            delete PMU;
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_450MA);
+            PMU = NULL;
-                break;
+        } else {
-            case Config_PowerConfig_ChargeCurrent_MA100:
+            LOG_INFO("AXP2101 PMU init succeeded, using AXP2101 PMU\n");
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_100MA);
+        }
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA190:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_190MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA280:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_280MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA360:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_360MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA450:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_450MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA550:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_550MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA630:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_630MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA700:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_700MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA780:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_780MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA880:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_880MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA960:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_960MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA1000:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_1000MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA1080:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_1080MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA1160:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_1160MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA1240:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_1240MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA1320:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_1320MA);
-                break;
     }
 
-#if 0
+    if (!PMU) {
+        PMU = new XPowersAXP192(*w);
+        if (!PMU->init()) {
+            LOG_WARN("Failed to find AXP192 power management\n");
+            delete PMU;
+            PMU = NULL;
+        } else {
+            LOG_INFO("AXP192 PMU init succeeded, using AXP192 PMU\n");
+        }
+    }
 
-      // Not connected
+    if (!PMU) {
-      //val = 0xfc;
+        /*
-      //axp._writeByte(AXP202_VHTF_CHGSET, 1, &val); // Set temperature protection
+         * In XPowersLib, if the XPowersAXPxxx object is released, Wire.end() will be called at the same time.
-
+         * In order not to affect other devices, if the initialization of the PMU fails, Wire needs to be re-initialized once,
-      //not used
+         * if there are multiple devices sharing the bus.
-      //val = 0x46;
+         * * */
-      //axp._writeByte(AXP202_OFF_CTL, 1, &val); // enable bat detection
+#ifndef PMU_USE_WIRE1
+        w->begin(I2C_SDA, I2C_SCL);
+#endif
+        return false;
+    }
+
+    batteryLevel = PMU;
+
+    if (PMU->getChipModel() == XPOWERS_AXP192) {
+
+        // lora radio power channel
+        PMU->setPowerChannelVoltage(XPOWERS_LDO2, 3300);
+        PMU->enablePowerOutput(XPOWERS_LDO2);
+
+        // oled module power channel,
+        // disable it will cause abnormal communication between boot and AXP power supply,
+        // do not turn it off
+        PMU->setPowerChannelVoltage(XPOWERS_DCDC1, 3300);
+        // enable oled power
+        PMU->enablePowerOutput(XPOWERS_DCDC1);
+
+        // gnss module power channel -  now turned on in setGpsPower
+        PMU->setPowerChannelVoltage(XPOWERS_LDO3, 3300);
+        // PMU->enablePowerOutput(XPOWERS_LDO3);
+
+        // protected oled power source
+        PMU->setProtectedChannel(XPOWERS_DCDC1);
+        // protected esp32 power source
+        PMU->setProtectedChannel(XPOWERS_DCDC3);
+
+        // disable not use channel
+        PMU->disablePowerOutput(XPOWERS_DCDC2);
+
+        // disable all axp chip interrupt
+        PMU->disableIRQ(XPOWERS_AXP192_ALL_IRQ);
+
+        // Set constant current charging current
+        PMU->setChargerConstantCurr(XPOWERS_AXP192_CHG_CUR_450MA);
+
+        // Set up the charging voltage
+        PMU->setChargeTargetVoltage(XPOWERS_AXP192_CHG_VOL_4V2);
+
+    } else if (PMU->getChipModel() == XPOWERS_AXP2101) {
+
+        // t-beam s3 core
+
+        /**
+         * gnss module power channel
+         * The default ALDO4 is off, you need to turn on the GNSS power first, otherwise it will be invalid during initialization
+         */
+        PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 3300);
+        PMU->enablePowerOutput(XPOWERS_ALDO4);
+
+        // lora radio power channel
+        PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300);
+        PMU->enablePowerOutput(XPOWERS_ALDO3);
+
+        // m.2 interface
+        PMU->setPowerChannelVoltage(XPOWERS_DCDC3, 3300);
+        PMU->enablePowerOutput(XPOWERS_DCDC3);
+
+        /**
+         * ALDO2 cannot be turned off.
+         * It is a necessary condition for sensor communication.
+         * It must be turned on to properly access the sensor and screen
+         * It is also responsible for the power supply of PCF8563
+         */
+        PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300);
+        PMU->enablePowerOutput(XPOWERS_ALDO2);
+
+        // 6-axis , magnetometer ,bme280 , oled screen power channel
+        PMU->setPowerChannelVoltage(XPOWERS_ALDO1, 3300);
+        PMU->enablePowerOutput(XPOWERS_ALDO1);
+
+        // sdcard power channle
+        PMU->setPowerChannelVoltage(XPOWERS_BLDO1, 3300);
+        PMU->enablePowerOutput(XPOWERS_BLDO1);
+
+        // PMU->setPowerChannelVoltage(XPOWERS_DCDC4, 3300);
+        // PMU->enablePowerOutput(XPOWERS_DCDC4);
+
+        // not use channel
+        PMU->disablePowerOutput(XPOWERS_DCDC2); // not elicited
+        PMU->disablePowerOutput(XPOWERS_DCDC5); // not elicited
+        PMU->disablePowerOutput(XPOWERS_DLDO1); // Invalid power channel, it does not exist
+        PMU->disablePowerOutput(XPOWERS_DLDO2); // Invalid power channel, it does not exist
+        PMU->disablePowerOutput(XPOWERS_VBACKUP);
+
+        // disable all axp chip interrupt
+        PMU->disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
+
+        // Set the constant current charging current of AXP2101, temporarily use 500mA by default
+        PMU->setChargerConstantCurr(XPOWERS_AXP2101_CHG_CUR_500MA);
+
+        // Set up the charging voltage
+        PMU->setChargeTargetVoltage(XPOWERS_AXP2101_CHG_VOL_4V2);
+    }
+
+    PMU->clearIrqStatus();
+
+    // TBeam1.1 /T-Beam S3-Core has no external TS detection,
+    // it needs to be disabled, otherwise it will cause abnormal charging
+    PMU->disableTSPinMeasure();
+
+    // PMU->enableSystemVoltageMeasure();
+    PMU->enableVbusVoltageMeasure();
+    PMU->enableBattVoltageMeasure();
+
+    LOG_DEBUG("=======================================================================\n");
+    if (PMU->isChannelAvailable(XPOWERS_DCDC1)) {
+        LOG_DEBUG("DC1  : %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_DCDC1) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_DCDC1));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_DCDC2)) {
+        LOG_DEBUG("DC2  : %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_DCDC2) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_DCDC2));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_DCDC3)) {
+        LOG_DEBUG("DC3  : %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_DCDC3) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_DCDC3));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_DCDC4)) {
+        LOG_DEBUG("DC4  : %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_DCDC4) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_DCDC4));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_LDO2)) {
+        LOG_DEBUG("LDO2 : %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_LDO2) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_LDO2));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_LDO3)) {
+        LOG_DEBUG("LDO3 : %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_LDO3) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_LDO3));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO1)) {
+        LOG_DEBUG("ALDO1: %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_ALDO1) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_ALDO1));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO2)) {
+        LOG_DEBUG("ALDO2: %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_ALDO2) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_ALDO2));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO3)) {
+        LOG_DEBUG("ALDO3: %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_ALDO3) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_ALDO3));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO4)) {
+        LOG_DEBUG("ALDO4: %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_ALDO4) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_ALDO4));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_BLDO1)) {
+        LOG_DEBUG("BLDO1: %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_BLDO1) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_BLDO1));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_BLDO2)) {
+        LOG_DEBUG("BLDO2: %s   Voltage:%u mV \n", PMU->isPowerChannelEnable(XPOWERS_BLDO2) ? "+" : "-",
+                  PMU->getPowerChannelVoltage(XPOWERS_BLDO2));
+    }
+    LOG_DEBUG("=======================================================================\n");
+
+// We can safely ignore this approach for most (or all) boards because MCU turned off
+// earlier than battery discharged to 2.6V.
+//
+// Unfortanly for now we can't use this killswitch for RAK4630-based boards because they have a bug with
+// battery voltage measurement. Probably it sometimes drops to low values.
+#ifndef RAK4630
+    // Set PMU shutdown voltage at 2.6V to maximize battery utilization
+    PMU->setSysPowerDownVoltage(2600);
 #endif
-            axp.debugCharging();
 
 #ifdef PMU_IRQ
+    uint64_t pmuIrqMask = 0;
+
+    if (PMU->getChipModel() == XPOWERS_AXP192) {
+        pmuIrqMask = XPOWERS_AXP192_VBUS_INSERT_IRQ | XPOWERS_AXP192_BAT_INSERT_IRQ | XPOWERS_AXP192_PKEY_SHORT_IRQ;
+    } else if (PMU->getChipModel() == XPOWERS_AXP2101) {
+        pmuIrqMask = XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_BAT_INSERT_IRQ | XPOWERS_AXP2101_PKEY_SHORT_IRQ;
+    }
+
     pinMode(PMU_IRQ, INPUT);
     attachInterrupt(
         PMU_IRQ, [] { pmu_irq = true; }, FALLING);
 
-            axp.adc1Enable(AXP202_BATT_CUR_ADC1, 1);
+    // we do not look for AXPXXX_CHARGING_FINISHED_IRQ & AXPXXX_CHARGING_IRQ because it occurs repeatedly while there is
-            // we do not look for AXP202_CHARGING_FINISHED_IRQ & AXP202_CHARGING_IRQ because it occurs repeatedly while there is
     // no battery also it could cause inadvertent waking from light sleep just because the battery filled
-            // we don't look for AXP202_BATT_REMOVED_IRQ because it occurs repeatedly while no battery installed
+    // we don't look for AXPXXX_BATT_REMOVED_IRQ because it occurs repeatedly while no battery installed
-            // we don't look at AXP202_VBUS_REMOVED_IRQ because we don't have anything hooked to vbus
+    // we don't look at AXPXXX_VBUS_REMOVED_IRQ because we don't have anything hooked to vbus
-            axp.enableIRQ(AXP202_BATT_CONNECT_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_PEK_SHORTPRESS_IRQ, 1);
+    PMU->enableIRQ(pmuIrqMask);
+
+    PMU->clearIrqStatus();
+#endif /*PMU_IRQ*/
 
-            axp.clearIRQ();
-#endif
     readPowerStatus();
-        } else {
-            DEBUG_MSG("AXP192 Begin FAIL\n");
-        }
-    } else {
-        DEBUG_MSG("AXP192 not found\n");
-    }
 
-    return axp192_found;
+    pmu_found = true;
+
+    return pmu_found;
+
 #else
     return false;
 #endif

src/PowerFSM.cpp

@@ -11,12 +11,12 @@
 /// Should we behave as if we have AC power now?
 static bool isPowered()
 {
-    // Circumvent the battery sensing logic and assumes constant power if no battery pin or power mgmt IC
+// Circumvent the battery sensing logic and assumes constant power if no battery pin or power mgmt IC
-    #if !defined(BATTERY_PIN) && !defined(AXP192_SLAVE_ADDRESS)
+#if !defined(BATTERY_PIN) && !defined(HAS_AXP192) && !defined(HAS_AXP2101)
     return true;
-    #endif
+#endif
 
-    bool isRouter = (config.device.role == Config_DeviceConfig_Role_Router ? 1 : 0);
+    bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
 
     // If we are not a router and we already have AC power go to POWER state after init, otherwise go to ON
     // We assume routers might be powered all the time, but from a low current (solar) source
@@ -32,16 +32,16 @@ static bool isPowered()
 
 static void sdsEnter()
 {
-    DEBUG_MSG("Enter state: SDS\n");
+    LOG_INFO("Enter state: SDS\n");
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
-    doDeepSleep(config.power.sds_secs ? config.power.sds_secs : default_sds_secs * 1000LL);
+    doDeepSleep(getConfiguredOrDefaultMs(config.power.sds_secs));
 }
 
 extern Power *power;
 
 static void shutdownEnter()
 {
-    DEBUG_MSG("Enter state: SHUTDOWN\n");
+    LOG_INFO("Enter state: SHUTDOWN\n");
     power->shutdown();
 }
 
@@ -51,22 +51,21 @@ static uint32_t secsSlept;
 
 static void lsEnter()
 {
-    DEBUG_MSG("lsEnter begin, ls_secs=%u\n",
+    LOG_INFO("lsEnter begin, ls_secs=%u\n", config.power.ls_secs);
-              config.power.ls_secs ? config.power.ls_secs : default_ls_secs);
     screen->setOn(false);
     secsSlept = 0; // How long have we been sleeping this time
 
-    // DEBUG_MSG("lsEnter end\n");
+    // LOG_INFO("lsEnter end\n");
 }
 
 static void lsIdle()
 {
-    // DEBUG_MSG("lsIdle begin ls_secs=%u\n", getPref_ls_secs());
+    // LOG_INFO("lsIdle begin ls_secs=%u\n", getPref_ls_secs());
 
 #ifdef ARCH_ESP32
 
     // Do we have more sleeping to do?
-    if (secsSlept < config.power.ls_secs ? config.power.ls_secs : default_ls_secs * 1000) {
+    if (secsSlept < config.power.ls_secs) {
         // Briefly come out of sleep long enough to blink the led once every few seconds
         uint32_t sleepTime = 30;
 
@@ -83,7 +82,7 @@ static void lsIdle()
                 wakeCause2 = doLightSleep(1); // leave led on for 1ms
 
                 secsSlept += sleepTime;
-                // DEBUG_MSG("sleeping, flash led!\n");
+                // LOG_INFO("sleeping, flash led!\n");
                 break;
 
             case ESP_SLEEP_WAKEUP_UART:
@@ -94,7 +93,7 @@ static void lsIdle()
             default:
                 // We woke for some other reason (button press, device interrupt)
                 // uint64_t status = esp_sleep_get_ext1_wakeup_status();
-                DEBUG_MSG("wakeCause2 %d\n", wakeCause2);
+                LOG_INFO("wakeCause2 %d\n", wakeCause2);
 
 #ifdef BUTTON_PIN
                 bool pressed = !digitalRead(BUTTON_PIN);
@@ -118,7 +117,7 @@ static void lsIdle()
     } else {
         // Time to stop sleeping!
         setLed(false);
-        DEBUG_MSG("reached ls_secs, servicing loop()\n");
+        LOG_INFO("Reached ls_secs, servicing loop()\n");
         powerFSM.trigger(EVENT_WAKE_TIMER);
     }
 #endif
@@ -126,7 +125,7 @@ static void lsIdle()
 
 static void lsExit()
 {
-    DEBUG_MSG("Exit state: LS\n");
+    LOG_INFO("Exit state: LS\n");
     // setGPSPower(true); // restore GPS power
     if (gps)
         gps->forceWake(true);
@@ -134,7 +133,7 @@ static void lsExit()
 
 static void nbEnter()
 {
-    DEBUG_MSG("Enter state: NB\n");
+    LOG_INFO("Enter state: NB\n");
     screen->setOn(false);
     setBluetoothEnable(false);
 
@@ -149,7 +148,7 @@ static void darkEnter()
 
 static void serialEnter()
 {
-    DEBUG_MSG("Enter state: SERIAL\n");
+    LOG_INFO("Enter state: SERIAL\n");
     setBluetoothEnable(false);
     screen->setOn(true);
     screen->print("Serial connected\n");
@@ -162,10 +161,10 @@ static void serialExit()
 
 static void powerEnter()
 {
-    DEBUG_MSG("Enter state: POWER\n");
+    LOG_INFO("Enter state: POWER\n");
     if (!isPowered()) {
         // If we got here, we are in the wrong state - we should be in powered, let that state ahndle things
-        DEBUG_MSG("Loss of power in Powered\n");
+        LOG_INFO("Loss of power in Powered\n");
         powerFSM.trigger(EVENT_POWER_DISCONNECTED);
     } else {
         screen->setOn(true);
@@ -178,7 +177,7 @@ static void powerIdle()
 {
     if (!isPowered()) {
         // If we got here, we are in the wrong state
-        DEBUG_MSG("Loss of power in Powered\n");
+        LOG_INFO("Loss of power in Powered\n");
         powerFSM.trigger(EVENT_POWER_DISCONNECTED);
     }
 }
@@ -192,7 +191,7 @@ static void powerExit()
 
 static void onEnter()
 {
-    DEBUG_MSG("Enter state: ON\n");
+    LOG_INFO("Enter state: ON\n");
     screen->setOn(true);
     setBluetoothEnable(true);
 
@@ -200,7 +199,7 @@ static void onEnter()
 
     uint32_t now = millis();
 
-    if (now - lastPingMs >
+    if ((now - lastPingMs) >
         30 * 1000) { // if more than a minute since our last press, ask node we are looking at to update their state
         if (displayedNodeNum)
             service.sendNetworkPing(displayedNodeNum, true); // Refresh the currently displayed node
@@ -223,7 +222,7 @@ static void screenPress()
 
 static void bootEnter()
 {
-    DEBUG_MSG("Enter state: BOOT\n");
+    LOG_INFO("Enter state: BOOT\n");
 }
 
 State stateSHUTDOWN(shutdownEnter, NULL, NULL, "SHUTDOWN");
@@ -239,10 +238,10 @@ Fsm powerFSM(&stateBOOT);
 
 void PowerFSM_setup()
 {
-    bool isRouter = (config.device.role == Config_DeviceConfig_Role_Router ? 1 : 0);
+    bool isRouter = (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ? 1 : 0);
     bool hasPower = isPowered();
 
-    DEBUG_MSG("PowerFSM init, USB power=%d\n", hasPower);
+    LOG_INFO("PowerFSM init, USB power=%d\n", hasPower ? 1 : 0);
     powerFSM.add_timed_transition(&stateBOOT, hasPower ? &statePOWER : &stateON, 3 * 1000, NULL, "boot timeout");
 
     // wake timer expired or a packet arrived
@@ -328,50 +327,28 @@ void PowerFSM_setup()
 
     powerFSM.add_transition(&stateDARK, &stateDARK, EVENT_CONTACT_FROM_PHONE, NULL, "Contact from phone");
 
-    // each time we get a new update packet make sure we are staying in the ON state so the screen stays awake (also we don't
-    // shutdown bluetooth if is_router)
-    powerFSM.add_transition(&stateDARK, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
-    powerFSM.add_transition(&stateON, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
-
     powerFSM.add_timed_transition(&stateON, &stateDARK,
-                                  config.display.screen_on_secs ? config.display.screen_on_secs
+                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
-                                                                               : 60 * 1000 * 10,
+                                  "Screen-on timeout");
-                                  NULL, "Screen-on timeout");
-
-    // On most boards we use light-sleep to be our main state, but on NRF52 we just stay in DARK
-    State *lowPowerState = &stateLS;
-
-    uint32_t meshSds = 0;
 
 #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/Meshtastic-device/issues/1071
+    // See: https://github.com/meshtastic/firmware/issues/1071
     if (isRouter || config.power.is_power_saving) {
         powerFSM.add_timed_transition(&stateNB, &stateLS,
-                                      config.power.min_wake_secs ? config.power.min_wake_secs
+                                      getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
-                                                                                : default_min_wake_secs * 1000,
+                                      "Min wake timeout");
-                                      NULL, "Min wake timeout");
         powerFSM.add_timed_transition(&stateDARK, &stateLS,
-                                      config.power.wait_bluetooth_secs
+                                      getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs),
-                                          ? config.power.wait_bluetooth_secs
-                                          : default_wait_bluetooth_secs * 1000,
                                       NULL, "Bluetooth timeout");
-        meshSds = config.power.mesh_sds_timeout_secs ? config.power.mesh_sds_timeout_secs
-                                                                    : default_mesh_sds_timeout_secs;
-
-    } else {
-
-        meshSds = UINT32_MAX;
     }
 
-#else
+    if (config.power.sds_secs != UINT32_MAX)
-    lowPowerState = &stateDARK;
+        powerFSM.add_timed_transition(lowPowerState, &stateSDS, getConfiguredOrDefaultMs(config.power.sds_secs), NULL,
-    meshSds = UINT32_MAX; // Workaround for now: Don't go into deep sleep on the RAK4631
+                                      "mesh timeout");
 #endif
 
-    if (meshSds != UINT32_MAX)
-        powerFSM.add_timed_transition(lowPowerState, &stateSDS, meshSds * 1000, NULL, "mesh timeout");
-
     powerFSM.run_machine(); // run one interation of the state machine, so we run our on enter tasks for the initial DARK state
 }

src/PowerFSM.h

@@ -19,7 +19,7 @@
 #define EVENT_POWER_CONNECTED 13
 #define EVENT_POWER_DISCONNECTED 14
 #define EVENT_FIRMWARE_UPDATE 15 // We just received a new firmware update packet from the phone
-#define EVENT_SHUTDOWN 16 //force a full shutdown now (not just sleep)
+#define EVENT_SHUTDOWN 16        // force a full shutdown now (not just sleep)
 #define EVENT_INPUT 17           // input broker wants something, we need to wake up and enable screen
 
 extern Fsm powerFSM;

src/PowerFSMThread.h

@@ -26,11 +26,10 @@ class PowerFSMThread : public OSThread
 
         if (powerStatus->getHasUSB()) {
             timeLastPowered = millis();
-        } else if (config.power.on_battery_shutdown_after_secs > 0 &&
+        } else if (config.power.on_battery_shutdown_after_secs > 0 && config.power.on_battery_shutdown_after_secs != UINT32_MAX &&
-                   millis() >
+                   millis() > (timeLastPowered +
-                       timeLastPowered +
+                               getConfiguredOrDefaultMs(
-                           (1000 *
+                                   config.power.on_battery_shutdown_after_secs))) { // shutdown after 30 minutes unpowered
-                            config.power.on_battery_shutdown_after_secs)) { // shutdown after 30 minutes unpowered
             powerFSM.trigger(EVENT_SHUTDOWN);
         }
 

src/PowerStatus.h

@@ -82,7 +82,7 @@ class PowerStatus : public Status
             isCharging = newStatus->isCharging;
         }
         if (isDirty) {
-            // DEBUG_MSG("Battery %dmV %d%%\n", batteryVoltageMv, batteryChargePercent);
+            // LOG_DEBUG("Battery %dmV %d%%\n", batteryVoltageMv, batteryChargePercent);
             onNewStatus.notifyObservers(this);
         }
         return 0;

src/RedirectablePrint.cpp

@@ -1,12 +1,12 @@
-#include "configuration.h"
 #include "RedirectablePrint.h"
+#include "NodeDB.h"
 #include "RTC.h"
 #include "concurrency/OSThread.h"
-// #include "wifi/WiFiServerAPI.h"
+#include "configuration.h"
 #include <assert.h>
+#include <cstring>
 #include <sys/time.h>
 #include <time.h>
-#include <cstring>
 
 /**
  * A printer that doesn't go anywhere
@@ -26,11 +26,9 @@ size_t RedirectablePrint::write(uint8_t c)
     SEGGER_RTT_PutChar(SEGGER_STDOUT_CH, c);
 #endif
 
-    // FIXME - clean this up, the whole relationship of this class to SerialConsole to TCP/bluetooth debug log output is kinda messed up.  But for now, just have this hack to
+    if (!config.has_lora || config.device.serial_enabled)
-    // optionally send chars to TCP also
-    //WiFiServerPort::debugOut(c);
-
         dest->write(c);
+
     return 1; // We always claim one was written, rather than trusting what the
               // serial port said (which could be zero)
 }
@@ -38,26 +36,25 @@ size_t RedirectablePrint::write(uint8_t c)
 size_t RedirectablePrint::vprintf(const char *format, va_list arg)
 {
     va_list copy;
+    static char printBuf[160];
 
     va_copy(copy, arg);
-    int len = vsnprintf(printBuf, printBufLen, format, copy);
+    size_t len = vsnprintf(printBuf, sizeof(printBuf), format, copy);
     va_end(copy);
-    if (len < 0) {
+
-        va_end(arg);
+    // If the resulting string is longer than sizeof(printBuf)-1 characters, the remaining characters are still counted for the
-        return 0;
+    // return value
-    };
+
-    if (len >= (int)printBufLen) {
+    if (len > sizeof(printBuf) - 1) {
-        delete[] printBuf;
+        len = sizeof(printBuf) - 1;
-        printBufLen *= 2;
+        printBuf[sizeof(printBuf) - 2] = '\n';
-        printBuf = new char[printBufLen];
-        len = vsnprintf(printBuf, printBufLen, format, arg);
     }
 
     len = Print::write(printBuf, len);
     return len;
 }
 
-size_t RedirectablePrint::logDebug(const char *format, ...)
+size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
 {
     size_t r = 0;
 
@@ -85,9 +82,9 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
                 int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
                 int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
 
-                r += printf("%02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
+                r += printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
             } else
-                r += printf("??:??:?? %u ", millis() / 1000);
+                r += printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
 
             auto thread = concurrency::OSThread::currentThread;
             if (thread) {
@@ -98,7 +95,6 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
                 print("] ");
             }
         }
-
         r += vprintf(format, arg);
         va_end(arg);
 
@@ -108,3 +104,35 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
 
     return r;
 }
+
+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");
+    for (uint16_t i = 0; i < len; i += 16) {
+        if (i % 128 == 0)
+            log(logLevel, "   +------------------------------------------------+ +----------------+\n");
+        char s[] = "|                                                | |                |\n";
+        uint8_t ix = 1, iy = 52;
+        for (uint8_t j = 0; j < 16; j++) {
+            if (i + j < len) {
+                uint8_t c = buf[i + j];
+                s[ix++] = alphabet[(c >> 4) & 0x0F];
+                s[ix++] = alphabet[c & 0x0F];
+                ix++;
+                if (c > 31 && c < 128)
+                    s[iy++] = c;
+                else
+                    s[iy++] = '.';
+            }
+        }
+        uint8_t index = i / 16;
+        if (i < 256)
+            log(logLevel, " ");
+        log(logLevel, "%02x", index);
+        log(logLevel, ".");
+        log(logLevel, s);
+    }
+    log(logLevel, "   +------------------------------------------------+ +----------------+\n");
+}

src/RedirectablePrint.h

@@ -12,10 +12,6 @@ class RedirectablePrint : public Print
 {
     Print *dest;
 
-    /// We dynamically grow this scratch buffer if necessary
-    char *printBuf = new char[64];
-    size_t printBufLen = 64;
-
     /// Used to allow multiple logDebug messages to appear on a single log line
     bool isContinuationMessage = false;
 
@@ -37,14 +33,13 @@ class RedirectablePrint : public Print
      * If the provide format string ends with a newline we assume it is the final print of a single
      * log message.  Otherwise we assume more prints will come before the log message ends.  This
      * allows you to call logDebug a few times to build up a single log message line if you wish.
-     * 
-     * FIXME, eventually add log levels (INFO, WARN, ERROR) and subsystems.  Move into 
-     * a different class.
      */
-    size_t logDebug(const char * format, ...)  __attribute__ ((format (printf, 2, 3)));
+    size_t log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
 
     /** like printf but va_list based */
     size_t vprintf(const char *format, va_list arg);
+
+    void hexDump(const char *logLevel, unsigned char *buf, uint16_t len);
 };
 
 class NoopPrint : public Print

src/SPILock.cpp

@@ -1,5 +1,5 @@
-#include "configuration.h"
 #include "SPILock.h"
+#include "configuration.h"
 #include <Arduino.h>
 #include <assert.h>
 

src/SerialConsole.cpp

@@ -20,9 +20,10 @@ void consolePrintf(const char *format, ...)
     va_start(arg, format);
     console->vprintf(format, arg);
     va_end(arg);
+    console->flush();
 }
 
-SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
+SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), concurrency::OSThread("SerialConsole")
 {
     assert(!console);
     console = this;
@@ -30,7 +31,7 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
                       // setDestination(&noopPrint); for testing, try turning off 'all' debug output and see what leaks
 
     Port.begin(SERIAL_BAUD);
-#ifdef ARCH_NRF52
+#if defined(ARCH_NRF52) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3)
     time_t timeout = millis();
     while (!Port) {
         if ((millis() - timeout) < 5000) {
@@ -43,6 +44,15 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
     emitRebooted();
 }
 
+int32_t SerialConsole::runOnce()
+{
+    return runOncePart();
+}
+
+void SerialConsole::flush()
+{
+    Port.flush();
+}
 
 // For the serial port we can't really detect if any client is on the other side, so instead just look for recent messages
 bool SerialConsole::checkIsConnected()
@@ -57,10 +67,15 @@ bool SerialConsole::checkIsConnected()
  */
 bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
 {
+    // only talk to the API once the configuration has been loaded and we're sure the serial port is not disabled.
+    if (config.has_lora && config.device.serial_enabled) {
         // Turn off debug serial printing once the API is activated, because other threads could print and corrupt packets
         if (!config.device.debug_log_enabled)
             setDestination(&noopPrint);
         canWrite = true;
 
         return StreamAPI::handleToRadio(buf, len);
+    } else {
+        return false;
+    }
 }

src/SerialConsole.h

@@ -6,7 +6,7 @@
  * Provides both debug printing and, if the client starts sending protobufs to us, switches to send/receive protobufs
  * (and starts dropping debug printing - FIXME, eventually those prints should be encapsulated in protobufs).
  */
-class SerialConsole : public StreamAPI, public RedirectablePrint
+class SerialConsole : public StreamAPI, public RedirectablePrint, private concurrency::OSThread
 {
   public:
     SerialConsole();
@@ -24,8 +24,11 @@ class SerialConsole : public StreamAPI, public RedirectablePrint
         return RedirectablePrint::write(c);
     }
 
-  protected:
+    virtual int32_t runOnce() override;
 
+    void flush();
+
+  protected:
     /// Check the current underlying physical link to see if the client is currently connected
     virtual bool checkIsConnected() override;
 };

src/Status.h

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

src/airtime.cpp

@@ -10,18 +10,18 @@ void AirTime::logAirtime(reportTypes reportType, uint32_t airtime_ms)
 {
 
     if (reportType == TX_LOG) {
-        DEBUG_MSG("AirTime - Packet transmitted : %ums\n", airtime_ms);
+        LOG_DEBUG("AirTime - Packet transmitted : %ums\n", airtime_ms);
         this->airtimes.periodTX[0] = this->airtimes.periodTX[0] + airtime_ms;
         myNodeInfo.air_period_tx[0] = myNodeInfo.air_period_tx[0] + airtime_ms;
 
         this->utilizationTX[this->getPeriodUtilHour()] = this->utilizationTX[this->getPeriodUtilHour()] + airtime_ms;
 
     } else if (reportType == RX_LOG) {
-        DEBUG_MSG("AirTime - Packet received : %ums\n", airtime_ms);
+        LOG_DEBUG("AirTime - Packet received : %ums\n", airtime_ms);
         this->airtimes.periodRX[0] = this->airtimes.periodRX[0] + airtime_ms;
         myNodeInfo.air_period_rx[0] = myNodeInfo.air_period_rx[0] + airtime_ms;
     } else if (reportType == RX_ALL_LOG) {
-        DEBUG_MSG("AirTime - Packet received (noise?) : %ums\n", airtime_ms);
+        LOG_DEBUG("AirTime - Packet received (noise?) : %ums\n", airtime_ms);
         this->airtimes.periodRX_ALL[0] = this->airtimes.periodRX_ALL[0] + airtime_ms;
     }
 
@@ -34,11 +34,13 @@ uint8_t AirTime::currentPeriodIndex()
     return ((getSecondsSinceBoot() / SECONDS_PER_PERIOD) % PERIODS_TO_LOG);
 }
 
-uint8_t AirTime::getPeriodUtilMinute() {
+uint8_t AirTime::getPeriodUtilMinute()
+{
     return (getSecondsSinceBoot() / 10) % CHANNEL_UTILIZATION_PERIODS;
 }
 
-uint8_t AirTime::getPeriodUtilHour() {
+uint8_t AirTime::getPeriodUtilHour()
+{
     return (getSecondsSinceBoot() / 60) % MINUTES_IN_HOUR;
 }
 
@@ -46,7 +48,7 @@ void AirTime::airtimeRotatePeriod()
 {
 
     if (this->airtimes.lastPeriodIndex != this->currentPeriodIndex()) {
-        DEBUG_MSG("Rotating airtimes to a new period = %u\n", this->currentPeriodIndex());
+        LOG_DEBUG("Rotating airtimes to a new period = %u\n", this->currentPeriodIndex());
 
         for (int i = PERIODS_TO_LOG - 2; i >= 0; --i) {
             this->airtimes.periodTX[i + 1] = this->airtimes.periodTX[i];
@@ -101,7 +103,7 @@ float AirTime::channelUtilizationPercent()
     uint32_t sum = 0;
     for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) {
         sum += this->channelUtilization[i];
-        // DEBUG_MSG("ChanUtilArray %u %u\n", i, this->channelUtilization[i]);
+        // LOG_DEBUG("ChanUtilArray %u %u\n", i, this->channelUtilization[i]);
     }
 
     return (float(sum) / float(CHANNEL_UTILIZATION_PERIODS * 10 * 1000)) * 100;
@@ -117,9 +119,46 @@ float AirTime::utilizationTXPercent()
     return (float(sum) / float(MS_IN_HOUR)) * 100;
 }
 
-AirTime::AirTime() : concurrency::OSThread("AirTime"),airtimes({}) {
+bool AirTime::isTxAllowedChannelUtil(bool polite)
+{
+    uint8_t percentage = (polite ? polite_channel_util_percent : max_channel_util_percent);
+    if (channelUtilizationPercent() < percentage) {
+        return true;
+    } else {
+        LOG_WARN("Channel utilization is >%d percent. Skipping this opportunity to send.\n", percentage);
+        return false;
+    }
 }
 
+bool AirTime::isTxAllowedAirUtil()
+{
+    if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
+        if (utilizationTXPercent() < myRegion->dutyCycle * polite_duty_cycle_percent / 100) {
+            return true;
+        } else {
+            LOG_WARN("Tx air utilization is >%f percent. Skipping this opportunity to send.\n",
+                     myRegion->dutyCycle * polite_duty_cycle_percent / 100);
+            return false;
+        }
+    }
+    return true;
+}
+
+// Get the amount of minutes we have to be silent before we can send again
+uint8_t AirTime::getSilentMinutes(float txPercent, float dutyCycle)
+{
+    float newTxPercent = txPercent;
+    for (int8_t i = MINUTES_IN_HOUR - 1; i >= 0; --i) {
+        newTxPercent -= ((float)this->utilizationTX[i] / (MS_IN_MINUTE * MINUTES_IN_HOUR / 100));
+        if (newTxPercent < dutyCycle)
+            return MINUTES_IN_HOUR - 1 - i;
+    }
+
+    return MINUTES_IN_HOUR;
+}
+
+AirTime::AirTime() : concurrency::OSThread("AirTime"), airtimes({}) {}
+
 int32_t AirTime::runOnce()
 {
     secSinceBoot++;
@@ -174,14 +213,14 @@ int32_t AirTime::runOnce()
         // Update channel_utilization every second.
         myNodeInfo.air_util_tx = airTime->utilizationTXPercent();
     }
-/*
+    /*
-    DEBUG_MSG("utilPeriodTX %d TX Airtime %3.2f%\n", utilPeriodTX, airTime->utilizationTXPercent());
+        LOG_DEBUG("utilPeriodTX %d TX Airtime %3.2f%\n", utilPeriodTX, airTime->utilizationTXPercent());
         for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) {
-        DEBUG_MSG(
+            LOG_DEBUG(
                 "%d,", this->utilizationTX[i]
                 );
         }
-    DEBUG_MSG("\n");
+        LOG_DEBUG("\n");
-*/
+    */
     return (1000 * 1);
 }

src/airtime.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "MeshRadio.h"
 #include "concurrency/OSThread.h"
 #include "configuration.h"
 #include <Arduino.h>
@@ -29,9 +30,9 @@
 #define PERIODS_TO_LOG 8
 #define MINUTES_IN_HOUR 60
 #define SECONDS_IN_MINUTE 60
+#define MS_IN_MINUTE (SECONDS_IN_MINUTE * 1000)
 #define MS_IN_HOUR (MINUTES_IN_HOUR * SECONDS_IN_MINUTE * 1000)
 
-
 enum reportTypes { TX_LOG, RX_LOG, RX_ALL_LOG };
 
 void logAirtime(reportTypes reportType, uint32_t airtime_ms);
@@ -57,12 +58,18 @@ class AirTime : private concurrency::OSThread
     uint32_t getSecondsPerPeriod();
     uint32_t getSecondsSinceBoot();
     uint32_t *airtimeReport(reportTypes reportType);
+    uint8_t getSilentMinutes(float txPercent, float dutyCycle);
+    bool isTxAllowedChannelUtil(bool polite = false);
+    bool isTxAllowedAirUtil();
 
   private:
     bool firstTime = true;
     uint8_t lastUtilPeriod = 0;
     uint8_t lastUtilPeriodTX = 0;
     uint32_t secSinceBoot = 0;
+    uint8_t max_channel_util_percent = 40;
+    uint8_t polite_channel_util_percent = 25;
+    uint8_t polite_duty_cycle_percent = 50; // half of Duty Cycle allowance is ok for metadata
 
     struct airtimeStruct {
         uint32_t periodTX[PERIODS_TO_LOG];     // AirTime transmitted

src/buzz/buzz.cpp

@@ -1,22 +1,14 @@
 #include "buzz.h"
+#include "NodeDB.h"
 #include "configuration.h"
 
-#ifndef PIN_BUZZER
+#if !defined(ARCH_ESP32) && !defined(ARCH_RP2040) && !defined(ARCH_PORTDUINO)
-
-// Noop methods for boards w/o buzzer
-void playBeep(){};
-void playStartMelody(){};
-void playShutdownMelody(){};
-
-#else
-#ifdef M5STACK
-#include "Speaker.h"
-TONE Tone;
-#else
 #include "Tone.h"
 #endif
 
+#if !defined(ARCH_PORTDUINO)
 extern "C" void delay(uint32_t dwMs);
+#endif
 
 struct ToneDuration {
     int frequency_khz;
@@ -36,45 +28,41 @@ struct ToneDuration {
 #define NOTE_A3 220
 #define NOTE_AS3 233
 #define NOTE_B3 247
+#define NOTE_CS4 277
 
 const int DURATION_1_8 = 125; // 1/8 note
 const int DURATION_1_4 = 250; // 1/4 note
 
-void playTones(const ToneDuration *tone_durations, int size) {
+void playTones(const ToneDuration *tone_durations, int size)
+{
+#ifdef PIN_BUZZER
+    if (!config.device.buzzer_gpio)
+        config.device.buzzer_gpio = PIN_BUZZER;
+#endif
+    if (config.device.buzzer_gpio) {
         for (int i = 0; i < size; i++) {
             const auto &tone_duration = tone_durations[i];
-#ifdef M5STACK
+            tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
-    Tone.tone(tone_duration.frequency_khz);
-    delay(tone_duration.duration_ms);
-    Tone.mute();
-#else
-    tone(PIN_BUZZER, tone_duration.frequency_khz, tone_duration.duration_ms);
-#endif
             // to distinguish the notes, set a minimum time between them.
             delay(1.3 * tone_duration.duration_ms);
         }
+    }
 }
 
-#ifdef M5STACK
+void playBeep()
-void playBeep() {
+{
     ToneDuration melody[] = {{NOTE_B3, DURATION_1_4}};
     playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
-#else
-void playBeep() { tone(PIN_BUZZER, NOTE_B3, DURATION_1_4); }
-#endif
 
-void playStartMelody() {
+void playStartMelody()
-  ToneDuration melody[] = {{NOTE_B3, DURATION_1_4},
+{
-                           {NOTE_B3, DURATION_1_8},
+    ToneDuration melody[] = {{NOTE_FS3, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_CS4, DURATION_1_4}};
-                           {NOTE_B3, DURATION_1_8}};
     playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
-void playShutdownMelody() {
+void playShutdownMelody()
-  ToneDuration melody[] = {{NOTE_B3, DURATION_1_4},
+{
-                           {NOTE_G3, DURATION_1_8},
+    ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8}, {NOTE_AS3, DURATION_1_8}, {NOTE_FS3, DURATION_1_4}};
-                           {NOTE_D3, DURATION_1_8}};
     playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
-#endif

src/commands.h

@@ -14,4 +14,5 @@ enum class Cmd {
     STOP_BOOT_SCREEN,
     PRINT,
     START_SHUTDOWN_SCREEN,
+    START_REBOOT_SCREEN,
 };

src/concurrency/BinarySemaphoreFreeRTOS.cpp

@@ -1,5 +1,5 @@
-#include "configuration.h"
 #include "concurrency/BinarySemaphoreFreeRTOS.h"
+#include "configuration.h"
 #include <assert.h>
 
 #ifdef HAS_FREE_RTOS

src/concurrency/BinarySemaphorePosix.cpp

@@ -1,18 +1,14 @@
-#include "configuration.h"
 #include "concurrency/BinarySemaphorePosix.h"
+#include "configuration.h"
 
 #ifndef HAS_FREE_RTOS
 
 namespace concurrency
 {
 
-BinarySemaphorePosix::BinarySemaphorePosix()
+BinarySemaphorePosix::BinarySemaphorePosix() {}
-{
-}
 
-BinarySemaphorePosix::~BinarySemaphorePosix()
+BinarySemaphorePosix::~BinarySemaphorePosix() {}
-{
-}
 
 /**
  * Returns false if we timed out
@@ -23,13 +19,9 @@ bool BinarySemaphorePosix::take(uint32_t msec)
     return false;
 }
 
-void BinarySemaphorePosix::give()
+void BinarySemaphorePosix::give() {}
-{
-}
 
-IRAM_ATTR void BinarySemaphorePosix::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken)
+IRAM_ATTR void BinarySemaphorePosix::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken) {}
-{
-}
 
 } // namespace concurrency
 

src/concurrency/InterruptableDelay.cpp

@@ -1,5 +1,5 @@
-#include "configuration.h"
 #include "concurrency/InterruptableDelay.h"
+#include "configuration.h"
 
 namespace concurrency
 {
@@ -13,12 +13,12 @@ InterruptableDelay::~InterruptableDelay() {}
  */
 bool InterruptableDelay::delay(uint32_t msec)
 {
-    // DEBUG_MSG("delay %u ", msec);
+    // LOG_DEBUG("delay %u ", msec);
 
     // sem take will return false if we timed out (i.e. were not interrupted)
     bool r = semaphore.take(msec);
 
-    // DEBUG_MSG("interrupt=%d\n", r);
+    // LOG_DEBUG("interrupt=%d\n", r);
     return !r;
 }
 

src/concurrency/InterruptableDelay.h

@@ -2,7 +2,6 @@
 
 #include "../freertosinc.h"
 
-
 #ifdef HAS_FREE_RTOS
 #include "concurrency/BinarySemaphoreFreeRTOS.h"
 #define BinarySemaphore BinarySemaphoreFreeRTOS

src/concurrency/Lock.cpp

@@ -1,5 +1,5 @@
-#include "configuration.h"
 #include "Lock.h"
+#include "configuration.h"
 #include <cassert>
 
 namespace concurrency