Remove HAS_GPS for WSLv3

re-merge fixes by @lesykm

.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,54 +23,23 @@ 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-coreink
+          - board: tbeam-s3-core
+          - board: tlora-t3s3-v1
           
     runs-on: ubuntu-latest
     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
-        run: |
-          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
+      - uses: actions/checkout@v3
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
       - name: Check ${{ matrix.board }}
         run: bin/check-all.sh ${{ matrix.board }}
@@ -86,73 +54,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
-
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
+          - board: station-g1
+          - board: m5stack-core
+          - board: m5stack-coreink
+          - board: tbeam-s3-core
+          - board: tlora-t3s3-v1
+    uses: ./.github/workflows/build_esp32.yml
     with:
-          submodules: "recursive"
-          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
+      board: ${{ matrix.board }}
 
   build-nrf52:
     strategy:
@@ -164,85 +84,29 @@ jobs:
           - board: rak4631_eink
           - board: t-echo
           - board: pca10059_diy_eink
-
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
+          - board: feather_diy
+    uses: ./.github/workflows/build_nrf52.yml
     with:
-          submodules: "recursive"
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
+      board: ${{ matrix.board }}
 
-      - name: Setup Python
-        uses: actions/setup-python@v2
+  build-rpi2040:
+    strategy:
+      fail-fast: false
+      max-parallel: 2
+      matrix:
+        include:
+          - board: pico
+    uses: ./.github/workflows/build_rpi2040.yml
     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
-
-      - 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
+      board: ${{ matrix.board }}
 
   build-native:
     runs-on: ubuntu-latest
     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: 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
+      - uses: actions/checkout@v3
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
       # We now run integration test before other build steps (to quickly see runtime failures)
       - name: Build for native
@@ -258,18 +122,36 @@ jobs:
         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
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        uses: docker/login-action@v2
+        with: 
+          username: meshtastic
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Docker setup
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        uses: docker/setup-buildx-action@v2
+
+      - name: Docker build and push
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: meshtastic/device-simulator:latest
       
   after-checks:
     runs-on: ubuntu-latest
@@ -283,7 +165,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
@@ -291,30 +173,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
@@ -323,15 +205,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' }}
@@ -344,3 +231,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/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,44 @@
+---
+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,28 @@
+---
+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.5-linux-x86.tar.gz
-          tar xvzf nanopb-0.4.5-linux-x86.tar.gz
-          mv nanopb-0.4.5-linux-x86 nanopb-0.4.5
+          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.7-linux-x86.tar.gz
+          tar xvzf nanopb-0.4.7-linux-x86.tar.gz
+          mv nanopb-0.4.7-linux-x86 nanopb-0.4.7
 
       - 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

.vscode/settings.json

@@ -51,7 +51,10 @@
         "iterator": "cpp",
         "shared_mutex": "cpp",
         "iostream": "cpp",
-        "esp_nimble_hci.h": "c"
+        "esp_nimble_hci.h": "c",
+        "map": "cpp",
+        "random": "cpp",
+        "*.tpp": "cpp"
     },
     "cSpell.words": [
         "Blox",

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)
-[![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)
-[![CLA assistant](https://cla-assistant.io/readme/badge/meshtastic/Meshtastic-device)](https://cla-assistant.io/meshtastic/Meshtastic-device)
+![GitHub release downloads](https://img.shields.io/github/downloads/meshtastic/firmware/total)
+[![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/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/developers/Firmware/build)**
+**[Building Instructions](https://meshtastic.org/docs/development/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"
-#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 images/system-info.bin $OUTDIR/system-info.bin
-
+cp .pio/build/tbeam/littlefs.bin $OUTDIR/littlefs-$VERSION.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 921600 erase_flash
-	%PYTHON% -m esptool --baud 921600 write_flash 0x1000 system-info.bin
+	%PYTHON% -m esptool --baud 115200 erase_flash
+	%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 921600 write_flash 0x00390000 %%f
+        %PYTHON% -m esptool --baud 115200 write_flash 0x300000 %%f
     )
-	%PYTHON% -m esptool --baud 921600 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 0x00390000 littlefs-*.bin
-	"$PYTHON" -m esptool  write_flash 0x10000 ${FILENAME}
+	"$PYTHON" -m esptool  write_flash 0x00 ${FILENAME}
+    "$PYTHON" -m esptool  write_flash 0x260000 bleota.bin
+	"$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 921600 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 921600 erase_region 0xe000 0x2000
+    %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-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
-	echo "Trying to flash update ${FILENAME}."
-	$PYTHON -m esptool --baud 921600 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 921600 erase_region 0xe000 0x2000
+if [ -f "${FILENAME}" ] && [ -z "${FILENAME##*"update"*}" ]; then
+	printf "Trying to flash update ${FILENAME}"
+	$PYTHON -m esptool --baud 115200 write_flash 0x10000 ${FILENAME}
 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' )
-try:
-    import littlefs
-except ImportError:
-    env.Execute("$PYTHONEXE -m pip install littlefs-python")
+platform = env.PioPlatform()
+
+def esp32_create_combined_bin(source, target, env):
+    # this sub is borrowed from ESPEasy build toolchain. It's licensed under GPL V3
+    # 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 platform-custom.py, firmare version " + verObj['long'])
-# print("path is" + ','.join(sys.path))
+print("Using meshtastic platformio-custom.py, firmware version " + verObj['long'])
 
 # 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/read-system-info.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-esptool.py --baud 921600 read_flash 0x1000 0xf000 system-info.img
+esptool.py --baud 115200 read_flash 0x1000 0xf000 system-info.img

bin/readprops.py

@@ -32,6 +32,6 @@ def readProps(prefsLoc):
         # traceback.print_exc()
         verObj['long'] = verObj['short']
 
-    # print("firmare version " + verStr)
+    # print("firmware version " + verStr)
     return verObj
 # print("path is" + ','.join(sys.path))

bin/regen-protos.bat

@@ -1 +1 @@
-cd protobufs && ..\nanopb-0.4.5\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 *.proto

bin/regen-protos.sh

@@ -2,13 +2,13 @@
 
 set -e
 
-echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.5 to be located in the"
-echo "meshtastic-device root directory if the following step fails, you should download the correct"
-echo "prebuilt binaries for your computer into nanopb-0.4.5"
+echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.7 to be located in the"
+echo "firmware root directory if the following step fails, you should download the correct"
+echo "prebuilt binaries for your computer into nanopb-0.4.7"
 
 # the nanopb tool seems to require that the .options file be in the current directory!
 cd protobufs
-../nanopb-0.4.5/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 *.proto
 
 #echo "Regenerating protobuf documentation - if you see an error message"
 #echo "you can ignore it unless doing a new protobuf release to github."

boards/generic_wl5e.json

@@ -0,0 +1,31 @@
+{
+  "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/tbeam-s3-core.json

@@ -0,0 +1,46 @@
+{
+  "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,47 @@
+{
+  "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"
+}

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,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x1c0000,
-app1,     app,  ota_1,   0x1d0000,0x1c0000,
-spiffs,   data, spiffs,  0x390000,0x070000,
+nvs,      data, nvs,     0x009000, 0x005000,
+otadata,  data, ota,     0x00e000, 0x002000,
+app,      app,  ota_0,   0x010000, 0x250000,
+flashApp, app,  ota_1,   0x260000, 0x0A0000,
+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,134 +36,76 @@ 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 
   -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 = 921600
+monitor_speed = 115200
 
 lib_deps =
   https://github.com/meshtastic/esp8266-oled-ssd1306.git#53580644255b48ebb7a737343c6b4e71c7e11cf2 ; 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
-  https://github.com/meshtastic/TinyGPSPlus.git
-  Wire ; explicitly needed here because the AXP202 library forgets to add it
-  SPI
+  https://github.com/meshtastic/arduino-fsm.git#7db3702bf0cfe97b783d6c72595e3f38e0b19159
+  https://github.com/meshtastic/TinyGPSPlus.git#127ad674ef85f0201cb68a065879653ed94792c4
   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#395844922c5d88d5db0481a9c91479931172428d
 
 ; 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
-  https://github.com/jgromes/RadioLib.git#3df3b092ebf412bd0b26524e7b296733bd6a62f7
-build_flags = ${env.build_flags} -Os 
-# -DRADIOLIB_GODMODE
-build_src_filter = ${env.build_src_filter} -<portduino/>
+  mprograms/QMC5883LCompass@^1.1.1
+  end2endzone/NonBlockingRTTTL@^1.3.0
+  https://github.com/meshtastic/SparkFun_ATECCX08a_Arduino_Library.git#52b5282639d08a8cbd4b748363089eed6102dc76
+
+build_flags = ${env.build_flags} -Os -DRADIOLIB_SPI_PARANOID=0
+build_src_filter = ${env.build_src_filter} -<platform/portduino/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT 
 [networking_base]
 lib_deps =
-  PubSubClient
-  meshtastic/json11@^1.0.2
+  knolleary/PubSubClient@^2.8
+  arduino-libraries/NTPClient@^3.1.0
 
 ; Common libs for environmental measurements in telemetry module 
 ; (not included in native / portduino)
 [environmental_base]
 lib_deps =
   adafruit/Adafruit BusIO@^1.11.4
-  adafruit/DHT sensor library@^1.4.1
   adafruit/Adafruit Unified Sensor@^1.1.4
-  paulstoffregen/OneWire@^2.3.5
-  robtillaart/DS18B20@^0.1.11
+  adafruit/Adafruit BMP280 Library@^2.6.6
   adafruit/Adafruit BME280 Library@^2.2.2
   adafruit/Adafruit BME680 Library@^2.0.1
   adafruit/Adafruit MCP9808 Library@^2.0.0
-
-; Common settings for ESP targes, mixin with extends = esp32_base
-[esp32_base]
-extends = arduino_base
-platform = espressif32@3.5.0
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<nrf52/>
-upload_speed = 921600
-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
-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.3.7
-  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/> -<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
+  adafruit/Adafruit INA260 Library@^1.5.0
+  adafruit/Adafruit INA219@^1.2.0
+  adafruit/Adafruit SHTC3 Library@^1.0.0
+  adafruit/Adafruit LPS2X@^2.0.4
+  adafruit/Adafruit SHT31 Library@^2.2.0

src/BluetoothCommon.cpp

@@ -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,
-                                        0x55, 0x4a, 0x02, 0xee, 0xc2, 0xbc, 0xa2, 0x8b};
+const uint8_t FROMRADIO_UUID_16[16u] = {0x02, 0x00, 0x12, 0xac, 0x42, 0x02, 0x78, 0xb8,
+                                        0xed, 0x11, 0x93, 0x49, 0x9e, 0xe6, 0x55, 0x2c};
 const uint8_t FROMNUM_UUID_16[16u] = {0x53, 0x44, 0xe3, 0x47, 0x75, 0xaa, 0x70, 0xa6,
                                       0x66, 0x4f, 0x00, 0xa8, 0x8c, 0xa1, 0x9d, 0xed};

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>
 
-#ifndef NO_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");
-        // else DEBUG_MSG("sleep ok\n");
+        // if (!canSleep) LOG_DEBUG("Supressing sleep!\n");
+        // else LOG_DEBUG("sleep ok\n");
 
         return 5;
     }
@@ -111,12 +108,12 @@ 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) ||
             !moduleConfig.canned_message.enabled) {
@@ -126,57 +123,71 @@ class ButtonThread : public concurrency::OSThread
     }
     static void userButtonPressedLong()
     {
-        // DEBUG_MSG("Long press!\n");
-#ifndef NRF52_SERIES
+        // 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
-            if (axp192_found == true) {
+#ifdef HAS_PMU
+            if (pmu_found == true) {
                 setLed(false);
                 power->shutdown();
             }
-#elif NRF52_SERIES
+#elif defined(ARCH_NRF52)
             // Do actual shutdown when button released, otherwise the button release
             // may wake the board immediatedly.
             if ((!shutdown_on_long_stop) && (millis() > 30 * 1000)) {
                 screen->startShutdownScreen();
-                DEBUG_MSG("Shutdown from long press");
+                LOG_INFO("Shutdown from long press");
                 playBeep();
+#ifdef PIN_LED1
                 ledOff(PIN_LED1);
+#endif
+#ifdef PIN_LED2        
                 ledOff(PIN_LED2);
+#endif
+#ifdef PIN_LED3        
+                ledOff(PIN_LED3);
+#endif
                 shutdown_on_long_stop = true;
             }
 #endif
         } else {
-            // DEBUG_MSG("Long press %u\n", (millis() - longPressTime));
+            // LOG_DEBUG("Long press %u\n", (millis() - longPressTime));
         }
     }
 
     static void userButtonDoublePressed()
     {
-#ifndef NO_ESP32
-        disablePin();
-#elif defined(HAS_EINK)
+    #if defined(USE_EINK) && defined(PIN_EINK_EN)
         digitalWrite(PIN_EINK_EN, digitalRead(PIN_EINK_EN) == LOW);
     #endif
+    #if defined(GPS_POWER_TOGGLE)
+        if(config.position.gps_enabled)
+        {
+        LOG_DEBUG("Flag set to false for gps power\n");
+        } 
+        else 
+        {
+        LOG_DEBUG("Flag set to true to restore power\n");
+        }
+    config.position.gps_enabled = !(config.position.gps_enabled);
+    doGPSpowersave(config.position.gps_enabled);
+    #endif
     }
 
     static void userButtonMultiPressed()
     {
-#ifndef NO_ESP32
-        clearNVS();
-#endif
-#ifdef NRF52_SERIES
-        clearBonds();
-#endif
+        screen->print("Sent ad-hoc ping\n");
+        service.refreshMyNodeInfo();
+        service.sendNetworkPing(NODENUM_BROADCAST, true);
     }
 
     static void userButtonPressedLongStart()
     {
         if (millis() > 30 * 1000) {
-            DEBUG_MSG("Long press start!\n");
+            LOG_DEBUG("Long press start!\n");
             longPressTime = millis();
         }
     }
@@ -184,7 +195,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

@@ -10,43 +10,36 @@
 #ifdef CONSOLE_MAX_BAUD
 #define SERIAL_BAUD CONSOLE_MAX_BAUD
 #else
-#define SERIAL_BAUD 921600 // Serial debug baud rate
+#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
 
-// What platforms should use SEGGER?
-#ifdef NRF52_SERIES
-
-// Always include the SEGGER code on NRF52 - because useful for debugging
-#include "SEGGER_RTT.h"
-
-// The channel we send stdout data to
-#define SEGGER_STDOUT_CH 0
-
-// Debug printing to segger console
-#define SEGGER_MSG(...) SEGGER_RTT_printf(SEGGER_STDOUT_CH, __VA_ARGS__)
-
-// If we are not on a NRF52840 (which has built in USB-ACM serial support) and we don't have serial pins hooked up, then we MUST
-// use SEGGER for debug output
-#if !defined(PIN_SERIAL_RX) && !defined(NRF52840_XXAA)
-// No serial ports on this board - ONLY use segger in memory console
-#define USE_SEGGER
-#endif
-
-#else
-#define SERIAL0_RX_GPIO 3 // Always GPIO3 on ESP32
-#endif
-
 #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,10 +1,70 @@
 #include "configuration.h"
 #include "FSCommon.h"
 
-void listDir(const char * dirname, uint8_t levels)
-#ifdef FSCom
+#ifdef HAS_SDCARD
+#include <SPI.h>
+#include <SD.h>
+
+
+#ifdef SDCARD_USE_SPI1  
+SPIClass SPI1(HSPI);
+#define SDHandler SPI1
+#endif
+
+
+#endif  //HAS_SDCARD
+
+bool copyFile(const char* from, const char* to)
 {
-    File root = FSCom.open(dirname);
+#ifdef FSCom
+    unsigned char cbuffer[16];
+   
+    File f1 = FSCom.open(from, FILE_O_READ);
+    if (!f1){
+        LOG_ERROR("Failed to open source file %s\n", from);
+        return false;
+    }
+
+    File f2 = FSCom.open(to, FILE_O_WRITE);
+    if (!f2) {
+        LOG_ERROR("Failed to open destination file %s\n", to);
+        return false;
+    }
+   
+    while (f1.available() > 0) {
+        byte i = f1.read(cbuffer, 16);
+        f2.write(cbuffer, i);
+    }
+   
+    f2.close();
+    f1.close();
+    return true;
+#endif
+}
+
+bool renameFile(const char* pathFrom, const char* pathTo)
+{
+#ifdef FSCom
+#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{
+        return false;
+    }
+#endif
+#endif
+}
+
+void listDir(const char * dirname, uint8_t levels, boolean del = false)
+{
+#ifdef FSCom
+#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+    char buffer[255];
+#endif
+    File root = FSCom.open(dirname, FILE_O_READ);
     if(!root){
         return;
     }
@@ -16,15 +76,92 @@ void listDir(const char * dirname, uint8_t levels)
     while(file){
         if(file.isDirectory() && !String(file.name()).endsWith(".")) {
             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());
+                    strcpy(buffer, file.path());
+                    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());
+                    strcpy(buffer, file.name());
+                    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());
+                strcpy(buffer, file.path());
                 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());
+                strcpy(buffer, file.name());
+                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());
+        strcpy(buffer, root.path());
+        root.close();
+        FSCom.rmdir(buffer);
+    } else {
+        root.close();
+    }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+    if(del) { 
+        LOG_DEBUG("Removing %s\n", root.name());
+        strcpy(buffer, root.name());
+        root.close();
+        FSCom.rmdir(buffer);
+    } else {
+        root.close();
+    }
+#else
+    root.close();
+#endif
+#endif
+}
+
+void rmDir(const char * dirname)
+{
+#ifdef FSCom
+#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+    listDir(dirname, 10, true);
+#elif defined(ARCH_NRF52)
+    // nRF52 implementation of LittleFS has a recursive delete function
+    FSCom.rmdir_r(dirname);
+#endif
 #endif
 }
 
@@ -33,11 +170,50 @@ void fsInit()
 #ifdef FSCom
     if (!FSBegin())
     {
-        DEBUG_MSG("ERROR filesystem mount Failed. Formatting...\n");
-        assert(0); // FIXME - report failure to phone
+        LOG_ERROR("Filesystem mount Failed.\n");
+        // assert(0); This auto-formats the partition, so no need to fail here.
     }
-
-    DEBUG_MSG("Filesystem files:\n");
+#ifdef ARCH_ESP32
+    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

@@ -4,26 +4,44 @@
 
 // Cross platform filesystem API
 
-#ifdef PORTDUINO
+#if defined(ARCH_PORTDUINO)
 // Portduino version
 #include "PortduinoFS.h"
 #define FSCom PortduinoFS
 #define FSBegin() true
 #define FILE_O_WRITE "w"
 #define FILE_O_READ "r"
-#elif !defined(NO_ESP32)
-// ESP32 version
-#include "LITTLEFS.h"
-#define FSCom LITTLEFS
-#define FSBegin() FSCom.begin(true)
+#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"
-#else
+#endif
+
+#if defined(ARCH_ESP32)
+// ESP32 version
+#include "LittleFS.h"
+#define FSCom LittleFS
+#define FSBegin() FSCom.begin(true) // format on failure
+#define FILE_O_WRITE "w"
+#define FILE_O_READ "r"
+#endif
+
+#if defined(ARCH_NRF52)
 // 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 copyFile(const char* from, const char* to);
+bool renameFile(const char* pathFrom, const char* pathTo);
+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
 
+    bool isPowerSaving = false; //Are we in power saving state
+
     Position p = 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 Position &pos) : Status()
     {
         this->hasLock = hasLock;
         this->isConnected = isConnected;
+        this->isPowerSaving = isPowerSaving;
 
         // all-in-one struct copy
         this->p = pos;
@@ -60,11 +47,13 @@ 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());
             return node->position.latitude_i;
@@ -77,7 +66,7 @@ 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());
             return node->position.longitude_i;
@@ -90,7 +79,7 @@ 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());
             return node->position.altitude;
@@ -108,12 +97,13 @@ class GPSStatus : public Status
     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 ||
+        return (newStatus->hasLock != hasLock || newStatus->isConnected != isConnected || newStatus->isPowerSaving !=isPowerSaving ||
                 newStatus->p.latitude_i != p.latitude_i || newStatus->p.longitude_i != p.longitude_i ||
                 newStatus->p.altitude != p.altitude || newStatus->p.altitude_hae != p.altitude_hae ||
                 newStatus->p.PDOP != p.PDOP || newStatus->p.ground_track != p.ground_track ||
+                newStatus->p.ground_speed != p.ground_speed ||
                 newStatus->p.sats_in_view != p.sats_in_view);
     }
 
@@ -122,9 +112,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 +126,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

@@ -70,7 +70,7 @@ namespace meshtastic {
                 numTotal = newStatus->getNumTotal();
             }
             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;

src/OSTimer.cpp

@@ -15,7 +15,7 @@ bool scheduleOSCallback(PendableFunction callback, void *param1, uint32_t param2
     return xTimerPendFunctionCall(callback, param1, param2, pdMS_TO_TICKS(delayMsec));
 } */
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
 
 // Super skanky quick hack to use hardware timers of the ESP32
 static hw_timer_t *timer;

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

@@ -5,13 +5,13 @@
 #include "main.h"
 #include "sleep.h"
 #include "utils.h"
+#include "buzz/buzz.h"
 
-#ifdef TBEAM_V10
-// FIXME. nasty hack cleanup how we load axp192
-#undef AXP192_SLAVE_ADDRESS
-#include "axp20x.h"
-
-AXP20X_Class axp;
+#ifdef HAS_PMU
+#include "XPowersLibInterface.hpp"
+#include "XPowersAXP2101.tpp"
+#include "XPowersAXP192.tpp"
+XPowersLibInterface *PMU = NULL;
 #else
 // Copy of the base class defined in axp20x.h.
 // I'd rather not inlude axp20x.h as it brings Wire dependency.
@@ -21,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 isChargeing() { return false; }
+    virtual bool isVbusIn() { return false; }
+    virtual bool isCharging() { return false; }
 };
 #endif
 
@@ -45,7 +45,7 @@ Power *power;
 using namespace meshtastic;
 
 #ifndef AREF_VOLTAGE
-#if defined(NRF52_SERIES)
+#if defined(ARCH_NRF52)
 /*
  * Internal Reference is +/-0.6V, with an adjustable gain of 1/6, 1/5, 1/4,
  * 1/3, 1/2 or 1, meaning 3.6, 3.0, 2.4, 1.8, 1.2 or 0.6V for the ADC levels.
@@ -76,14 +76,14 @@ 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();
 
         if (v < noBatVolt)
             return -1; // If voltage is super low assume no battery installed
 
-#ifndef NRF52_SERIES
+#ifdef ARCH_ESP32
         // This does not work on a RAK4631 with battery connected
         if (v > chargingVolt)
             return 0; // While charging we can't report % full on the battery
@@ -95,13 +95,17 @@ 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
@@ -111,43 +115,63 @@ class AnalogBatteryLevel : public HasBatteryLevel
         const uint32_t min_read_interval = 5000;
         if (millis() - last_read_time_ms > min_read_interval) {
             last_read_time_ms = millis();
-            uint32_t raw = analogRead(BATTERY_PIN);
+
+//Set the number of samples, it has an effect of increasing sensitivity, especially in complex electromagnetic environment.
+            uint32_t raw = 0;
+            for(uint32_t i=0; i<BATTERY_SENSE_SAMPLES; i++){
+                raw += analogRead(BATTERY_PIN);
+            }
+            raw = raw/BATTERY_SENSE_SAMPLES;
+
             float scaled;
 #ifndef VBAT_RAW_TO_SCALED
             scaled = 1000.0 * operativeAdcMultiplier * (AREF_VOLTAGE / 1024.0) * raw;
 #else
             scaled = VBAT_RAW_TO_SCALED(raw); // defined in variant.h
 #endif
-            // 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;
 };
@@ -158,21 +182,24 @@ 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);
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
     // ESP32 needs special analog stuff
     adcAttachPin(BATTERY_PIN);
 #endif
-#ifdef NRF52_SERIES
+#ifdef ARCH_NRF52
 #ifdef VBAT_AR_INTERNAL
     analogReference(VBAT_AR_INTERNAL);
 #else
@@ -196,7 +223,7 @@ bool Power::analogInit()
 
 bool Power::setup()
 {
-    bool found = axp192Init();
+    bool found = axpChipInit();
 
     if (!found) {
         found = analogInit();
@@ -209,10 +236,21 @@ bool Power::setup()
 
 void Power::shutdown()
 {
-#ifdef TBEAM_V10
-    DEBUG_MSG("Shutting down\n");
-    axp.shutdown();
-#elif NRF52_SERIES
+    screen->setOn(false);
+#if defined(USE_EINK) && defined(PIN_EINK_EN)
+    digitalWrite(PIN_EINK_EN, LOW); //power off backlight first
+#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);
+    ledOff(PIN_LED2);
     doDeepSleep(DELAY_FOREVER);
 #endif
 }
@@ -229,8 +267,8 @@ void Power::readPowerStatus()
         if (hasBattery) {
             batteryVoltageMv = batteryLevel->getBattVoltage();
             // If the AXP192 returns a valid battery percentage, use it
-            if (batteryLevel->getBattPercentage() >= 0) {
-                batteryChargePercent = batteryLevel->getBattPercentage();
+            if (batteryLevel->getBatteryPercent() >= 0) {
+                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
@@ -243,20 +281,40 @@ void Power::readPowerStatus()
 
         // Notify any status instances that are observing us
         const PowerStatus powerStatus2 =
-            PowerStatus(hasBattery ? OptTrue : OptFalse, batteryLevel->isVBUSPlug() ? OptTrue : OptFalse,
-                        batteryLevel->isChargeing() ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
-        DEBUG_MSG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
+            PowerStatus(hasBattery ? OptTrue : OptFalse, batteryLevel->isVbusIn() ? OptTrue : OptFalse,
+                        batteryLevel->isCharging() ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
+        LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
                   powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
         newStatus.notifyObservers(&powerStatus2);
+#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
-#ifdef NRF52_SERIES
+#ifdef ARCH_NRF52
         if (powerStatus2.getHasBattery() && !powerStatus2.getHasUSB()) {
             if (batteryLevel->getBattVoltage() < MIN_BAT_MILLIVOLTS) {
                 low_voltage_counter++;
-                if (low_voltage_counter > 3)
-                    powerFSM.trigger(EVENT_LOW_BATTERY);
+                LOG_DEBUG("Warning RAK4631 Low voltage counter: %d/10\n", low_voltage_counter);
+                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;
             }
@@ -277,41 +335,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()) {
-        DEBUG_MSG("USB unplugged\n");
+        PMU->getIrqStatus();
+
+        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()) {
-        DEBUG_MSG("Battery start charging\n");
+        if (PMU->isBatChagerStartIrq()) {
+            LOG_DEBUG("Battery start charging\n");
         }
-    if (axp.isChargingDoneIRQ()) {
-        DEBUG_MSG("Battery fully charged\n");
+        if (PMU->isBatChagerDoneIrq()) {
+            LOG_DEBUG("Battery fully charged\n");
         }
-    if (axp.isBattPlugInIRQ()) {
-        DEBUG_MSG("Battery inserted\n");
+        if (PMU->isBatInsertIrq()) {
+            LOG_DEBUG("Battery inserted\n");
         }
-    if (axp.isBattRemoveIRQ()) {
-        DEBUG_MSG("Battery removed\n");
-    }
-    if (axp.isPEKShortPressIRQ()) {
-        DEBUG_MSG("PEK short button press\n");
+        if (PMU->isBatRemoveIrq()) {
+            LOG_DEBUG("Battery removed\n");
         }
         */
-    axp.clearIRQ();
-#endif
+        if (PMU->isPekeyLongPressIrq()) {
+            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;
 }
@@ -324,128 +388,244 @@ 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);
-            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");
+        TwoWire * w = NULL;
 
-            axp.setPowerOutPut(AXP192_LDO2, AXP202_ON); // LORA radio
-            // axp.setPowerOutPut(AXP192_LDO3, AXP202_ON); // GPS main power - now turned on in setGpsPower
-            axp.setPowerOutPut(AXP192_DCDC2, AXP202_ON);
-            axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON);
-            axp.setPowerOutPut(AXP192_DCDC1, AXP202_ON);
-            axp.setDCDC1Voltage(3300); // for the OLED power
+    // Use macro to distinguish which wire is used by PMU
+#ifdef PMU_USE_WIRE1
+        w = &Wire1;
+#else
+        w = &Wire;
+#endif
 
-            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");
-
-            switch (config.power.charge_current) {
-            case Config_PowerConfig_ChargeCurrent_MAUnset:
-                axp.setChargeControlCur(AXP1XX_CHARGE_CUR_450MA);
-                break;
-            case Config_PowerConfig_ChargeCurrent_MA100:
-                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;
+    /**
+     * It is not necessary to specify the wire pin, 
+     * just input the wire, because the wire has been initialized in main.cpp
+     */
+    if (!PMU) {
+        PMU = new XPowersAXP2101(*w);
+        if (!PMU->init()) {
+            LOG_WARN("Failed to find AXP2101 power management\n");
+            delete PMU;
+            PMU = NULL;
+        } else {
+            LOG_INFO("AXP2101 PMU init succeeded, using AXP2101 PMU\n");
+        }
     }
 
-#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
-      //val = 0xfc;
-      //axp._writeByte(AXP202_VHTF_CHGSET, 1, &val); // Set temperature protection
-
-      //not used
-      //val = 0x46;
-      //axp._writeByte(AXP202_OFF_CTL, 1, &val); // enable bat detection
+    if (!PMU) {
+                /*
+        * 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, 
+        * if there are multiple devices sharing the bus.
+        * * */
+#ifndef PMU_USE_WIRE1
+        w->begin(I2C_SDA, I2C_SCL);
 #endif
-            axp.debugCharging();
+        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
+
 
 #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 AXP202_CHARGING_FINISHED_IRQ & AXP202_CHARGING_IRQ because it occurs repeatedly while there is
+        // we do not look for AXPXXX_CHARGING_FINISHED_IRQ & AXPXXX_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 at AXP202_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);
+        // we don't look for AXPXXX_BATT_REMOVED_IRQ because it occurs repeatedly while no battery installed
+        // we don't look at AXPXXX_VBUS_REMOVED_IRQ because we don't have anything hooked to vbus
+        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,37 +11,37 @@
 /// Should we behave as if we have AC power now?
 static bool isPowered()
 {
-    // Completely circumvents the battery / power sensing logic and assumes constant power source
-    if (config.power.is_always_powered) {
+    // Circumvent the battery sensing logic and assumes constant power if no battery pin or power mgmt IC
+    #if !defined(BATTERY_PIN) && !defined(HAS_AXP192) && !defined(HAS_AXP2101)
         return true;
-    }
+    #endif
 
-    bool isRouter = (config.device.role == Config_DeviceConfig_Role_Router ? 1 : 0);
+    bool isRouter = (config.device.role == Config_DeviceConfig_Role_ROUTER ? 1 : 0);
 
     // If we are not a router and we already have AC power go to POWER state after init, otherwise go to ON
     // We assume routers might be powered all the time, but from a low current (solar) source
-    bool isLowPower = config.power.is_low_power || isRouter;
+    bool isPowerSavingMode = config.power.is_power_saving || isRouter;
 
     /* To determine if we're externally powered, assumptions
         1) If we're powered up and there's no battery, we must be getting power externally. (because we'd be dead otherwise)
 
         2) If we detect USB power from the power management chip, we must be getting power externally.
     */
-    return !isLowPower && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
+    return !isPowerSavingMode && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
 }
 
 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",
-              config.power.ls_secs ? config.power.ls_secs : default_ls_secs);
+    LOG_INFO("lsEnter begin, ls_secs=%u\n", config.power.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());
 
-#ifndef NO_ESP32
+#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,8 +199,7 @@ static void onEnter()
 
     uint32_t now = millis();
 
-    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 ((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
         lastPingMs = now;
@@ -223,7 +221,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 +237,10 @@ Fsm powerFSM(&stateBOOT);
 
 void PowerFSM_setup()
 {
-    bool isRouter = (config.device.role == Config_DeviceConfig_Role_Router ? 1 : 0);
+    bool isRouter = (config.device.role == 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
@@ -251,8 +249,7 @@ void PowerFSM_setup()
 
     // We need this transition, because we might not transition if we were waiting to enter light-sleep, because when we wake from
     // light sleep we _always_ transition to NB or dark and
-    powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_PACKET_FOR_PHONE, NULL,
-                            "Received packet, exiting light sleep");
+    powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, exiting light sleep");
     powerFSM.add_transition(&stateNB, &stateNB, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, resetting win wake");
 
     // Handle press events - note: we ignore button presses when in API mode
@@ -261,8 +258,7 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateDARK, &stateON, EVENT_PRESS, NULL, "Press");
     powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_PRESS, screenPress, "Press");
     powerFSM.add_transition(&stateON, &stateON, EVENT_PRESS, screenPress, "Press"); // reenter On to restart our timers
-    powerFSM.add_transition(&stateSERIAL, &stateSERIAL, EVENT_PRESS, screenPress,
-                            "Press"); // Allow button to work while in serial API
+    powerFSM.add_transition(&stateSERIAL, &stateSERIAL, EVENT_PRESS, screenPress, "Press"); // Allow button to work while in serial API
 
     // Handle critically low power battery by forcing deep sleep
     powerFSM.add_transition(&stateBOOT, &stateSDS, EVENT_LOW_BATTERY, NULL, "LowBat");
@@ -328,53 +324,22 @@ 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, getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL, "Screen-on timeout");
 
-    powerFSM.add_timed_transition(&stateON, &stateDARK,
-                                  config.display.screen_on_secs ? config.display.screen_on_secs
-                                                                               : 60 * 1000,
-                                  NULL, "Screen-on timeout");
-
-    // On most boards we use light-sleep to be our main state, but on NRF52 we just stay in DARK
+#ifdef ARCH_ESP32
     State *lowPowerState = &stateLS;
-
-    uint32_t meshSds = 0;
-
-#ifndef NRF52_SERIES
     // 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) {
-
-        // I don't think this transition is correct, turning off for now - @geeksville
-        // powerFSM.add_timed_transition(&stateDARK, &stateNB, getPref_phone_timeout_secs() * 1000, NULL, "Phone timeout");
-        powerFSM.add_timed_transition(&stateNB, &stateLS,
-                                      config.power.min_wake_secs ? config.power.min_wake_secs
-                                                                                : default_min_wake_secs * 1000,
-                                      NULL, "Min wake timeout");
-        powerFSM.add_timed_transition(&stateDARK, &stateLS,
-                                      config.power.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;
+        powerFSM.add_timed_transition(&stateNB, &stateLS, getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL, "Min wake timeout");
+        powerFSM.add_timed_transition(&stateDARK, &stateLS, getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs), NULL, "Bluetooth timeout");
     }
 
-#else
-    lowPowerState = &stateDARK;
-    meshSds = UINT32_MAX; // Workaround for now: Don't go into deep sleep on the RAK4631
+    if (config.power.sds_secs != UINT32_MAX)
+        powerFSM.add_timed_transition(lowPowerState, &stateSDS, getConfiguredOrDefaultMs(config.power.sds_secs), NULL, "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/PowerFSMThread.h

@@ -27,10 +27,8 @@ class PowerFSMThread : public OSThread
         if (powerStatus->getHasUSB()) {
             timeLastPowered = millis();
         } else if (config.power.on_battery_shutdown_after_secs > 0 && 
-                   millis() >
-                       timeLastPowered +
-                           (1000 *
-                            config.power.on_battery_shutdown_after_secs)) { // shutdown after 30 minutes unpowered
+            config.power.on_battery_shutdown_after_secs != UINT32_MAX && 
+            millis() > (timeLastPowered + getConfiguredOrDefaultMs(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,8 +1,8 @@
 #include "configuration.h"
 #include "RedirectablePrint.h"
 #include "RTC.h"
+#include "NodeDB.h"
 #include "concurrency/OSThread.h"
-// #include "wifi/WiFiServerAPI.h"
 #include <assert.h>
 #include <sys/time.h>
 #include <time.h>
@@ -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
-    // optionally send chars to TCP also
-    //WiFiServerPort::debugOut(c);
-
+    if (!config.has_lora || config.device.serial_enabled)
         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,24 @@ 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);
-        return 0;
-    };
-    if (len >= (int)printBufLen) {
-        delete[] printBuf;
-        printBufLen *= 2;
-        printBuf = new char[printBufLen];
-        len = vsnprintf(printBuf, printBufLen, format, arg);
+
+    // If the resulting string is longer than sizeof(printBuf)-1 characters, the remaining characters are still counted for the return value
+
+    if (len > sizeof(printBuf) - 1) {
+        len = sizeof(printBuf) - 1;
+        printBuf[sizeof(printBuf) - 2] = '\n';
     }
 
     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 +81,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 +94,6 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
                 print("] ");
             }
         }
-
         r += vprintf(format, arg);
         va_end(arg);
 
@@ -108,3 +103,31 @@ 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/SerialConsole.cpp

@@ -4,6 +4,8 @@
 #include "configuration.h"
 
 #define Port Serial
+// Defaulting to the formerly removed phone_timeout_secs value of 15 minutes
+#define SERIAL_CONNECTION_TIMEOUT (15 * 60) * 1000UL
 
 SerialConsole *console;
 
@@ -18,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;
@@ -28,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 NRF52_SERIES
+#if defined(ARCH_NRF52) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3)
     time_t timeout = millis();
     while (!Port) {
         if ((millis() - timeout) < 5000) {
@@ -41,13 +44,20 @@ 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()
 {
     uint32_t now = millis();
-    return (now - lastContactMsec) < config.power.phone_timeout_secs
-               ? config.power.phone_timeout_secs
-               : default_phone_timeout_secs * 1000UL;
+    return (now - lastContactMsec) < SERIAL_CONNECTION_TIMEOUT;
 }
 
 /**
@@ -56,10 +66,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,6 +24,10 @@ class SerialConsole : public StreamAPI, public RedirectablePrint
         return RedirectablePrint::write(c);
     }
 
+    virtual int32_t runOnce() override;
+
+    void flush();
+
   protected:
 
     /// Check the current underlying physical link to see if the client is currently connected

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;
     }
 
@@ -46,7 +46,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 +101,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,6 +117,45 @@ float AirTime::utilizationTXPercent()
     return (float(sum) / float(MS_IN_HOUR)) * 100;
 }
 
+bool AirTime::isTxAllowedChannelUtil(bool polite)
+{
+    uint8_t percentage = (polite ? polite_channel_util_percent : max_channel_util_percent); 
+    if (channelUtilizationPercent() < percentage) {
+        return true; 
+    } else {
+        LOG_WARN("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 >%d 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({}) {
 }
 
@@ -175,13 +214,13 @@ int32_t AirTime::runOnce()
         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

@@ -4,6 +4,7 @@
 #include "configuration.h"
 #include <Arduino.h>
 #include <functional>
+#include "MeshRadio.h"
 
 /*
   TX_LOG      - Time on air this device has transmitted
@@ -29,6 +30,7 @@
 #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)
 
 
@@ -57,12 +59,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 "configuration.h"
+#include "NodeDB.h"
 
-#ifndef PIN_BUZZER
-
-// Noop methods for boards w/o buzzer
-void playBeep(){};
-void playStartMelody(){};
-void playShutdownMelody(){};
-
-#else
-#ifdef M5STACK
-#include "Speaker.h"
-TONE Tone;
-#else
+#if !defined(ARCH_ESP32) && !defined(ARCH_RP2040) && !defined(ARCH_PORTDUINO)
 #include "Tone.h"
 #endif
 
+#if !defined(ARCH_PORTDUINO)
 extern "C" void delay(uint32_t dwMs);
+#endif
 
 struct ToneDuration {
   int frequency_khz;
@@ -36,45 +28,42 @@ 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) {
+#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.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
+      tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
       // to distinguish the notes, set a minimum time between them.
       delay(1.3 * tone_duration.duration_ms);
     }
   }
+}
+
 
-#ifdef M5STACK
 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() {
-  ToneDuration melody[] = {{NOTE_B3, DURATION_1_4},
-                           {NOTE_B3, DURATION_1_8},
-                           {NOTE_B3, DURATION_1_8}};
+  ToneDuration melody[] = {{NOTE_FS3, DURATION_1_8},
+                           {NOTE_AS3, DURATION_1_8},
+                           {NOTE_CS4, DURATION_1_4}};
   playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 
 void playShutdownMelody() {
-  ToneDuration melody[] = {{NOTE_B3, DURATION_1_4},
-                           {NOTE_G3, DURATION_1_8},
-                           {NOTE_D3, DURATION_1_8}};
+  ToneDuration melody[] = {{NOTE_CS4, DURATION_1_8},
+                           {NOTE_AS3, DURATION_1_8},
+                           {NOTE_FS3, DURATION_1_4}};
   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/InterruptableDelay.cpp

@@ -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/NotifiedWorkerThread.cpp

@@ -1,7 +1,6 @@
 #include "configuration.h"
 #include "NotifiedWorkerThread.h"
 #include "main.h"
-#include <assert.h>
 
 namespace concurrency
 {
@@ -33,11 +32,11 @@ IRAM_ATTR bool NotifiedWorkerThread::notifyCommon(uint32_t v, bool overwrite)
 
         notification = v;
         if (debugNotification)
-            DEBUG_MSG("setting notification %d\n", v);
+            LOG_DEBUG("setting notification %d\n", v);
         return true;
     } else {
         if (debugNotification)
-            DEBUG_MSG("dropping notification %d\n", v);
+            LOG_DEBUG("dropping notification %d\n", v);
         return false;
     }
 }
@@ -66,7 +65,7 @@ bool NotifiedWorkerThread::notifyLater(uint32_t delay, uint32_t v, bool overwrit
     if (didIt) {                   // If we didn't already have something queued, override the delay to be larger
         setIntervalFromNow(delay); // a new version of setInterval relative to the current time
         if (debugNotification)
-            DEBUG_MSG("delaying notification %u\n", delay);
+            LOG_DEBUG("delaying notification %u\n", delay);
     }
 
     return didIt;

src/concurrency/OSThread.cpp

@@ -61,21 +61,31 @@ bool OSThread::shouldRun(unsigned long time)
     bool r = Thread::shouldRun(time);
 
     if (showRun && r)
-        DEBUG_MSG("Thread %s: run\n", ThreadName.c_str());
+        LOG_DEBUG("Thread %s: run\n", ThreadName.c_str());
 
     if (showWaiting && enabled && !r)
-        DEBUG_MSG("Thread %s: wait %lu\n", ThreadName.c_str(), interval);
+        LOG_DEBUG("Thread %s: wait %lu\n", ThreadName.c_str(), interval);
 
     if (showDisabled && !enabled)
-        DEBUG_MSG("Thread %s: disabled\n", ThreadName.c_str());
+        LOG_DEBUG("Thread %s: disabled\n", ThreadName.c_str());
 
     return r;
 }
 
 void OSThread::run()
 {
+#ifdef DEBUG_HEAP
+    auto heap = ESP.getFreeHeap();
+#endif    
     currentThread = this;
     auto newDelay = runOnce();
+#ifdef DEBUG_HEAP
+    auto newHeap = ESP.getFreeHeap();
+    if (newHeap < heap)
+        LOG_DEBUG("------ Thread %s leaked heap %d -> %d (%d) ------\n", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+    if (heap < newHeap)
+        LOG_DEBUG("++++++ Thread %s freed heap %d -> %d (%d) ++++++\n", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+#endif
 
     runned();
 
@@ -85,6 +95,14 @@ void OSThread::run()
     currentThread = NULL;
 }
 
+int32_t OSThread::disable() 
+{
+    enabled = false;
+    setInterval(INT32_MAX);
+    
+    return INT32_MAX;
+}
+
 /**
  * This flag is set **only** when setup() starts, to provide a way for us to check for sloppy static constructor calls.
  * Call assertIsSetup() to force a crash if someone tries to create an instance too early.

src/concurrency/OSThread.h

@@ -53,6 +53,8 @@ class OSThread : public Thread
 
     static void setup();
 
+    int32_t disable();
+
     /**
      * Wait a specified number msecs starting from the current time (rather than the last time we were run)
      */

src/configuration.h

@@ -25,6 +25,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #pragma once
 
 #include <Arduino.h>
+
 #ifdef RV3028_RTC
     #include "Melopero_RV3028.h"
 #endif
@@ -61,78 +62,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /// Convert a preprocessor name into a quoted string and if that string is empty use "unset"
 #define optstr(s) (xstr(s)[0] ? xstr(s) : "unset")
 
-#ifdef PORTDUINO
-
-#define NO_ESP32 // Don't use ESP32 libs (mainly bluetooth)
-
-#elif defined(NRF52_SERIES) // All of the NRF52 targets are configured using variant.h, so this section shouldn't need to be
-// board specific
-
-//
-// Standard definitions for NRF52 targets
-//
-
-#define NO_ESP32 // Don't use ESP32 libs (mainly bluetooth)
-
-// We bind to the GPS using variant.h instead for this platform (Serial1)
-
-#define LED_PIN PIN_LED1 // LED1 on nrf52840-DK
-
-// If the variant filed defines as standard button
-#ifdef PIN_BUTTON1
-#define BUTTON_PIN PIN_BUTTON1
-#endif
-
-#ifdef PIN_BUTTON2
-#define BUTTON_PIN_ALT PIN_BUTTON2
-#endif
-
-#ifdef PIN_BUTTON_TOUCH
-#define BUTTON_PIN_TOUCH PIN_BUTTON_TOUCH
-#endif
-
-#else
-
-//
-// Standard definitions for ESP32 targets
-//
-
-#define HAS_WIFI
-
-#define GPS_SERIAL_NUM 1
-#define GPS_RX_PIN 34
-#ifdef USE_JTAG
-#define GPS_TX_PIN -1
-#else
-#define GPS_TX_PIN 12
-#endif
-
-// -----------------------------------------------------------------------------
-// LoRa SPI
-// -----------------------------------------------------------------------------
-
-// NRF52 boards will define this in variant.h
-#ifndef RF95_SCK
-#define RF95_SCK 5
-#define RF95_MISO 19
-#define RF95_MOSI 27
-#define RF95_NSS 18
-#endif
-
-#endif
-
-#ifndef TTGO_T_ECHO
-#define GPS_UBLOX
-#endif
-
-//
-// Standard definitions for !ESP32 targets
-//
-
-#ifdef NO_ESP32
-// Nop definition for these attributes - not used on NRF52
+// Nop definition for these attributes that are specific to ESP32
+#ifndef EXT_RAM_ATTR
     #define EXT_RAM_ATTR
+#endif
+#ifndef IRAM_ATTR
     #define IRAM_ATTR
+#endif
+#ifndef RTC_DATA_ATTR
     #define RTC_DATA_ATTR
 #endif
 
@@ -157,18 +94,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Define this if you know you have that controller or your "SSD1306" misbehaves.
 //#define USE_SH1106
 
-// Flip the screen upside down by default as it makes more sense on T-BEAM
-// devices. Comment this out to not rotate screen 180 degrees.
-#define SCREEN_FLIP_VERTICALLY
-
 // Define if screen should be mirrored left to right
 // #define SCREEN_MIRROR
 
 // The m5stack I2C Keyboard (also RAK14004)
 #define CARDKB_ADDR 0x5F
 
-// The older M5 Faces I2C Keyboard
-#define FACESKB_ADDR 0x88
+// -----------------------------------------------------------------------------
+// SENSOR
+// -----------------------------------------------------------------------------
+#define BME_ADDR 0x76
+#define BME_ADDR_ALTERNATE 0x77
+#define MCP9808_ADDR 0x18
+#define INA_ADDR 0x40
+#define INA_ADDR_ALTERNATE 0x41
+#define QMC6310_ADDR 0x1C
+#define QMI8658_ADDR 0x6B
+#define QMC5883L_ADDR 0x1E
+#define SHTC3_ADDR 0x70
+#define LPS22HB_ADDR 0x5C
+#define LPS22HB_ADDR_ALT 0x5D
+#define SHT31_ADDR 0x44
+
+// -----------------------------------------------------------------------------
+// Security
+// -----------------------------------------------------------------------------
+
+#define ATECC608B_ADDR 0x35
 
 // -----------------------------------------------------------------------------
 // GPS
@@ -180,109 +132,52 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define GPS_THREAD_INTERVAL 100
 #endif
 
-#if defined(TBEAM_V10)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_TBEAM
-
-#elif defined(TBEAM_V07)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_TBEAM0p7
-
-#elif defined(DIY_V1)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_DIY_V1
-
-#elif defined(RAK_11200)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_RAK11200
-
-#elif defined(ARDUINO_HELTEC_WIFI_LORA_32_V2)
-
-#ifdef HELTEC_V2_0
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_HELTEC_V2_0
-
-#endif
-
-#ifdef HELTEC_V2_1
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_HELTEC_V2_1
-
-#endif
-
-#elif defined(ARDUINO_HELTEC_WIFI_LORA_32)
-
-#define HW_VENDOR HardwareModel_HELTEC_V1
-
-#elif defined(TLORA_V1)
-
-#define HW_VENDOR HardwareModel_TLORA_V1
-
-#elif defined(TLORA_V2)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_TLORA_V2
-
-#elif defined(TLORA_V1_3)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_TLORA_V1_1p3
-
-#elif defined(TLORA_V2_1_16)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_TLORA_V2_1_1p6
-
-#elif defined(GENIEBLOCKS)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_GENIEBLOCKS
-
-#elif defined(PRIVATE_HW)
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_PRIVATE_HW
-
-#endif
-
-#ifdef ARDUINO_NRF52840_PCA10056
-
-// This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR HardwareModel_NRF52840DK
-
-// This board uses 0 to be mean LED on
-#undef LED_INVERTED
-#define LED_INVERTED 1
-
-#elif defined(ARDUINO_NRF52840_PPR)
-
-#define HW_VENDOR HardwareModel_PPR
-
-#elif defined(RAK4630)
-
-#define HW_VENDOR HardwareModel_RAK4631
-
-#elif defined(TTGO_T_ECHO)
-
-#define HW_VENDOR HardwareModel_T_ECHO
-
-#elif defined(NANO_G1)
-
-#define HW_VENDOR HardwareModel_NANO_G1
-
-#elif defined(NORDIC_PCA10059)
-
-#define HW_VENDOR HardwareModel_NRF52840_PCA10059
-
-#elif defined(M5STACK)
-
-#define HW_VENDOR HardwareModel_M5STACK
-
-#elif NRF52_SERIES
-
-#define HW_VENDOR HardwareModel_NRF52_UNKNOWN
-
-#elif PORTDUINO
-
-#define HW_VENDOR HardwareModel_PORTDUINO
-
-#endif
-
+/* Step #1: offer chance for variant-specific defines */
 #include "variant.h"
+
+/* Step #2: follow with defines common to the architecture; 
+   also enable HAS_ option not specifically disabled by variant.h */
+#include "architecture.h"
+
+/* Step #3: mop up with disabled values for HAS_ options not handled by the above two */
+
+#ifndef HAS_WIFI
+    #define HAS_WIFI 0
+#endif
+#ifndef HAS_ETHERNET
+    #define HAS_ETHERNET 0
+#endif
+#ifndef HAS_SCREEN
+    #define HAS_SCREEN 0
+#endif
+#ifndef HAS_WIRE
+    #define HAS_WIRE 0
+#endif
+#ifndef HAS_GPS
+    #define HAS_GPS 0
+#endif
+#ifndef HAS_BUTTON
+    #define HAS_BUTTON 0
+#endif
+#ifndef HAS_TELEMETRY
+    #define HAS_TELEMETRY 0
+#endif
+#ifndef HAS_RADIO
+    #define HAS_RADIO 0
+#endif
+#ifndef HAS_RTC
+    #define HAS_RTC 0
+#endif
+#ifndef HAS_CPU_SHUTDOWN
+    #define HAS_CPU_SHUTDOWN 0
+#endif
+#ifndef HAS_BLUETOOTH
+    #define HAS_BLUETOOTH 0
+#endif
+
 #include "RF95Configuration.h"
 #include "DebugConfiguration.h"
+
+#ifndef HW_VENDOR
+    #error HW_VENDOR must be defined
+#endif

src/cubecell/FS.h

@@ -1 +0,0 @@
-// Placeholder FIXME

src/debug/axpDebug.h

@@ -1,19 +0,0 @@
-#if 0
-// Turn off for now
-uint32_t axpDebugRead()
-{
-  axp.debugCharging();
-  DEBUG_MSG("vbus current %f\n", axp.getVbusCurrent());
-  DEBUG_MSG("charge current %f\n", axp.getBattChargeCurrent());
-  DEBUG_MSG("bat voltage %f\n", axp.getBattVoltage());
-  DEBUG_MSG("batt pct %d\n", axp.getBattPercentage());
-  DEBUG_MSG("is battery connected %d\n", axp.isBatteryConnect());
-  DEBUG_MSG("is USB connected %d\n", axp.isVBUSPlug());
-  DEBUG_MSG("is charging %d\n", axp.isChargeing());
-
-  return 30 * 1000;
-}
-
-Periodic axpDebugOutput(axpDebugRead);
-axpDebugOutput.setup();
-#endif

src/debug/i2cScan.h

@@ -1,119 +0,0 @@
-#include "../configuration.h"
-#include "../main.h"
-#include <Wire.h>
-
-#ifndef NO_WIRE
-uint8_t oled_probe(byte addr)
-{
-    uint8_t r = 0;
-    uint8_t r_prev = 0;
-    uint8_t c = 0;
-    uint8_t o_probe = 0;
-    do {
-        r_prev = r;
-        Wire.beginTransmission(addr);
-        Wire.write(0x00);
-        Wire.endTransmission();
-        Wire.requestFrom((int)addr, 1);
-        if (Wire.available()) {
-            r = Wire.read();
-        }
-        r &= 0x0f;
-
-        if (r == 0x08 || r == 0x00) {
-            o_probe = 2; // SH1106
-        } else if ( r == 0x03 || r == 0x06 || r == 0x07) {
-            o_probe = 1; // SSD1306
-        }
-        c++;
-    } while ((r != r_prev) && (c < 4));
-    DEBUG_MSG("0x%x subtype probed in %i tries \n", r, c);
-    return o_probe;
-}
-
-void scanI2Cdevice(void)
-{
-    byte err, addr;
-    uint8_t r = 0x00;
-    int nDevices = 0;
-    for (addr = 1; addr < 127; addr++) {
-        Wire.beginTransmission(addr);
-        err = Wire.endTransmission();
-        if (err == 0) {
-            DEBUG_MSG("I2C device found at address 0x%x\n", addr);
-
-            nDevices++;
-
-            if (addr == SSD1306_ADDRESS) {
-                screen_found = addr;
-                screen_model = oled_probe(addr);
-                if (screen_model == 1){
-                    DEBUG_MSG("ssd1306 display found\n");
-                } else if (screen_model == 2){
-                    DEBUG_MSG("sh1106 display found\n");
-                } else {
-                    DEBUG_MSG("unknown display found\n");
-                }
-            }
-#ifdef RV3028_RTC
-            if (addr == RV3028_RTC){
-                rtc_found = addr;
-                DEBUG_MSG("RV3028 RTC found\n");
-                Melopero_RV3028 rtc;
-                rtc.initI2C();
-                rtc.writeToRegister(0x35,0x07); // no Clkout
-                rtc.writeToRegister(0x37,0xB4);
-            }
-#endif
-#ifdef PCF8563_RTC
-            if (addr == PCF8563_RTC){
-                rtc_found = addr;
-                DEBUG_MSG("PCF8563 RTC found\n");
-            }
-#endif
-            if (addr == CARDKB_ADDR) {
-                cardkb_found = addr;
-                // Do we have the RAK14006 instead?
-                Wire.beginTransmission(addr);
-                Wire.write(0x04); // SENSOR_GET_VERSION
-                Wire.endTransmission();
-                delay(20);
-                Wire.requestFrom((int)addr, 1);
-                if (Wire.available()) {
-                    r = Wire.read();
-                }
-                if (r == 0x02) { // KEYPAD_VERSION
-                    DEBUG_MSG("RAK14004 found\n");
-                    kb_model = 0x02;
-                } else {
-                    DEBUG_MSG("m5 cardKB found\n");
-                    kb_model = 0x00;
-                }
-            }
-            if (addr == FACESKB_ADDR) {
-                faceskb_found = addr;
-                DEBUG_MSG("m5 Faces found\n");
-            }
-            if (addr == ST7567_ADDRESS) {
-                screen_found = addr;
-                DEBUG_MSG("st7567 display found\n");
-            }
-#ifdef AXP192_SLAVE_ADDRESS
-            if (addr == AXP192_SLAVE_ADDRESS) {
-                axp192_found = true;
-                DEBUG_MSG("axp192 PMU found\n");
-            }
-#endif
-        } else if (err == 4) {
-            DEBUG_MSG("Unknow error at address 0x%x\n", addr);
-        }
-    }
-
-    if (nDevices == 0)
-        DEBUG_MSG("No I2C devices found\n");
-    else
-        DEBUG_MSG("%i I2C devices found\n",nDevices);
-}
-#else
-void scanI2Cdevice(void) {}
-#endif

src/detect/axpDebug.h

@@ -0,0 +1,19 @@
+#if 0
+// Turn off for now
+uint32_t axpDebugRead()
+{
+  axp.debugCharging();
+  LOG_DEBUG("vbus current %f\n", axp.getVbusCurrent());
+  LOG_DEBUG("charge current %f\n", axp.getBattChargeCurrent());
+  LOG_DEBUG("bat voltage %f\n", axp.getBattVoltage());
+  LOG_DEBUG("batt pct %d\n", axp.getBattPercentage());
+  LOG_DEBUG("is battery connected %d\n", axp.isBatteryConnect());
+  LOG_DEBUG("is USB connected %d\n", axp.isVBUSPlug());
+  LOG_DEBUG("is charging %d\n", axp.isChargeing());
+
+  return 30 * 1000;
+}
+
+Periodic axpDebugOutput(axpDebugRead);
+axpDebugOutput.setup();
+#endif

src/detect/einkScan.h

@@ -52,9 +52,9 @@ void scanEInkDevice(void)
     d_writeCommand(0x20);
     eink_found = (d_waitWhileBusy(150) > 0) ? true : false;
     if(eink_found)
-       DEBUG_MSG("EInk display found\n");
+      LOG_DEBUG("EInk display found\n");
     else
-       DEBUG_MSG("EInk display not found\n");
+      LOG_DEBUG("EInk display not found\n");
     SPI1.end();
 }
 #endif

src/detect/i2cScan.h

@@ -0,0 +1,232 @@
+#include "../configuration.h"
+#include "../main.h"
+#include <Wire.h>
+#include "mesh/generated/telemetry.pb.h"
+
+// AXP192 and AXP2101 have the same device address, we just need to identify it in Power.cpp
+#ifndef XPOWERS_AXP192_AXP2101_ADDRESS
+#define XPOWERS_AXP192_AXP2101_ADDRESS      0x34
+#endif
+
+#if HAS_WIRE
+
+void printATECCInfo()
+{
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+    atecc.readConfigZone(false);
+
+    LOG_DEBUG("ATECC608B Serial Number: ");
+    for (int i = 0 ; i < 9 ; i++) {
+        LOG_DEBUG("%02x",atecc.serialNumber[i]);
+    }
+
+    LOG_DEBUG(", Rev Number: ");
+    for (int i = 0 ; i < 4 ; i++) {
+        LOG_DEBUG("%02x",atecc.revisionNumber[i]);
+    }
+    LOG_DEBUG("\n");
+
+    LOG_DEBUG("ATECC608B Config %s",atecc.configLockStatus ? "Locked" : "Unlocked");
+    LOG_DEBUG(", Data %s",atecc.dataOTPLockStatus ? "Locked" : "Unlocked");
+    LOG_DEBUG(", Slot 0 %s\n",atecc.slot0LockStatus ? "Locked" : "Unlocked");
+
+    if (atecc.configLockStatus && atecc.dataOTPLockStatus && atecc.slot0LockStatus) {
+        if (atecc.generatePublicKey() == false) {
+            LOG_DEBUG("ATECC608B Error generating public key\n");
+        } else {
+            LOG_DEBUG("ATECC608B Public Key: ");
+            for (int i = 0 ; i < 64 ; i++) {
+                LOG_DEBUG("%02x",atecc.publicKey64Bytes[i]);
+            }
+            LOG_DEBUG("\n");
+        }
+    }
+#endif
+}
+
+uint16_t getRegisterValue(uint8_t address, uint8_t reg, uint8_t length) {
+    uint16_t value = 0x00;
+    Wire.beginTransmission(address);
+    Wire.write(reg);
+    Wire.endTransmission();
+    delay(20);
+    Wire.requestFrom(address, length);
+    LOG_DEBUG("Wire.available() = %d\n", Wire.available());
+    if (Wire.available() == 2) {
+        // Read MSB, then LSB
+        value = (uint16_t)Wire.read() << 8;  
+        value |= Wire.read();
+    } else if (Wire.available()) {
+        value = Wire.read();
+    }
+    return value;
+}
+
+uint8_t oled_probe(byte addr)
+{
+    uint8_t r = 0;
+    uint8_t r_prev = 0;
+    uint8_t c = 0;
+    uint8_t o_probe = 0;
+    do {
+        r_prev = r;
+        Wire.beginTransmission(addr);
+        Wire.write(0x00);
+        Wire.endTransmission();
+        Wire.requestFrom((int)addr, 1);
+        if (Wire.available()) {
+            r = Wire.read();
+        }
+        r &= 0x0f;
+
+        if (r == 0x08 || r == 0x00) {
+            o_probe = 2; // SH1106
+        } else if ( r == 0x03 || r == 0x04 || r == 0x06 || r == 0x07) {
+            o_probe = 1; // SSD1306
+        }
+        c++;
+    } while ((r != r_prev) && (c < 4));
+    LOG_DEBUG("0x%x subtype probed in %i tries \n", r, c);
+    return o_probe;
+}
+
+void scanI2Cdevice()
+{
+    byte err, addr;
+    uint16_t registerValue = 0x00;
+    int nDevices = 0;
+    for (addr = 1; addr < 127; addr++) {
+        Wire.beginTransmission(addr);
+        err = Wire.endTransmission();
+        if (err == 0) {
+            LOG_DEBUG("I2C device found at address 0x%x\n", addr);
+
+            nDevices++;
+
+            if (addr == SSD1306_ADDRESS) {
+                screen_found = addr;
+                screen_model = oled_probe(addr);
+                if (screen_model == 1) {
+                    LOG_INFO("ssd1306 display found\n");
+                } else if (screen_model == 2) {
+                    LOG_INFO("sh1106 display found\n");
+                } else {
+                    LOG_INFO("unknown display found\n");
+                }
+            }
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+            if (addr == ATECC608B_ADDR) {
+                keystore_found = addr;
+                if (atecc.begin(keystore_found) == true) {
+                    LOG_INFO("ATECC608B initialized\n");
+                } else {
+                    LOG_WARN("ATECC608B initialization failed\n");
+                }
+                printATECCInfo();
+            }
+#endif
+#ifdef RV3028_RTC
+            if (addr == RV3028_RTC){
+                rtc_found = addr;
+                LOG_INFO("RV3028 RTC found\n");
+                Melopero_RV3028 rtc;
+                rtc.initI2C();
+                rtc.writeToRegister(0x35,0x07); // no Clkout
+                rtc.writeToRegister(0x37,0xB4);
+            }
+#endif
+#ifdef PCF8563_RTC
+            if (addr == PCF8563_RTC){
+                rtc_found = addr;
+                LOG_INFO("PCF8563 RTC found\n");
+            }
+#endif
+            if (addr == CARDKB_ADDR) {
+                cardkb_found = addr;
+                // Do we have the RAK14006 instead?
+                registerValue = getRegisterValue(addr, 0x04, 1);
+                if (registerValue == 0x02) { // KEYPAD_VERSION
+                    LOG_INFO("RAK14004 found\n");
+                    kb_model = 0x02;
+                } else {
+                    LOG_INFO("m5 cardKB found\n");
+                    kb_model = 0x00;
+                }
+            }
+            if (addr == ST7567_ADDRESS) {
+                screen_found = addr;
+                LOG_INFO("st7567 display found\n");
+            }
+#ifdef HAS_PMU
+            if (addr == XPOWERS_AXP192_AXP2101_ADDRESS) {
+                pmu_found = true;
+                LOG_INFO("axp192/axp2101 PMU found\n");
+            }
+#endif
+            if (addr == BME_ADDR || addr == BME_ADDR_ALTERNATE) {
+                registerValue = getRegisterValue(addr, 0xD0, 1); // GET_ID
+                if (registerValue == 0x61) {
+                    LOG_INFO("BME-680 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_BME680] = addr;
+                } else if (registerValue == 0x60) {
+                    LOG_INFO("BME-280 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_BME280] = addr;
+                } else {
+                    LOG_INFO("BMP-280 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_BMP280] = addr;
+                }
+            }
+            if (addr == INA_ADDR || addr == INA_ADDR_ALTERNATE) {
+                registerValue = getRegisterValue(addr, 0xFE, 2);
+                LOG_DEBUG("Register MFG_UID: 0x%x\n", registerValue);
+                if (registerValue == 0x5449) {
+                    LOG_INFO("INA260 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_INA260] = addr;
+                } else { // Assume INA219 if INA260 ID is not found
+                    LOG_INFO("INA219 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_INA219] = addr;
+                }
+            }
+            if (addr == MCP9808_ADDR) {
+                nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808] = addr;
+                LOG_INFO("MCP9808 sensor found\n");
+            }
+            if (addr == SHT31_ADDR) {
+                LOG_INFO("SHT31 sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_SHT31] = addr;
+            }
+            if (addr == SHTC3_ADDR) {
+                LOG_INFO("SHTC3 sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_SHTC3] = addr;
+            }
+            if (addr == LPS22HB_ADDR || addr == LPS22HB_ADDR_ALT) {
+                LOG_INFO("LPS22HB sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_LPS22] = addr;
+            }
+
+            // High rate sensors, will be processed internally
+            if (addr == QMC6310_ADDR) {
+                LOG_INFO("QMC6310 Highrate 3-Axis magnetic sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_QMC6310] = addr;
+            }
+            if (addr == QMI8658_ADDR) {
+                LOG_INFO("QMI8658 Highrate 6-Axis inertial measurement sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_QMI8658] = addr;
+            }
+            if (addr == QMC5883L_ADDR) {
+                LOG_INFO("QMC5883L Highrate 3-Axis magnetic sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_QMC5883L] = addr;
+            }
+        } else if (err == 4) {
+            LOG_ERROR("Unknow error at address 0x%x\n", addr);
+        }
+    }
+
+    if (nDevices == 0)
+        LOG_INFO("No I2C devices found\n");
+    else
+        LOG_INFO("%i I2C devices found\n",nDevices);
+}
+#else
+void scanI2Cdevice() {}
+#endif

src/error.h

@@ -8,4 +8,4 @@
 #define RECORD_CRITICALERROR(code) recordCriticalError(code, __LINE__, __FILE__)
 
 /// Record an error that should be reported via analytics
-void recordCriticalError(CriticalErrorCode code = CriticalErrorCode_Unspecified, uint32_t address = 0, const char *filename = NULL);
+void recordCriticalError(CriticalErrorCode code = CriticalErrorCode_UNSPECIFIED, uint32_t address = 0, const char *filename = NULL);

src/esp32/BluetoothSoftwareUpdate.cpp

@@ -1,160 +0,0 @@
-#ifndef USE_NEW_ESP32_BLUETOOTH
-
-#include <Arduino.h>
-
-#include "../concurrency/LockGuard.h"
-#include "../graphics/Screen.h"
-#include "../main.h"
-#include "BluetoothSoftwareUpdate.h"
-#include "NodeDB.h"
-#include "PowerFSM.h"
-#include "RadioLibInterface.h"
-#include "configuration.h"
-#include "nimble/BluetoothUtil.h"
-
-#include <CRC32.h>
-#include <Update.h>
-
-int16_t updateResultHandle = -1;
-
-static CRC32 crc;
-
-static uint32_t updateExpectedSize, updateActualSize;
-static uint8_t update_result;
-static uint8_t update_region;
-
-static concurrency::Lock *updateLock;
-
-/// Handle writes & reads to total size
-int update_size_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
-{
-    concurrency::LockGuard g(updateLock);
-
-    // Check if there is enough to OTA Update
-    chr_readwrite32le(&updateExpectedSize, ctxt);
-
-    if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR && updateExpectedSize != 0) {
-        updateActualSize = 0;
-        crc.reset();
-        if (Update.isRunning())
-            Update.abort();
-        bool canBegin = Update.begin(updateExpectedSize, update_region);
-        DEBUG_MSG("Setting region %d update size %u, result %d\n", update_region, updateExpectedSize, canBegin);
-        if (!canBegin) {
-            // Indicate failure by forcing the size to 0 (client will read it back)
-            updateExpectedSize = 0;
-        } else {
-            // This totally breaks abstraction to up up into the app layer for this, but quick hack to make sure we only
-            // talk to one service during the sw update.
-            // DEBUG_MSG("FIXME, crufty shutdown of mesh bluetooth for sw update.");
-            // void stopMeshBluetoothService();
-            // stopMeshBluetoothService();
-
-            screen->startFirmwareUpdateScreen();
-            if (RadioLibInterface::instance)
-                RadioLibInterface::instance->disable(); // FIXME, nasty hack - the RF95 ISR/SPI code on ESP32 can fail while we
-                                                        // are writing flash - shut the radio off during updates
-        }
-    }
-
-    return 0;
-}
-
-#define MAX_BLOCKSIZE_FOR_BT 512
-
-/// Handle writes to data
-int update_data_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
-{
-    concurrency::LockGuard g(updateLock);
-
-    static uint8_t
-        data[MAX_BLOCKSIZE_FOR_BT]; // we temporarily copy here because I'm worried that a fast sender might be able overwrite srcbuf
-
-    uint16_t len = 0;
-
-    auto rc = ble_hs_mbuf_to_flat(ctxt->om, data, sizeof(data), &len);
-    assert(rc == 0);
-
-    // DEBUG_MSG("Writing %u\n", len);
-    crc.update(data, len);
-    Update.write(data, len);
-    updateActualSize += len;
-    powerFSM.trigger(EVENT_FIRMWARE_UPDATE);
-
-    return 0;
-}
-
-/// Handle writes to crc32
-int update_crc32_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
-{
-    concurrency::LockGuard g(updateLock);
-    uint32_t expectedCRC = 0;
-    chr_readwrite32le(&expectedCRC, ctxt);
-
-    uint32_t actualCRC = crc.finalize();
-    DEBUG_MSG("expected CRC %u\n", expectedCRC);
-
-    uint8_t result = 0xff;
-
-    if (updateActualSize != updateExpectedSize) {
-        DEBUG_MSG("Expected %u bytes, but received %u bytes!\n", updateExpectedSize, updateActualSize);
-        result = 0xe1;                   // FIXME, use real error codes
-    } else if (actualCRC != expectedCRC) // Check the CRC before asking the update to happen.
-    {
-        DEBUG_MSG("Invalid CRC! expected=%u, actual=%u\n", expectedCRC, actualCRC);
-        result = 0xe0; // FIXME, use real error codes
-    } else {
-        if (Update.end()) {
-            if (update_region == U_SPIFFS) {
-                DEBUG_MSG("Filesystem updated!\n");
-                nodeDB.saveToDisk(); // Since we just wiped the filesystem, we need to save our current state
-            } else {
-                DEBUG_MSG("Appload updated, rebooting in 5 seconds!\n");
-                rebootAtMsec = millis() + 5000;
-            }
-        } else {
-            DEBUG_MSG("Error Occurred. Error #: %d\n", Update.getError());
-        }
-        result = Update.getError();
-    }
-
-    if (RadioLibInterface::instance)
-        RadioLibInterface::instance->startReceive(); // Resume radio
-
-    assert(updateResultHandle >= 0);
-    update_result = result;
-    DEBUG_MSG("BLE notify update result\n");
-    auto res = ble_gattc_notify(curConnectionHandle, updateResultHandle);
-    assert(res == 0);
-
-    return 0;
-}
-
-int update_result_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
-{
-    return chr_readwrite8(&update_result, sizeof(update_result), ctxt);
-}
-
-int update_region_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
-{
-    return chr_readwrite8(&update_region, sizeof(update_region), ctxt);
-}
-
-/*
-See bluetooth-api.md
-
- */
-void reinitUpdateService()
-{
-    if (!updateLock)
-        updateLock = new concurrency::Lock();
-
-    auto res = ble_gatts_count_cfg(gatt_update_svcs); // assigns handles?  see docstring for note about clearing the handle list
-                                                      // before calling SLEEP SUPPORT
-    assert(res == 0);
-
-    res = ble_gatts_add_svcs(gatt_update_svcs);
-    assert(res == 0);
-}
-
-#endif //#ifndef USE_NEW_ESP32_BLUETOOTH

src/esp32/BluetoothSoftwareUpdate.h

@@ -1,29 +0,0 @@
-#ifndef USE_NEW_ESP32_BLUETOOTH
-
-#pragma once
-
-#include "nimble/NimbleDefs.h"
-
-void reinitUpdateService();
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int update_size_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg);
-int update_data_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg);
-int update_result_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg);
-int update_crc32_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg);
-int update_region_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg);
-
-extern const struct ble_gatt_svc_def gatt_update_svcs[];
-
-extern const ble_uuid128_t update_result_uuid, update_region_uuid;
-
-extern int16_t updateResultHandle;
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif //#ifndef USE_NEW_ESP32_BLUETOOTH

src/esp32/ESP32Bluetooth.cpp

@@ -1,259 +0,0 @@
-#ifdef USE_NEW_ESP32_BLUETOOTH
-
-#include "configuration.h"
-#include "ESP32Bluetooth.h"
-#include "BluetoothCommon.h"
-#include "PowerFSM.h"
-#include "sleep.h"
-#include "main.h"
-#include "mesh/PhoneAPI.h"
-#include "mesh/mesh-pb-constants.h"
-#include <NimBLEDevice.h>
-
-//static BLEService meshBleService = BLEService(BLEUuid(MESH_SERVICE_UUID_16));
-//static BLECharacteristic fromNum = BLECharacteristic(BLEUuid(FROMNUM_UUID_16));
-//static BLECharacteristic fromRadio = BLECharacteristic(BLEUuid(FROMRADIO_UUID_16));
-//static BLECharacteristic toRadio = BLECharacteristic(BLEUuid(TORADIO_UUID_16));
-
-//static BLEDis bledis; // DIS (Device Information Service) helper class instance
-//static BLEBas blebas; // BAS (Battery Service) helper class instance
-//static BLEDfu bledfu; // DFU software update helper service
-
-// This scratch buffer is used for various bluetooth reads/writes - but it is safe because only one bt operation can be in
-// proccess at once
-// static uint8_t trBytes[_max(_max(_max(_max(ToRadio_size, RadioConfig_size), User_size), MyNodeInfo_size), FromRadio_size)];
-static uint8_t fromRadioBytes[FromRadio_size];
-
-NimBLECharacteristic *FromNumCharacteristic;
-NimBLEServer *bleServer;
-
-static bool passkeyShowing;
-static uint32_t doublepressed;
-
-/**
- * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
- */
-void BluetoothPhoneAPI::onNowHasData(uint32_t fromRadioNum)
-{
-    PhoneAPI::onNowHasData(fromRadioNum);
-
-    DEBUG_MSG("BLE notify fromNum\n");
-    //fromNum.notify32(fromRadioNum);
-    
-    uint8_t val[4];
-    put_le32(val, fromRadioNum);
-
-    std::string fromNumByteString(&val[0], &val[0] + sizeof(val));
-
-    FromNumCharacteristic->setValue(fromNumByteString);
-    FromNumCharacteristic->notify();
-}
-
-/// Check the current underlying physical link to see if the client is currently connected
-bool BluetoothPhoneAPI::checkIsConnected() {
-    if (bleServer && bleServer->getConnectedCount() > 0) {
-        return true;
-    }
-    return false;
-}
-
-PhoneAPI *bluetoothPhoneAPI;
-
-class ESP32BluetoothToRadioCallback : public NimBLECharacteristicCallbacks {
-    virtual void onWrite(NimBLECharacteristic *pCharacteristic) {
-        DEBUG_MSG("To Radio onwrite\n");
-        auto valueString = pCharacteristic->getValue();
-        
-        bluetoothPhoneAPI->handleToRadio(reinterpret_cast<const uint8_t*>(&valueString[0]), pCharacteristic->getDataLength());
-    }
-};
-
-class ESP32BluetoothFromRadioCallback : public NimBLECharacteristicCallbacks {
-    virtual void onRead(NimBLECharacteristic *pCharacteristic) {
-        DEBUG_MSG("From Radio onread\n");
-        size_t numBytes = bluetoothPhoneAPI->getFromRadio(fromRadioBytes);
-
-        std::string fromRadioByteString(fromRadioBytes, fromRadioBytes + numBytes);
-
-        pCharacteristic->setValue(fromRadioByteString);
-    }
-};
-
-class ESP32BluetoothServerCallback : public NimBLEServerCallbacks {
-    virtual uint32_t onPassKeyRequest() {
-
-        uint32_t passkey = 0;
-
-        if (doublepressed > 0 && (doublepressed + (30 * 1000)) > millis()) {
-            DEBUG_MSG("User has overridden passkey\n");
-            passkey = defaultBLEPin;
-        } else {
-            DEBUG_MSG("Using random passkey\n");
-            passkey = random(
-                100000, 999999); // This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
-        }
-        DEBUG_MSG("*** Enter passkey %d on the peer side ***\n", passkey);
-
-        powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
-        screen->startBluetoothPinScreen(passkey);
-        passkeyShowing = true;
-
-        return passkey;
-    }
-
-    virtual void onAuthenticationComplete(ble_gap_conn_desc *desc) {
-        DEBUG_MSG("BLE authentication complete\n");
-
-        if (passkeyShowing) {
-            passkeyShowing = false;
-            screen->stopBluetoothPinScreen();
-        }
-    }
-};
-
-
-static ESP32BluetoothToRadioCallback *toRadioCallbacks;
-static ESP32BluetoothFromRadioCallback *fromRadioCallbacks;
-
-void ESP32Bluetooth::shutdown()
-{
-    // Shutdown bluetooth for minimum power draw
-    DEBUG_MSG("Disable bluetooth\n");
-    //Bluefruit.Advertising.stop();
-}
-
-void ESP32Bluetooth::setup()
-{
-    // Initialise the Bluefruit module
-    DEBUG_MSG("Initialise the ESP32 bluetooth module\n");
-    //Bluefruit.autoConnLed(false);
-    //Bluefruit.begin();
-
-    // Set the advertised device name (keep it short!)
-    //Bluefruit.setName(getDeviceName());
-
-    // Set the connect/disconnect callback handlers
-    //Bluefruit.Periph.setConnectCallback(connect_callback);
-    //Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
-
-    // Configure and Start the Device Information Service
-    DEBUG_MSG("Configuring the Device Information Service\n");
-    // FIXME, we should set a mfg string based on our HW_VENDOR enum
-    // bledis.setManufacturer(HW_VENDOR);
-    //bledis.setModel(optstr(HW_VERSION));
-    //bledis.setFirmwareRev(optstr(APP_VERSION));
-    //bledis.begin();
-
-    // Start the BLE Battery Service and set it to 100%
-    //DEBUG_MSG("Configuring the Battery Service\n");
-    //blebas.begin();
-    //blebas.write(0); // Unknown battery level for now
-
-    //bledfu.begin(); // Install the DFU helper
-
-    // Setup the Heart Rate Monitor service using
-    // BLEService and BLECharacteristic classes
-    DEBUG_MSG("Configuring the Mesh bluetooth service\n");
-    //setupMeshService();
-
-    // Supposedly debugging works with soft device if you disable advertising
-    //if (isSoftDeviceAllowed) {
-        // Setup the advertising packet(s)
-    //    DEBUG_MSG("Setting up the advertising payload(s)\n");
-    //    startAdv();
-
-    //    DEBUG_MSG("Advertising\n");
-    //}
-
-    //NimBLEDevice::deleteAllBonds();
-
-    NimBLEDevice::init(getDeviceName());
-    NimBLEDevice::setPower(ESP_PWR_LVL_P9);
-
-    NimBLEDevice::setSecurityAuth(true, true, true);
-    NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
-    bleServer = NimBLEDevice::createServer();
-    
-    ESP32BluetoothServerCallback *serverCallbacks = new ESP32BluetoothServerCallback();
-    bleServer->setCallbacks(serverCallbacks);
-
-    NimBLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
-    //NimBLECharacteristic *pNonSecureCharacteristic = bleService->createCharacteristic("1234", NIMBLE_PROPERTY::READ );
-    //NimBLECharacteristic *pSecureCharacteristic = bleService->createCharacteristic("1235", NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::READ_AUTHEN);
-
-    //define the characteristics that the app is looking for
-    NimBLECharacteristic *ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_AUTHEN | NIMBLE_PROPERTY::WRITE_ENC);
-    NimBLECharacteristic *FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
-    FromNumCharacteristic = bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
-    
-    bluetoothPhoneAPI = new BluetoothPhoneAPI();
-
-    toRadioCallbacks = new ESP32BluetoothToRadioCallback();
-    ToRadioCharacteristic->setCallbacks(toRadioCallbacks);
-
-    fromRadioCallbacks = new ESP32BluetoothFromRadioCallback();
-    FromRadioCharacteristic->setCallbacks(fromRadioCallbacks);
-
-    //uint8_t val[4];
-    //uint32_t zero = 0;
-    //put_le32(val, zero);
-    //std::string fromNumByteString(&val[0], &val[0] + sizeof(val));
-    //FromNumCharacteristic->setValue(fromNumByteString);
-
-    bleService->start();
-    //pNonSecureCharacteristic->setValue("Hello Non Secure BLE");
-    //pSecureCharacteristic->setValue("Hello Secure BLE");
-
-    //FromRadioCharacteristic->setValue("FromRadioString");
-    //ToRadioCharacteristic->setCallbacks()
-
-    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
-    pAdvertising->start();
-
-}
-
-
-/// Given a level between 0-100, update the BLE attribute
-void updateBatteryLevel(uint8_t level)
-{
-    //blebas.write(level);
-}
-
-void ESP32Bluetooth::clearBonds()
-{
-    DEBUG_MSG("Clearing bluetooth bonds!\n");
-    //bond_print_list(BLE_GAP_ROLE_PERIPH);
-    //bond_print_list(BLE_GAP_ROLE_CENTRAL);
-
-    //Bluefruit.Periph.clearBonds();
-    //Bluefruit.Central.clearBonds();
-    
-}
-
-void clearNVS() {
-    NimBLEDevice::deleteAllBonds();
-    ESP.restart();
-}
-
-void disablePin() {
-    DEBUG_MSG("User Override, disabling bluetooth pin requirement\n");
-    // keep track of when it was pressed, so we know it was within X seconds
-
-    // Flash the LED
-    setLed(true);
-    delay(100);
-    setLed(false);
-    delay(100);
-    setLed(true);
-    delay(100);
-    setLed(false);
-    delay(100);
-    setLed(true);
-    delay(100);
-    setLed(false);
-
-    doublepressed = millis();
-}
-
-#endif

src/esp32/ESP32Bluetooth.h

@@ -1,33 +0,0 @@
-#ifdef USE_NEW_ESP32_BLUETOOTH
-
-#pragma once
-
-extern uint16_t fromNumValHandle;
-
-class BluetoothPhoneAPI : public PhoneAPI
-{
-protected: 
-    /**
-     * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
-     */
-    virtual void onNowHasData(uint32_t fromRadioNum) override;
-
-    /// Check the current underlying physical link to see if the client is currently connected
-    virtual bool checkIsConnected() override;
-};
-
-extern PhoneAPI *bluetoothPhoneAPI;
-
-class ESP32Bluetooth
-{
-  public:
-    void setup();
-    void shutdown();
-    void clearBonds();
-};
-
-void setBluetoothEnable(bool on);
-void clearNVS();
-void disablePin();
-
-#endif

src/esp32/NimbleSoftwareUpdate.c

@@ -1,73 +0,0 @@
-#ifndef USE_NEW_ESP32_BLUETOOTH
-#include "BluetoothSoftwareUpdate.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
-
-// "cb0b9a0b-a84c-4c0d-bdbb-442e3144ee30"
-const ble_uuid128_t update_service_uuid =
-    BLE_UUID128_INIT(0x30, 0xee, 0x44, 0x31, 0x2e, 0x44, 0xbb, 0xbd, 0x0d, 0x4c, 0x4c, 0xa8, 0x0b, 0x9a, 0x0b, 0xcb);
-
-// "e74dd9c0-a301-4a6f-95a1-f0e1dbea8e1e" write|read
-const ble_uuid128_t update_size_uuid =
-    BLE_UUID128_INIT(0x1e, 0x8e, 0xea, 0xdb, 0xe1, 0xf0, 0xa1, 0x95, 0x6f, 0x4a, 0x01, 0xa3, 0xc0, 0xd9, 0x4d, 0xe7);
-
-// "e272ebac-d463-4b98-bc84-5cc1a39ee517" write
-const ble_uuid128_t update_data_uuid =
-    BLE_UUID128_INIT(0x17, 0xe5, 0x9e, 0xa3, 0xc1, 0x5c, 0x84, 0xbc, 0x98, 0x4b, 0x63, 0xd4, 0xac, 0xeb, 0x72, 0xe2);
-
-// "4826129c-c22a-43a3-b066-ce8f0d5bacc6" write
-const ble_uuid128_t update_crc32_uuid =
-    BLE_UUID128_INIT(0xc6, 0xac, 0x5b, 0x0d, 0x8f, 0xce, 0x66, 0xb0, 0xa3, 0x43, 0x2a, 0xc2, 0x9c, 0x12, 0x26, 0x48);
-
-// "5e134862-7411-4424-ac4a-210937432c77" read|notify
-const ble_uuid128_t update_result_uuid =
-    BLE_UUID128_INIT(0x77, 0x2c, 0x43, 0x37, 0x09, 0x21, 0x4a, 0xac, 0x24, 0x44, 0x11, 0x74, 0x62, 0x48, 0x13, 0x5e);
-
-// "5e134862-7411-4424-ac4a-210937432c67" write
-const ble_uuid128_t update_region_uuid =
-    BLE_UUID128_INIT(0x67, 0x2c, 0x43, 0x37, 0x09, 0x21, 0x4a, 0xac, 0x24, 0x44, 0x11, 0x74, 0x62, 0x48, 0x13, 0x5e);
-
-const struct ble_gatt_svc_def gatt_update_svcs[] = {
-    {
-        /*** Service: Security test. */
-        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-        .uuid = &update_service_uuid.u,
-        .characteristics =
-            (struct ble_gatt_chr_def[]){{
-                                            .uuid = &update_size_uuid.u,
-                                            .access_cb = update_size_callback,
-                                            .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_AUTHEN | BLE_GATT_CHR_F_READ |
-                                                     BLE_GATT_CHR_F_READ_AUTHEN,
-                                        },
-                                        {
-                                            .uuid = &update_data_uuid.u,
-                                            .access_cb = update_data_callback,
-                                            .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_AUTHEN,
-                                        },
-                                        {
-                                            .uuid = &update_crc32_uuid.u,
-                                            .access_cb = update_crc32_callback,
-                                            .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_AUTHEN,
-                                        },
-                                        {
-                                            .uuid = &update_result_uuid.u,
-                                            .access_cb = update_result_callback,
-                                            .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_READ_AUTHEN | BLE_GATT_CHR_F_NOTIFY,
-                                        },
-                                        {
-                                            .uuid = &update_region_uuid.u,
-                                            .access_cb = update_region_callback,
-                                            .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_AUTHEN,
-                                        },
-                                        {
-                                            0, /* No more characteristics in this service. */
-                                        }},
-    },
-
-    {
-        0, /* No more services. */
-    },
-};
-
-#endif //#ifndef USE_NEW_ESP32_BLUETOOTH

src/gps/GPS.cpp

@@ -3,7 +3,6 @@
 #include "RTC.h"
 #include "configuration.h"
 #include "sleep.h"
-#include <assert.h>
 
 // If we have a serial GPS port it will not be null
 #ifdef GPS_SERIAL_NUM
@@ -59,32 +58,129 @@ bool GPS::getACK(uint8_t c, uint8_t i) {
   }
 }
 
+/**
+ * @brief  
+ * @note   New method, this method can wait for the specified class and message ID, and return the payload
+ * @param  *buffer: The message buffer, if there is a response payload message, it will be returned through the buffer parameter
+ * @param  size:    size of buffer
+ * @param  requestedClass:  request class constant
+ * @param  requestedID:     request message ID constant
+ * @retval length of payload message
+ */
+int GPS::getAck(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID)
+{
+    uint16_t    ubxFrameCounter = 0;
+    uint32_t    startTime = millis();
+    uint16_t    needRead;
+
+    while (millis() - startTime < 800) {
+        while (_serial_gps->available()) {
+            int c = _serial_gps->read();
+            switch (ubxFrameCounter) {
+            case 0:
+                //ubxFrame 'μ'
+                if (c == 0xB5) {    
+                    ubxFrameCounter++;
+                }
+                break;
+            case 1:
+                //ubxFrame 'b'
+                if (c == 0x62) {
+                    ubxFrameCounter++;
+                } else {
+                    ubxFrameCounter = 0;
+                }
+                break;
+            case 2:
+                //Class
+                if (c == requestedClass) {
+                    ubxFrameCounter++;
+                } else {
+                    ubxFrameCounter = 0;
+                }
+                break;
+            case 3:
+                 //Message ID
+                if (c == requestedID) {
+                    ubxFrameCounter++;
+                } else {
+                    ubxFrameCounter = 0;
+                }
+                break;
+            case 4:
+                //Payload lenght lsb
+                needRead = c;
+                ubxFrameCounter++;
+                break;
+            case 5:
+                //Payload lenght msb
+                needRead |=  (c << 8);
+                ubxFrameCounter++;
+                break;
+            case 6:
+                // Check for buffer overflow
+                if (needRead >= size) {
+                    ubxFrameCounter = 0;
+                    break;
+                }
+                if (_serial_gps->readBytes(buffer, needRead) != needRead) {
+                    ubxFrameCounter = 0;
+                } else {
+                    // return payload lenght
+                    return needRead;
+                }
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+    return 0;
+}
+
 bool GPS::setupGPS()
 {
     if (_serial_gps && !didSerialInit) {
         didSerialInit = true;
 
+#ifdef ARCH_ESP32
+    // In esp32 framework, setRxBufferSize needs to be initialized before Serial
+    _serial_gps->setRxBufferSize(2048); // the default is 256
+#endif
+
+// if the overrides are not dialled in, set them from the board definitions, if they exist
+
+#if defined(GPS_RX_PIN)
+if (!config.position.rx_gpio)
+    config.position.rx_gpio = GPS_RX_PIN;
+#endif
+#if defined(GPS_TX_PIN)
+if (!config.position.tx_gpio)
+    config.position.tx_gpio = GPS_TX_PIN;
+#endif
+
 // ESP32 has a special set of parameters vs other arduino ports
-#if defined(GPS_RX_PIN) && !defined(NO_ESP32)
-        _serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
+#if defined(ARCH_ESP32)
+        if(config.position.rx_gpio)
+            _serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, config.position.rx_gpio, config.position.tx_gpio);
 #else
         _serial_gps->begin(GPS_BAUDRATE);
 #endif
-#ifndef NO_ESP32
-        _serial_gps->setRxBufferSize(2048); // the default is 256
-#endif
-#ifdef TTGO_T_ECHO
-        // Switch to 9600 baud, then close and reopen port
-        _serial_gps->end();
-        delay(250);
-        _serial_gps->begin(4800);
-        delay(250);
-        _serial_gps->write("$PCAS01,1*1D\r\n");
-        delay(250);
-        _serial_gps->end();
-        delay(250);
-        _serial_gps->begin(9600);
-        delay(250);
+
+        /*
+        * T-Beam-S3-Core will be preset to use gps Probe here, and other boards will not be changed first
+        */
+        gnssModel =  probe();
+
+        if(gnssModel == GNSS_MODEL_MTK){
+            /*
+            * t-beam-s3-core uses the same L76K GNSS module as t-echo. 
+            * Unlike t-echo, L76K uses 9600 baud rate for communication by default.
+            * */
+            // _serial_gps->begin(9600);    //The baud rate of 9600 has been initialized at the beginning of setupGPS, this line is the redundant part
+            // delay(250);
+
             // Initialize the L76K Chip, use GPS + GLONASS
             _serial_gps->write("$PCAS04,5*1C\r\n");
             delay(250);
@@ -94,23 +190,30 @@ bool GPS::setupGPS()
             // Switch to Vehicle Mode, since SoftRF enables Aviation < 2g
             _serial_gps->write("$PCAS11,3*1E\r\n");
             delay(250);
-#endif
-#ifdef GPS_UBLOX
-        delay(250);
+
+        }else if(gnssModel == GNSS_MODEL_UBLOX){
+
+            /*
+                tips: NMEA Only should not be set here, otherwise initializing Ublox gnss module again after 
+                setting will not output command messages in UART1, resulting in unrecognized module information
+
                 // Set the UART port to output NMEA only
                 byte _message_nmea[] = {0xB5, 0x62, 0x06, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0xC0, 0x08, 0x00, 0x00,
                                         0x80, 0x25, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0xAF};
                 _serial_gps->write(_message_nmea, sizeof(_message_nmea));
                 if (!getACK(0x06, 0x00)) {
-            DEBUG_MSG("WARNING: Unable to enable NMEA Mode.\n");
+                    LOG_WARN("Unable to enable NMEA Mode.\n");
                     return true;
                 }  
+            */
+
+           // ublox-M10S can be compatible with UBLOX traditional protocol, so the following sentence settings are also valid
 
             // disable GGL
             byte _message_GGL[] = {0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x05, 0x3A};
             _serial_gps->write(_message_GGL, sizeof(_message_GGL));
             if (!getACK(0x06, 0x01)) {
-            DEBUG_MSG("WARNING: Unable to disable NMEA GGL.\n");
+                LOG_WARN("Unable to disable NMEA GGL.\n");
                 return true;
             }
 
@@ -118,7 +221,7 @@ bool GPS::setupGPS()
             byte _message_GSA[] = {0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x02, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x06, 0x41};
             _serial_gps->write(_message_GSA, sizeof(_message_GSA));
             if (!getACK(0x06, 0x01)) {
-            DEBUG_MSG("WARNING: Unable to disable NMEA GSA.\n");
+                LOG_WARN("Unable to disable NMEA GSA.\n");
                 return true;
             }
 
@@ -126,7 +229,7 @@ bool GPS::setupGPS()
             byte _message_GSV[] = {0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x03, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x07, 0x48};
             _serial_gps->write(_message_GSV, sizeof(_message_GSV));
             if (!getACK(0x06, 0x01)) {
-            DEBUG_MSG("WARNING: Unable to disable NMEA GSV.\n");
+                LOG_WARN("Unable to disable NMEA GSV.\n");
                 return true;
             }
 
@@ -134,7 +237,7 @@ bool GPS::setupGPS()
             byte _message_VTG[] = {0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x05, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x09, 0x56};
             _serial_gps->write(_message_VTG, sizeof(_message_VTG));
             if (!getACK(0x06, 0x01)) {
-            DEBUG_MSG("WARNING: Unable to disable NMEA VTG.\n");
+                LOG_WARN("Unable to disable NMEA VTG.\n");
                 return true;
             }
 
@@ -142,15 +245,17 @@ bool GPS::setupGPS()
             byte _message_RMC[] = {0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x09, 0x54};
             _serial_gps->write(_message_RMC, sizeof(_message_RMC));
             if (!getACK(0x06, 0x01)) {
-            DEBUG_MSG("WARNING: Unable to enable NMEA RMC.\n");
+                LOG_WARN("Unable to enable NMEA RMC.\n");
                 return true;
             }
 
             // enable GGA
             byte _message_GGA[] = {0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x38};
             _serial_gps->write(_message_GGA, sizeof(_message_GGA));
-        if (!getACK(0x06, 0x01)) DEBUG_MSG("WARNING: Unable to enable NMEA GGA.\n");
-#endif
+            if (!getACK(0x06, 0x01)) {
+                LOG_WARN("Unable to enable NMEA GGA.\n");
+            }
+        }
     }
 
     return true;
@@ -164,21 +269,30 @@ bool GPS::setup()
     pinMode(PIN_GPS_EN, OUTPUT);
 #endif
 
+#ifdef HAS_PMU
+if(config.position.gps_enabled){
+    setGPSPower(true);
+}
+#endif
+
 #ifdef PIN_GPS_RESET
     digitalWrite(PIN_GPS_RESET, 1); // assert for 10ms
     pinMode(PIN_GPS_RESET, OUTPUT);
     delay(10);
     digitalWrite(PIN_GPS_RESET, 0);
 #endif
-
     setAwake(true); // Wake GPS power before doing any init
     bool ok = setupGPS();
 
     if (ok) {
         notifySleepObserver.observe(&notifySleep);
         notifyDeepSleepObserver.observe(&notifyDeepSleep);
+        notifyGPSSleepObserver.observe(&notifyGPSSleep);
+    }
+    if (config.position.gps_enabled==false) {
+        setAwake(false);
+        doGPSpowersave(false);
     }
-
     return ok;
 }
 
@@ -187,6 +301,7 @@ GPS::~GPS()
     // we really should unregister our sleep observer
     notifySleepObserver.unobserve(&notifySleep);
     notifyDeepSleepObserver.unobserve(&notifyDeepSleep);
+    notifyGPSSleepObserver.observe(&notifyGPSSleep);
 }
 
 bool GPS::hasLock()
@@ -245,12 +360,12 @@ void GPS::setNumSatellites(uint8_t n)
 void GPS::setAwake(bool on)
 {
     if (!wakeAllowed && on) {
-        DEBUG_MSG("Inhibiting because !wakeAllowed\n");
+        LOG_WARN("Inhibiting because !wakeAllowed\n");
         on = false;
     }
 
     if (isAwake != on) {
-        DEBUG_MSG("WANT GPS=%d\n", on);
+        LOG_DEBUG("WANT GPS=%d\n", on);
         if (on) {
             lastWakeStartMsec = millis();
             wake();
@@ -271,16 +386,7 @@ uint32_t GPS::getWakeTime() const
 
     if (t == UINT32_MAX)
         return t; // already maxint
-
-    if (t == 0)
-        t = (config.device.role == Config_DeviceConfig_Role_Router)
-                ? 5 * 60
-                : 15 * 60; // Allow up to 15 mins for each attempt (probably will be much
-                           // less if we can find sats) or less if a router
-
-    t *= 1000; // msecs
-
-    return t;
+    return t * 1000;
 }
 
 /** Get how long we should sleep between aqusition attempts in msecs
@@ -288,21 +394,15 @@ uint32_t GPS::getWakeTime() const
 uint32_t GPS::getSleepTime() const
 {
     uint32_t t = config.position.gps_update_interval;
-    bool gps_disabled = config.position.gps_disabled;
+    bool gps_enabled = config.position.gps_enabled;
 
-    if (gps_disabled)
+    if (!gps_enabled)
         t = UINT32_MAX; // Sleep forever now
 
     if (t == UINT32_MAX)
         return t; // already maxint
     
-    if (t == 0) // default - unset in preferences
-        t = (config.device.role == Config_DeviceConfig_Role_Router) ? 24 * 60 * 60
-                                                                                   : 2 * 60; // 2 mins or once per day for routers
-
-    t *= 1000;
-
-    return t;
+    return t * 1000;
 }
 
 void GPS::publishUpdate()
@@ -311,10 +411,10 @@ void GPS::publishUpdate()
         shouldPublish = false;
 
         // In debug logs, identify position by @timestamp:stage (stage 2 = publish)
-        DEBUG_MSG("publishing pos@%x:2, hasVal=%d, GPSlock=%d\n", p.pos_timestamp, hasValidLocation, hasLock());
+        LOG_DEBUG("publishing pos@%x:2, hasVal=%d, GPSlock=%d\n", p.timestamp, hasValidLocation, hasLock());
 
         // Notify any status instances that are observing us
-        const meshtastic::GPSStatus status = meshtastic::GPSStatus(hasValidLocation, isConnected(), p);
+        const meshtastic::GPSStatus status = meshtastic::GPSStatus(hasValidLocation, isConnected(), isPowerSaving(), p);
         newStatus.notifyObservers(&status);
     }
 }
@@ -325,14 +425,14 @@ int32_t GPS::runOnce()
         // if we have received valid NMEA claim we are connected
         setConnected();
     } else {
-#ifdef GPS_UBLOX        
+        if((config.position.gps_enabled == 1) && (gnssModel == GNSS_MODEL_UBLOX)){
             // reset the GPS on next bootup
             if(devicestate.did_gps_reset && (millis() > 60000) && !hasFlow()) {
-            DEBUG_MSG("GPS is not communicating, trying factory reset on next bootup.\n");
+                LOG_DEBUG("GPS is not communicating, trying factory reset on next bootup.\n");
                 devicestate.did_gps_reset = false;
-            nodeDB.saveToDisk();
+                nodeDB.saveDeviceStateToDisk();
+            }
         }
-#endif
     }
 
     // If we are overdue for an update, turn on the GPS and at least publish the current status
@@ -346,7 +446,7 @@ int32_t GPS::runOnce()
 
     // While we are awake
     if (isAwake) {
-        // DEBUG_MSG("looking for location\n");
+        // LOG_DEBUG("looking for location\n");
         if ((now - lastWhileActiveMsec) > 5000) {
             lastWhileActiveMsec = now;
             whileActive();
@@ -361,7 +461,7 @@ int32_t GPS::runOnce()
 
         bool gotLoc = lookForLocation();
         if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
-            DEBUG_MSG("hasValidLocation RISING EDGE\n");
+            LOG_DEBUG("hasValidLocation RISING EDGE\n");
             hasValidLocation = true;
             shouldPublish = true;
         }
@@ -372,13 +472,13 @@ int32_t GPS::runOnce()
         bool tooLong = wakeTime != UINT32_MAX && (now - lastWakeStartMsec) > wakeTime;
 
         // Once we get a location we no longer desperately want an update
-        // DEBUG_MSG("gotLoc %d, tooLong %d, gotTime %d\n", gotLoc, tooLong, gotTime);
+        // LOG_DEBUG("gotLoc %d, tooLong %d, gotTime %d\n", gotLoc, tooLong, gotTime);
         if ((gotLoc && gotTime) || tooLong) {
 
             if (tooLong) {
                 // we didn't get a location during this ack window, therefore declare loss of lock
                 if (hasValidLocation) {
-                    DEBUG_MSG("hasValidLocation FALLING EDGE (last read: %d)\n", gotLoc);
+                    LOG_DEBUG("hasValidLocation FALLING EDGE (last read: %d)\n", gotLoc);
                 }
                 p = Position_init_default;
                 hasValidLocation = false;
@@ -400,7 +500,7 @@ int32_t GPS::runOnce()
 void GPS::forceWake(bool on)
 {
     if (on) {
-        DEBUG_MSG("Allowing GPS lock\n");
+        LOG_DEBUG("Allowing GPS lock\n");
         // lastSleepStartMsec = 0; // Force an update ASAP
         wakeAllowed = true;
     } else {
@@ -415,7 +515,7 @@ void GPS::forceWake(bool on)
 /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
 int GPS::prepareSleep(void *unused)
 {
-    DEBUG_MSG("GPS prepare sleep!\n");
+    LOG_INFO("GPS prepare sleep!\n");
     forceWake(false);
 
     return 0;
@@ -424,29 +524,136 @@ int GPS::prepareSleep(void *unused)
 /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
 int GPS::prepareDeepSleep(void *unused)
 {
-    DEBUG_MSG("GPS deep sleep!\n");
+    LOG_INFO("GPS deep sleep!\n");
 
     // For deep sleep we also want abandon any lock attempts (because we want minimum power)
+    getSleepTime();
     setAwake(false);
 
     return 0;
 }
 
-#ifndef NO_GPS
+GnssModel_t GPS::probe()
+{
+    // return immediately if the model is set by the variant.h file
+#ifdef GPS_UBLOX
+    return GNSS_MODEL_UBLOX;
+#elif defined(GPS_L76K)
+    return GNSS_MODEL_MTK;
+#else
+    // we use autodetect, only T-BEAM S3 for now...
+    uint8_t buffer[256];
+    /*
+    * The GNSS module information variable is temporarily placed inside the function body, 
+    * if it needs to be used elsewhere, it can be moved to the outside
+    * */
+    struct uBloxGnssModelInfo info ;
+
+    memset(&info, 0, sizeof(struct uBloxGnssModelInfo));
+
+    // Close all NMEA sentences , Only valid for MTK platform
+    _serial_gps->write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
+    delay(20);
+
+    // Get version information
+    _serial_gps->write("$PCAS06,0*1B\r\n");
+    uint32_t startTimeout = millis() + 500;
+    while (millis() < startTimeout) {
+        if (_serial_gps->available()) {
+            String ver = _serial_gps->readStringUntil('\r');
+            // Get module info , If the correct header is returned, 
+            // it can be determined that it is the MTK chip
+            int index = ver.indexOf("$");
+            if(index != -1){
+                ver = ver.substring(index);
+                if (ver.startsWith("$GPTXT,01,01,02")) {
+                    LOG_INFO("L76K GNSS init succeeded, using L76K GNSS Module\n");
+                    return GNSS_MODEL_MTK;
+                }
+            }
+        }
+    }
+  
+
+    uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x0E, 0x30};
+    _serial_gps->write(cfg_rate, sizeof(cfg_rate));
+    // Check that the returned response class and message ID are correct
+    if (!getAck(buffer, 256, 0x06, 0x08)) {
+        LOG_WARN("Failed to find UBlox & MTK GNSS Module\n");
+        return GNSS_MODEL_UNKONW;
+    } 
+
+    //  Get Ublox gnss module hardware and software info
+    uint8_t cfg_get_hw[] =  {0xB5, 0x62, 0x0A, 0x04, 0x00, 0x00, 0x0E, 0x34};
+    _serial_gps->write(cfg_get_hw, sizeof(cfg_get_hw));
+
+    uint16_t len = getAck(buffer, 256, 0x0A, 0x04);
+    if (len) {
+
+        uint16_t position = 0;
+        for (int i = 0; i < 30; i++) {
+            info.swVersion[i] = buffer[position];
+            position++;
+        }
+        for (int i = 0; i < 10; i++) {
+            info.hwVersion[i] = buffer[position];
+            position++;
+        }
+
+        while (len >= position + 30) {
+            for (int i = 0; i < 30; i++) {
+                info.extension[info.extensionNo][i] = buffer[position];
+                position++;
+            }
+            info.extensionNo++;
+            if (info.extensionNo > 9)
+                break;
+        }
+
+        LOG_DEBUG("Module Info : \n");
+        LOG_DEBUG("Soft version: %s\n",info.swVersion);
+        LOG_DEBUG("Hard version: %s\n",info.hwVersion);
+        LOG_DEBUG("Extensions:%d\n",info.extensionNo);
+        for (int i = 0; i < info.extensionNo; i++) {
+            LOG_DEBUG("  %s\n",info.extension[i]);
+        }
+
+        memset(buffer,0,sizeof(buffer));
+
+        //tips: extensionNo field is 0 on some 6M GNSS modules
+        for (int i = 0; i < info.extensionNo; ++i) {
+            if (!strncmp(info.extension[i], "OD=", 3)) {
+                strcpy((char *)buffer, &(info.extension[i][3]));
+                LOG_DEBUG("GetModel:%s\n",(char *)buffer);
+            }
+        }
+    }
+
+    if (strlen((char*)buffer)) {
+        LOG_INFO("UBlox GNSS init succeeded, using UBlox %s GNSS Module\n" , buffer);
+    }else{
+        LOG_INFO("UBlox GNSS init succeeded, using UBlox GNSS Module\n");
+    }
+
+    return GNSS_MODEL_UBLOX;
+#endif
+}
+
+#if HAS_GPS
 #include "NMEAGPS.h"
 #endif
 
 GPS *createGps()
 {
 
-#ifdef NO_GPS
+#if !HAS_GPS
     return nullptr;
 #else
-    if (!config.position.gps_disabled) {
+    if (config.position.gps_enabled) {
 #ifdef GPS_ALTITUDE_HAE
-        DEBUG_MSG("Using HAE altitude model\n");
+        LOG_DEBUG("Using HAE altitude model\n");
 #else
-        DEBUG_MSG("Using MSL altitude model\n");
+        LOG_DEBUG("Using MSL altitude model\n");
 #endif
         if (GPS::_serial_gps) {
             // Some boards might have only the TX line from the GPS connected, in that case, we can't configure it at all.  Just
@@ -456,6 +663,11 @@ GPS *createGps()
             return new_gps;
         }
     }
+    else{
+        GPS *new_gps = new NMEAGPS();
+        new_gps->setup();
+        return new_gps;
+    }
     return nullptr;
 #endif
 }

src/gps/GPS.h

@@ -4,6 +4,20 @@
 #include "Observer.h"
 #include "concurrency/OSThread.h"
 
+
+struct uBloxGnssModelInfo { 
+    char    swVersion[30];
+    char    hwVersion[10];
+    uint8_t extensionNo;
+    char    extension[10][30];
+} ;
+
+typedef enum{
+  GNSS_MODEL_MTK,
+  GNSS_MODEL_UBLOX,
+  GNSS_MODEL_UNKONW,
+}GnssModel_t;
+
 // Generate a string representation of DOP
 const char *getDOPString(uint32_t dop);
 
@@ -35,6 +49,7 @@ class GPS : private concurrency::OSThread
 
     CallbackObserver<GPS, void *> notifySleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareSleep);
     CallbackObserver<GPS, void *> notifyDeepSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
+    CallbackObserver<GPS, void *> notifyGPSSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
 
   public:
     /** If !NULL we will use this serial port to construct our GPS */
@@ -63,6 +78,8 @@ class GPS : private concurrency::OSThread
     /// Return true if we are connected to a GPS
     bool isConnected() const { return hasGPS; }
 
+    bool isPowerSaving() const { return !config.position.gps_enabled;}
+
     /**
      * Restart our lock attempt - try to get and broadcast a GPS reading ASAP
      * called after the CPU wakes from light-sleep state
@@ -146,6 +163,14 @@ class GPS : private concurrency::OSThread
     void publishUpdate();
 
     virtual int32_t runOnce() override;
+
+  // Get GNSS model
+    GnssModel_t probe();
+
+    int getAck(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID);
+
+  protected:
+    GnssModel_t gnssModel = GNSS_MODEL_UNKONW;
 };
 
 // Creates an instance of the GPS class. 

src/gps/GeoCoord.cpp

@@ -379,7 +379,7 @@ float GeoCoord::latLongToMeter(double lat_a, double lng_a, double lat_b, double
  * Latitude of the second point
  * @param lon2
  * Longitude of the second point
- * @return Bearing between the two points in radians. A value of 0 means due
+ * @return Bearing from point 1 to point 2 in radians. A value of 0 means due
  * north.
  */
 float GeoCoord::bearing(double lat1, double lon1, double lat2, double lon2)

src/gps/NMEAGPS.cpp

@@ -19,14 +19,21 @@ static int32_t toDegInt(RawDegrees d)
 
 bool NMEAGPS::factoryReset()
 {
-#ifdef GPS_UBLOX
+#ifdef PIN_GPS_REINIT
+    //The L76K GNSS on the T-Echo requires the RESET pin to be pulled LOW
+    digitalWrite(PIN_GPS_REINIT, 0);
+    pinMode(PIN_GPS_REINIT, OUTPUT);
+    delay(150); //The L76K datasheet calls for at least 100MS delay
+    digitalWrite(PIN_GPS_REINIT, 1);
+#endif  
+
+    // send the UBLOX Factory Reset Command regardless of detect state, something is very wrong, just assume it's UBLOX.
     // Factory Reset
     byte _message_reset[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF,
         0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0xFF, 0xFF, 0x00, 0x00, 0x17, 0x2B, 0x7E};
     _serial_gps->write(_message_reset,sizeof(_message_reset));
     delay(1000);
-#endif
     return true;
 }
 
@@ -46,9 +53,9 @@ bool NMEAGPS::setupGPS()
     // see NMEAGPS.h
     gsafixtype.begin(reader, NMEA_MSG_GXGSA, 2);
     gsapdop.begin(reader, NMEA_MSG_GXGSA, 15);
-    DEBUG_MSG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
+    LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
 #else
-    DEBUG_MSG("GxGSA NOT available\n");
+    LOG_DEBUG("GxGSA NOT available\n");
 #endif
 
     return true;
@@ -78,7 +85,7 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
         t.tm_year = d.year() - 1900;
         t.tm_isdst = false;
         if (t.tm_mon > -1){
-            DEBUG_MSG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
+            LOG_DEBUG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
             perhapsSetRTC(RTCQualityGPS, t);
             return true;
         } else
@@ -102,7 +109,7 @@ bool NMEAGPS::lookForLocation()
 
 #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
     fixType = atoi(gsafixtype.value());  // will set to zero if no data
-    DEBUG_MSG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
+    // LOG_DEBUG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
 #endif
 
     // check if GPS has an acceptable lock
@@ -110,7 +117,7 @@ bool NMEAGPS::lookForLocation()
         return false;
 
 #ifdef GPS_EXTRAVERBOSE
-    DEBUG_MSG("AGE: LOC=%d FIX=%d DATE=%d TIME=%d\n", 
+    LOG_DEBUG("AGE: LOC=%d FIX=%d DATE=%d TIME=%d\n", 
                 reader.location.age(), 
 #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
                 gsafixtype.age(),
@@ -130,7 +137,7 @@ bool NMEAGPS::lookForLocation()
             (reader.time.age() < GPS_SOL_EXPIRY_MS) &&
             (reader.date.age() < GPS_SOL_EXPIRY_MS)))
     {
-        DEBUG_MSG("SOME data is TOO OLD: LOC %u, TIME %u, DATE %u\n", reader.location.age(), reader.time.age(), reader.date.age());
+        LOG_WARN("SOME data is TOO OLD: LOC %u, TIME %u, DATE %u\n", reader.location.age(), reader.time.age(), reader.date.age());
         return false;
     }
 
@@ -144,24 +151,24 @@ bool NMEAGPS::lookForLocation()
     // Bail out EARLY to avoid overwriting previous good data (like #857)
     if (toDegInt(loc.lat) > 900000000) {
 #ifdef GPS_EXTRAVERBOSE        
-        DEBUG_MSG("Bail out EARLY on LAT %i\n",toDegInt(loc.lat));
+        LOG_DEBUG("Bail out EARLY on LAT %i\n",toDegInt(loc.lat));
 #endif
         return false;
     }
     if (toDegInt(loc.lng) > 1800000000) {
 #ifdef GPS_EXTRAVERBOSE        
-        DEBUG_MSG("Bail out EARLY on LNG %i\n",toDegInt(loc.lng));
+        LOG_DEBUG("Bail out EARLY on LNG %i\n",toDegInt(loc.lng));
 #endif
         return false;
     }
 
-    p.location_source = Position_LocSource_LOCSRC_GPS_INTERNAL;
+    p.location_source = Position_LocSource_LOC_INTERNAL;
 
     // Dilution of precision (an accuracy metric) is reported in 10^2 units, so we need to scale down when we use it
 #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
     p.HDOP = reader.hdop.value();
     p.PDOP = TinyGPSPlus::parseDecimal(gsapdop.value());
-    DEBUG_MSG("PDOP=%d, HDOP=%d\n", dop, reader.hdop.value());
+    // LOG_DEBUG("PDOP=%d, HDOP=%d\n", p.PDOP, p.HDOP);
 #else
     // FIXME! naive PDOP emulation (assumes VDOP==HDOP)
     // correct formula is PDOP = SQRT(HDOP^2 + VDOP^2)
@@ -176,8 +183,8 @@ bool NMEAGPS::lookForLocation()
     p.latitude_i = toDegInt(loc.lat);
     p.longitude_i = toDegInt(loc.lng);
 
-    p.alt_geoid_sep = reader.geoidHeight.meters();
-    p.altitude_hae = reader.altitude.meters() + p.alt_geoid_sep;
+    p.altitude_geoidal_separation = reader.geoidHeight.meters();
+    p.altitude_hae = reader.altitude.meters() + p.altitude_geoidal_separation;
     p.altitude = reader.altitude.meters();
 
     p.fix_quality = fixQual;
@@ -194,7 +201,7 @@ bool NMEAGPS::lookForLocation()
     t.tm_mon = reader.date.month() - 1;
     t.tm_year = reader.date.year() - 1900;
     t.tm_isdst = false;
-    p.pos_timestamp = mktime(&t);
+    p.timestamp = mktime(&t);
 
     // Nice to have, if available
     if (reader.satellites.isUpdated()) {
@@ -205,18 +212,15 @@ bool NMEAGPS::lookForLocation()
         if (reader.course.value() < 36000) {  // sanity check
             p.ground_track = reader.course.value() * 1e3; // Scale the heading (in degrees * 10^-2) to match the expected degrees * 10^-5
         } else {
-            DEBUG_MSG("BOGUS course.value() REJECTED: %d\n",
+            LOG_WARN("BOGUS course.value() REJECTED: %d\n",
                         reader.course.value());
         }
     }
 
-/*
-    // REDUNDANT?
-    // expect gps pos lat=37.520825, lon=-122.309162, alt=158
-    DEBUG_MSG("new NMEA GPS pos lat=%f, lon=%f, alt=%d, dop=%g, heading=%f\n",
-              latitude * 1e-7, longitude * 1e-7, altitude, dop * 1e-2,
-              heading * 1e-5);
-*/
+    if (reader.speed.isUpdated() && reader.speed.isValid()) {
+        p.ground_speed = reader.speed.kmph();
+    }
+
     return true;
 }
 
@@ -247,7 +251,7 @@ bool NMEAGPS::whileIdle()
     // First consume any chars that have piled up at the receiver
     while (_serial_gps->available() > 0) {
         int c = _serial_gps->read();
-        // DEBUG_MSG("%c", c);
+        // LOG_DEBUG("%c", c);
         isValid |= reader.encode(c);
     }
 

src/gps/NMEAWPL.cpp

@@ -0,0 +1,90 @@
+#include "NMEAWPL.h"
+#include "GeoCoord.h"
+
+/* -------------------------------------------
+ *        1       2 3        4 5    6
+ *        |       | |        | |    |
+ * $--WPL,llll.ll,a,yyyyy.yy,a,c--c*hh<CR><LF>
+ *
+ * Field Number:
+ * 1 Latitude
+ * 2 N or S (North or South)
+ * 3 Longitude
+ * 4 E or W (East or West)
+ * 5 Waypoint name
+ * 6 Checksum
+ * -------------------------------------------
+ */
+
+uint32_t printWPL(char *buf, const Position &pos, const char *name)
+{
+    GeoCoord geoCoord(pos.latitude_i,pos.longitude_i,pos.altitude);
+    uint32_t len = sprintf(buf, "$GNWPL,%02d%07.4f,%c,%03d%07.4f,%c,%s",
+        geoCoord.getDMSLatDeg(),
+        (abs(geoCoord.getLatitude()) - geoCoord.getDMSLatDeg() * 1e+7) * 6e-6,
+        geoCoord.getDMSLatCP(),
+        geoCoord.getDMSLonDeg(),
+        (abs(geoCoord.getLongitude()) - geoCoord.getDMSLonDeg() * 1e+7) * 6e-6,
+        geoCoord.getDMSLonCP(),
+        name);
+    uint32_t chk = 0;
+    for (uint32_t i = 1; i < len; i++) {
+        chk ^= buf[i];
+    }
+    len += sprintf(buf + len, "*%02X\r\n", chk);
+    return len;
+}
+
+/* -------------------------------------------
+ *        1         2       3 4       5 6 7  8   9  10 11 12 13  14   15
+ *        |         |       | |       | | |  |   |   | |   | |   |    |
+ * $--GGA,hhmmss.ss,ddmm.mm,a,ddmm.mm,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*hh<CR><LF>
+ *
+ * Field Number:
+ *  1 UTC of this position report, hh is hours, mm is minutes, ss.ss is seconds.
+ *  2 Latitude
+ *  3 N or S (North or South)
+ *  4 Longitude
+ *  5 E or W (East or West)
+ *  6 GPS Quality Indicator (non null)
+ *  7 Number of satellites in use, 00 - 12
+ *  8 Horizontal Dilution of precision (meters)
+ *  9 Antenna Altitude above/below mean-sea-level (geoid) (in meters)
+ * 10 Units of antenna altitude, meters
+ * 11 Geoidal separation, the difference between the WGS-84 earth ellipsoid and mean-sea-level (geoid), "-" means mean-sea-level below ellipsoid
+ * 12 Units of geoidal separation, meters
+ * 13 Age of differential GPS data, time in seconds since last SC104 type 1 or 9 update, null field when DGPS is not used
+ * 14 Differential reference station ID, 0000-1023
+ * 15 Checksum
+ * -------------------------------------------
+ */
+
+uint32_t printGGA(char *buf, const Position &pos)
+{
+    GeoCoord geoCoord(pos.latitude_i,pos.longitude_i,pos.altitude);
+    uint32_t len = sprintf(buf, "$GNGGA,%06u.%03u,%02d%07.4f,%c,%03d%07.4f,%c,%u,%02u,%04u,%04d,%c,%04d,%c,%d,%04d",
+        pos.time / 1000,
+        pos.time % 1000,
+        geoCoord.getDMSLatDeg(),
+        (abs(geoCoord.getLatitude()) - geoCoord.getDMSLatDeg() * 1e+7) * 6e-6,
+        geoCoord.getDMSLatCP(),
+        geoCoord.getDMSLonDeg(),
+        (abs(geoCoord.getLongitude()) - geoCoord.getDMSLonDeg() * 1e+7) * 6e-6,
+        geoCoord.getDMSLonCP(),
+        pos.fix_type,
+        pos.sats_in_view,
+        pos.HDOP,
+        geoCoord.getAltitude(),
+        'M',
+        pos.altitude_geoidal_separation,
+        'M',
+        0,
+        0);
+
+    uint32_t chk = 0;
+    for (uint32_t i = 1; i < len; i++) {
+        chk ^= buf[i];
+    }
+    len += sprintf(buf + len, "*%02X\r\n", chk);
+    return len;
+}

src/gps/NMEAWPL.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <Arduino.h>
+#include "main.h"
+
+uint32_t printWPL(char *buf, const Position &pos, const char *name);
+uint32_t printGGA(char *buf, const Position &pos);

src/gps/RTC.cpp

@@ -33,7 +33,7 @@ void readFromRTC()
         t.tm_sec = rtc.getSecond();
         tv.tv_sec = mktime(&t);
         tv.tv_usec = 0;
-        DEBUG_MSG("Read RTC time from RV3028 as %ld\n", tv.tv_sec);
+        LOG_DEBUG("Read RTC time from RV3028 as %ld\n", tv.tv_sec);
         timeStartMsec = now;
         zeroOffsetSecs = tv.tv_sec;
         if (currentQuality == RTCQualityNone) {
@@ -44,18 +44,22 @@ void readFromRTC()
     if(rtc_found == PCF8563_RTC) {
         uint32_t now = millis();
         PCF8563_Class rtc;
+#ifdef RTC_USE_WIRE1
+        rtc.begin(Wire1);
+#else
         rtc.begin();
+#endif
         auto tc = rtc.getDateTime();
         tm t;
-        t.tm_year = tc.year;
-        t.tm_mon = tc.month;
+        t.tm_year = tc.year - 1900;
+        t.tm_mon = tc.month - 1;
         t.tm_mday = tc.day;
         t.tm_hour = tc.hour;
         t.tm_min = tc.minute;
         t.tm_sec = tc.second;
         tv.tv_sec = mktime(&t);
         tv.tv_usec = 0;
-        DEBUG_MSG("Read RTC time from PCF8563 as %ld\n", tv.tv_sec);
+        LOG_DEBUG("Read RTC time from PCF8563 as %ld\n", tv.tv_sec);
         timeStartMsec = now;
         zeroOffsetSecs = tv.tv_sec;
         if (currentQuality == RTCQualityNone) {
@@ -65,7 +69,7 @@ void readFromRTC()
 #else 
     if (!gettimeofday(&tv, NULL)) {
         uint32_t now = millis();
-        DEBUG_MSG("Read RTC time as %ld\n", tv.tv_sec);
+        LOG_DEBUG("Read RTC time as %ld\n", tv.tv_sec);
         timeStartMsec = now;
         zeroOffsetSecs = tv.tv_sec;
     }
@@ -82,11 +86,11 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
     if (q > currentQuality) {
         currentQuality = q;
         shouldSet = true;
-        DEBUG_MSG("Upgrading time to RTC %ld secs (quality %d)\n", tv->tv_sec, q);
+        LOG_DEBUG("Upgrading time to RTC %ld secs (quality %d)\n", tv->tv_sec, q);
     } else if(q == RTCQualityGPS && (now - lastSetMsec) > (12 * 60 * 60 * 1000UL)) {
         // Every 12 hrs we will slam in a new GPS time, to correct for local RTC clock drift
         shouldSet = true;
-        DEBUG_MSG("Reapplying external time to correct clock drift %ld secs\n", tv->tv_sec);
+        LOG_DEBUG("Reapplying external time to correct clock drift %ld secs\n", tv->tv_sec);
     }
     else
         shouldSet = false;
@@ -105,22 +109,26 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
             rtc.initI2C();
             tm *t = localtime(&tv->tv_sec);
             rtc.setTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_wday, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
-            DEBUG_MSG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
+            LOG_DEBUG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
         }
 #elif defined(PCF8563_RTC)
         if(rtc_found == PCF8563_RTC) {
             PCF8563_Class rtc;
+#ifdef RTC_USE_WIRE1
+        rtc.begin(Wire1);
+#else
         rtc.begin();
+#endif
             tm *t = localtime(&tv->tv_sec);
-            rtc.setDateTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_wday, t->tm_hour, t->tm_min, t->tm_sec);
-            DEBUG_MSG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
+            rtc.setDateTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
+            LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
         }
-#elif !defined(NO_ESP32)
+#elif defined(ARCH_ESP32)
         settimeofday(tv, NULL);
 #endif
 
         // nrf52 doesn't have a readable RTC (yet - software not written)
-#if defined(PORTDUINO) || !defined(NO_ESP32) || defined(RV3028_RTC) || defined(PCF8563_RTC)
+#ifdef HAS_RTC
         readFromRTC();
 #endif
 
@@ -141,9 +149,9 @@ bool perhapsSetRTC(RTCQuality q, struct tm &t)
     tv.tv_sec = res;
     tv.tv_usec = 0; // time.centisecond() * (10 / 1000);
 
-    // DEBUG_MSG("Got time from GPS month=%d, year=%d, unixtime=%ld\n", t.tm_mon, t.tm_year, tv.tv_sec);
+    // LOG_DEBUG("Got time from GPS month=%d, year=%d, unixtime=%ld\n", t.tm_mon, t.tm_year, tv.tv_sec);
     if (t.tm_year < 0 || t.tm_year >= 300) {
-        // DEBUG_MSG("Ignoring invalid GPS month=%d, year=%d, unixtime=%ld\n", t.tm_mon, t.tm_year, tv.tv_sec);
+        // LOG_DEBUG("Ignoring invalid GPS month=%d, year=%d, unixtime=%ld\n", t.tm_mon, t.tm_year, tv.tv_sec);
         return false;
     } else {
         return perhapsSetRTC(q, &tv);

src/graphics/EInkDisplay2.cpp

@@ -1,6 +1,6 @@
 #include "configuration.h"
 
-#ifdef HAS_EINK
+#ifdef USE_EINK
 #include "main.h"
 #include "EInkDisplay2.h"
 #include "SPILock.h"
@@ -14,8 +14,8 @@
 #define TECHO_DISPLAY_MODEL GxEPD2_154_D67
 #elif defined(RAK4630)
 
-//GxEPD2_213_B74 - RAK14000 2.13 inch b/w 250x128 
-#define TECHO_DISPLAY_MODEL GxEPD2_213_B74
+//GxEPD2_213_BN - RAK14000 2.13 inch b/w 250x122 - changed from GxEPD2_213_B74 - which was not going to give partial update support
+#define TECHO_DISPLAY_MODEL GxEPD2_213_BN
 
 //4.2 inch 300x400 - GxEPD2_420_M01
 //#define TECHO_DISPLAY_MODEL GxEPD2_420_M01
@@ -46,7 +46,7 @@ EInkDisplay::EInkDisplay(uint8_t address, int sda, int scl)
     setGeometry(GEOMETRY_RAWMODE, TECHO_DISPLAY_MODEL::WIDTH, TECHO_DISPLAY_MODEL::HEIGHT);
     #elif defined(RAK4630)
     
-    //GxEPD2_213_B74 - RAK14000 2.13 inch b/w 250x128 
+    //GxEPD2_213_BN - RAK14000 2.13 inch b/w 250x122 
     setGeometry(GEOMETRY_RAWMODE, 250, 122);
 
     //GxEPD2_420_M01
@@ -103,21 +103,24 @@ bool EInkDisplay::forceDisplay(uint32_t msecLimit)
             }
         }
 
-        DEBUG_MSG("Updating E-Paper... ");
+        LOG_DEBUG("Updating E-Paper... ");
         
         #if defined(TTGO_T_ECHO)
         // ePaper.Reset(); // wake the screen from sleep
         adafruitDisplay->display(false); // FIXME, use partial update mode
         #elif defined(RAK4630)
         
-        //RAK14000 2.13 inch b/w 250x122 does not support partial updates
-        adafruitDisplay->display(false); // FIXME, use partial update mode
+        //RAK14000 2.13 inch b/w 250x122 actually now does support partial updates
+        
+        //Full update mode (slow)
+        //adafruitDisplay->display(false); // FIXME, use partial update mode
         
         //Only enable for e-Paper with support for partial updates and comment out above adafruitDisplay->display(false); 
         // 1.54 inch 200x200 - GxEPD2_154_M09
+        // 2.13 inch 250x122 - GxEPD2_213_BN
         // 2.9 inch 296x128 - GxEPD2_290_T5D
         // 4.2 inch 300x400 - GxEPD2_420_M01
-        //adafruitDisplay->nextPage();
+        adafruitDisplay->nextPage();
         
         #elif defined(PCA10059) || defined(M5_COREINK)
         adafruitDisplay->nextPage();
@@ -125,11 +128,11 @@ bool EInkDisplay::forceDisplay(uint32_t msecLimit)
         
         // Put screen to sleep to save power (possibly not necessary because we already did poweroff inside of display)
         adafruitDisplay->hibernate();
-        DEBUG_MSG("done\n");
+        LOG_DEBUG("done\n");
 
         return true;
     } else {
-        // DEBUG_MSG("Skipping eink display\n");
+        // LOG_DEBUG("Skipping eink display\n");
         return false;
     }
 }
@@ -159,7 +162,7 @@ void EInkDisplay::setDetected(uint8_t detected)
 // Connect to the display
 bool EInkDisplay::connect()
 {
-    DEBUG_MSG("Doing EInk init\n");
+    LOG_INFO("Doing EInk init\n");
 
 #ifdef PIN_EINK_PWR_ON
     digitalWrite(PIN_EINK_PWR_ON, HIGH); // If we need to assert a pin to power external peripherals
@@ -190,11 +193,11 @@ bool EInkDisplay::connect()
         
         adafruitDisplay->init(115200, true, 10, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
 
-        //RAK14000 2.13 inch b/w 250x122 does not support partial updates 
+        //RAK14000 2.13 inch b/w 250x122 does actually now support partial updates 
         adafruitDisplay->setRotation(3);
-        //For 1.54, 2.9 and 4.2
+        //Partial update support for  1.54, 2.13 RAK14000 b/w , 2.9 and 4.2
         //adafruitDisplay->setRotation(1);
-        //adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
     } else {
         (void)adafruitDisplay;
     }      
@@ -210,8 +213,7 @@ bool EInkDisplay::connect()
 #elif defined(M5_COREINK)
     auto lowLevel = new TECHO_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
     adafruitDisplay = new GxEPD2_BW<TECHO_DISPLAY_MODEL, TECHO_DISPLAY_MODEL::HEIGHT>(*lowLevel);
-    delay(100);
-    adafruitDisplay->init(115200, true, 20, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+    adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
     adafruitDisplay->setRotation(0);
     adafruitDisplay->setPartialWindow(0, 0, EPD_WIDTH, EPD_HEIGHT);
 #endif