Merge pull request #2000 from meshtastic/develop

Develop upstream

.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,54 @@
+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: 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,56 +23,22 @@ 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: m5stack-core
+          - board: station-g1
           - board: m5stack-coreink
-          
+          - board: tbeam-s3-core
+
     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 }}
@@ -92,71 +57,19 @@ jobs:
           - board: heltec-v1
           - board: heltec-v2.0
           - board: heltec-v2.1
+          - board: heltec-v3
+          - board: heltec-wsl-v3
           - board: tbeam0.7
           - board: meshtastic-diy-v1
+          - board: meshtastic-dr-dev
           - board: nano-g1
+          - board: station-g1
           - board: m5stack-core
           - board: m5stack-coreink
-
-    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 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: tbeam-s3-core
+    uses: ./.github/workflows/build_esp32.yml
+    with:
+      board: ${{ matrix.board }}
 
   build-nrf52:
     strategy:
@@ -168,85 +81,29 @@ jobs:
           - board: rak4631_eink
           - board: t-echo
           - board: pca10059_diy_eink
+          - board: feather_diy
+    uses: ./.github/workflows/build_nrf52.yml
+    with:
+      board: ${{ matrix.board }}
 
-    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
-
-      - name: Build NRF52
-        run: bin/build-nrf52.sh ${{ matrix.board }}
-
-      - name: Get release version string
-        run: echo "::set-output name=version::$(./bin/buildinfo.py long)"
-        id: version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: firmware-${{ matrix.board }}-${{ steps.version.outputs.version }}.zip
-          path: |
-            release/*.uf2
-            release/*.elf
-          retention-days: 90
+  build-rpi2040:
+    strategy:
+      fail-fast: false
+      max-parallel: 2
+      matrix:
+        include:
+          - board: pico
+    uses: ./.github/workflows/build_rpi2040.yml
+    with:
+      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
@@ -262,19 +119,37 @@ 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
     needs: [check]
@@ -287,7 +162,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
@@ -295,30 +170,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
@@ -327,15 +202,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' }}
@@ -348,3 +228,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"

.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

@@ -52,7 +52,9 @@
         "shared_mutex": "cpp",
         "iostream": "cpp",
         "esp_nimble_hci.h": "c",
-        "map": "cpp"
+        "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/workflow/status/meshtastic/firmware/CI?label=actions&logo=github&color=yellow)](https://github.com/meshtastic/firmware/actions/workflows/main_matrix.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,52 @@
+; 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
+
+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
+
+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/esp32s3.ini

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

bin/build-esp32.sh

@@ -10,11 +10,8 @@ OUTDIR=release/
 rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
-# Make sure our submodules are current
-git submodule update 
-
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-platformio lib update 
+platformio pkg update 
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f .pio/build/$1/firmware.*
@@ -29,13 +26,15 @@ SRCELF=.pio/build/$1/firmware.elf
 cp $SRCELF $OUTDIR/$basename.elf
 
 echo "Copying ESP32 bin file"
-SRCBIN=.pio/build/$1/firmware.bin
+SRCBIN=.pio/build/$1/firmware.factory.bin
 cp $SRCBIN $OUTDIR/$basename.bin
 
+echo "Copying ESP32 update bin file"
+SRCBIN=.pio/build/$1/firmware.bin
+cp $SRCBIN $OUTDIR/$basename-update.bin
+
 echo "Building Filesystem for ESP32 targets"
 pio run --environment tbeam -t buildfs
-cp .pio/build/tbeam/spiffs.bin $OUTDIR/littlefs-$VERSION.bin
-cp 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,17 +26,20 @@ IF "__%FILENAME%__" == "____" (
     echo "Missing FILENAME"
 	goto HELP
 )
-IF EXIST %FILENAME% (
+IF EXIST %FILENAME% IF x%FILENAME:update=%==x%FILENAME% (
     echo Trying to flash update %FILENAME%, but first erasing and writing system information"
 	%PYTHON% -m esptool --baud 115200 erase_flash
-	%PYTHON% -m esptool --baud 115200 write_flash 0x1000 system-info.bin
+	%PYTHON% -m esptool --baud 115200 write_flash 0x00 %FILENAME%
+	%PYTHON% -m esptool --baud 115200 write_flash 0x260000 bleota.bin
     for %%f in (littlefs-*.bin) do (
-        %PYTHON% -m esptool --baud 115200 write_flash 0x00390000 %%f
+        %PYTHON% -m esptool --baud 115200 write_flash 0x300000 %%f
     )
-	%PYTHON% -m esptool --baud 115200 write_flash 0x10000 %FILENAME%
+) else (
+    echo "Invalid file: %FILENAME%"
+	goto HELP
 ) else (
     echo "Invalid file: %FILENAME%"
 	goto HELP
 )
 
-:EOF
+:EOF

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}" ] && [[ "${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,14 +26,15 @@ IF "__%FILENAME%__" == "____" (
     echo "Missing FILENAME"
 	goto HELP
 )
-IF EXIST %FILENAME% (
+IF EXIST %FILENAME% IF NOT x%FILENAME:update=%==x%FILENAME% (
     echo Trying to flash update %FILENAME%
     %PYTHON% -m esptool --baud 115200 write_flash 0x10000 %FILENAME%
-    echo Erasing the otadata partition, which will turn off flash flippy-flop and force the first image to be used
-    %PYTHON% -m esptool --baud 115200 erase_region 0xe000 0x2000
+) else (
+    echo "Invalid file: %FILENAME%"
+	goto HELP
 ) else (
     echo "Invalid file: %FILENAME%"
 	goto HELP
 )
 
-:EOF
+:EOF

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}."
+if [ -f "${FILENAME}" ] && [[ $FILENAME == *"update"* ]]; then
+	printf "Trying to flash update ${FILENAME}"
 	$PYTHON -m esptool --baud 115200 write_flash 0x10000 ${FILENAME}
-	echo "Erasing the otadata partition, which will turn off flash flippy-flop and force the first image to be used"
-	$PYTHON -m esptool --baud 115200 erase_region 0xe000 0x2000
 else
-	echo "Invalid file: ${FILENAME}"
 	show_help
+	echo "Invalid file: ${FILENAME}"
 fi
 
 exit 0

bin/mklittlefs.py

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

bin/platformio-custom.py

@@ -1,24 +1,70 @@
-
-
 import subprocess
 import configparser
 import traceback
 import sys
+from os.path import join
 from readprops import readProps
 
 Import("env")
-env.Replace( MKSPIFFSTOOL=env.get("PROJECT_DIR") + '/bin/mklittlefs.py' )
-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 platformio-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/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.sh

@@ -3,7 +3,7 @@
 set -e
 
 echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.6 to be located in the"
-echo "meshtastic-device root directory if the following step fails, you should download the correct"
+echo "firmware root directory if the following step fails, you should download the correct"
 echo "prebuilt binaries for your computer into nanopb-0.4.6"
 
 # the nanopb tool seems to require that the .options file be in the current directory!

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,48 @@
+{
+  "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_DFU_ON_BOOT=1",
+      "-DARDUINO_USB_MSC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "dio",
+    "hwids": [
+      [
+        "0X303A",
+        "0x1001"
+      ]
+    ],
+    "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"
+}

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,7 +2,9 @@
 ; 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
@@ -20,9 +22,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,137 +37,73 @@ 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 = 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.0
 
 ; 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
+  mprograms/QMC5883LCompass@^1.1.1
+  https://github.com/meshtastic/SparkFun_ATECCX08a_Arduino_Library.git#52b5282639d08a8cbd4b748363089eed6102dc76
 
-build_flags = ${env.build_flags} -Os 
-# -DRADIOLIB_GODMODE
-build_src_filter = ${env.build_src_filter} -<portduino/>
+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
   adafruit/Adafruit INA260 Library@^1.5.0
   adafruit/Adafruit INA219@^1.2.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 = 115200
-debug_init_break = tbreak setup
-
-# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
-# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
-# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
-# -DUSE_NEW_ESP32_BLUETOOTH will enable the new NimBLE C++ api
-build_flags =
-  ${arduino_base.build_flags} -Wall -Wextra -Isrc/esp32 -Isrc/esp32-mfix-esp32-psram-cache-issue -lnimble -std=c++11 
-  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
-  -DAXP_DEBUG_PORT=Serial -DUSE_NEW_ESP32_BLUETOOTH
-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 SHTC3 Library@^1.0.0
+  adafruit/Adafruit LPS2X@^2.0.4

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
 {
 /**
@@ -127,25 +123,32 @@ class ButtonThread : public concurrency::OSThread
     static void userButtonPressedLong()
     {
         // DEBUG_MSG("Long press!\n");
-#ifndef NRF52_SERIES
+#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");
                 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
@@ -156,21 +159,16 @@ class ButtonThread : public concurrency::OSThread
 
     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
     }
 
     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()

src/DebugConfiguration.h

@@ -17,29 +17,6 @@
 
 #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__)
 #else

src/FSCommon.cpp

@@ -1,10 +1,70 @@
 #include "configuration.h"
 #include "FSCommon.h"
 
-void listDir(const char * dirname, uint8_t levels)
+#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)
 {
 #ifdef FSCom
-    File root = FSCom.open(dirname);
+    unsigned char cbuffer[16];
+   
+    File f1 = FSCom.open(from, FILE_O_READ);
+    if (!f1){
+        DEBUG_MSG("Failed to open source file %s\n", from);
+        return false;
+    }
+
+    File f2 = FSCom.open(to, FILE_O_WRITE);
+    if (!f2) {
+        DEBUG_MSG("Failed to open 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,55 +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) { 
+                    DEBUG_MSG("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) { 
+                    DEBUG_MSG("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) {
+                DEBUG_MSG("Deleting %s\n", file.path());
+                strcpy(buffer, file.path());
+                file.close();
+                FSCom.remove(buffer);
+            } else {
+            DEBUG_MSG(" %s (%i Bytes)\n", file.path(), file.size());
+                file.close();
+            }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+            if(del) {
+                DEBUG_MSG("Deleting %s\n", file.name());
+                strcpy(buffer, file.name());
+                file.close();
+                FSCom.remove(buffer);
+            } else {
+                DEBUG_MSG(" %s (%i Bytes)\n", file.name(), file.size());
+                file.close();
+            }
+#else
+            DEBUG_MSG(" %s (%i Bytes)\n", file.name(), file.size());
+            file.close();
+#endif            
         }
-        file.close();
         file = root.openNextFile();
     }
-    file.close();
+#ifdef ARCH_ESP32    
+    if(del) { 
+        DEBUG_MSG("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) { 
+        DEBUG_MSG("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
-    File file = FSCom.open(dirname);
-    if(!file){
-        return;
-    }
-    if(!file.isDirectory()){
-        file.close();
-        FSCom.remove(file.name());
-      //  DEBUG_MSG("Remove FILE  %s\n", file.name());
-        return;
-    }
-
-    file.rewindDirectory();
-    while (true) {
-        File entry = file.openNextFile();
-        if (!entry) {
-          break;
-        }
-        char dirpath[100];   // array to hold the result.
-        strcpy(dirpath, dirname); // copy string one into the result.
-        strcat(dirpath,"/"); // append string two to the result.
-        strcat(dirpath,entry.name()); // append string two to the result.
-        if(entry.isDirectory() && !String(entry.name()).endsWith(".")) {
-            entry.close();
-         //   DEBUG_MSG("Descend DIR  %s\n", dirpath);
-            rmDir(dirpath);
-        } else {
-            entry.close();
-         //   DEBUG_MSG("Remove FILE  %s\n", entry.name());
-            FSCom.remove(entry.name());
-        }
-    }
-    FSCom.rmdir(dirname);
-   // DEBUG_MSG("Remove DIR  %s\n", dirname);
-    file.close();
+#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
 }
 
@@ -76,8 +173,47 @@ void fsInit()
         DEBUG_MSG("ERROR filesystem mount Failed. Formatting...\n");
         assert(0); // FIXME - report failure to phone
     }
-
+#ifdef ARCH_ESP32
+    DEBUG_MSG("Filesystem files (%d/%d Bytes):\n", FSCom.usedBytes(), FSCom.totalBytes());
+#else
     DEBUG_MSG("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)) {
+        DEBUG_MSG("No SD_MMC card detected\n");
+        return ;
+    }
+    uint8_t cardType = SD.cardType();
+    if (cardType == CARD_NONE) {
+        DEBUG_MSG("No SD_MMC card attached\n");
+        return ;
+    }
+    DEBUG_MSG("SD_MMC Card Type: ");
+    if (cardType == CARD_MMC) {
+        DEBUG_MSG("MMC\n");
+    } else if (cardType == CARD_SD) {
+        DEBUG_MSG("SDSC\n");
+    } else if (cardType == CARD_SDHC) {
+        DEBUG_MSG("SDHC\n");
+    } else {
+        DEBUG_MSG("UNKNOWN\n");
+    }
+
+    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
+    DEBUG_MSG("SD Card Size: %lluMB\n", cardSize);
+    DEBUG_MSG("Total space: %llu MB\n", SD.totalBytes() / (1024 * 1024));
+    DEBUG_MSG("Used space: %llu MB\n", SD.usedBytes() / (1024 * 1024));
+#endif
+}
+
+
+

src/FSCommon.h

@@ -4,21 +4,34 @@
 
 // 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)
+#endif
+
+#if defined(ARCH_RP2040)
+// RP2040
+#include "LittleFS.h"
+#define FSCom LittleFS
+#define FSBegin() FSCom.begin()
+#define FILE_O_WRITE "w"
+#define FILE_O_READ "r"
+#endif
+
+#if defined(ARCH_ESP32)
 // ESP32 version
-#include "LITTLEFS.h"
-#define FSCom LITTLEFS
+#include "LittleFS.h"
+#define FSCom LittleFS
 #define FSBegin() FSCom.begin(true)
 #define FILE_O_WRITE "w"
 #define FILE_O_READ "r"
-#else
+#endif
+
+#if defined(ARCH_NRF52)
 // NRF52 version
 #include "InternalFileSystem.h"
 #define FSCom InternalFS
@@ -27,5 +40,8 @@ using namespace Adafruit_LittleFS_Namespace;
 #endif
 
 void fsInit();
-void listDir(const char * dirname, uint8_t levels);
+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

@@ -25,22 +25,6 @@ class GPSStatus : public Status
   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()
     {
@@ -114,6 +98,7 @@ class GPSStatus : public Status
                 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,7 +107,7 @@ 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");
         }
@@ -136,9 +121,9 @@ 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,
+                DEBUG_MSG("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");
             onNewStatus.notifyObservers(this);

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/Power.cpp

@@ -7,12 +7,11 @@
 #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.
@@ -22,20 +21,20 @@ class HasBatteryLevel
     /**
      * Battery state of charge, from 0 to 100 or -1 for unknown
      */
-    virtual int getBattPercentage() { return -1; }
+    virtual int getBatteryPercent() { return -1; }
 
     /**
      * The raw voltage of the battery or NAN if unknown
      */
-    virtual float getBattVoltage() { return NAN; }
+    virtual uint16_t getBattVoltage() { return 0; }
 
     /**
      * return true if there is a battery installed in this unit
      */
     virtual bool isBatteryConnect() { return false; }
 
-    virtual bool isVBUSPlug() { return false; }
-    virtual bool isChargeing() { return false; }
+    virtual bool isVbusIn() { return false; }
+    virtual bool isCharging() { return false; }
 };
 #endif
 
@@ -46,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.
@@ -77,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
@@ -96,7 +95,7 @@ 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
@@ -112,7 +111,18 @@ 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();
+
+#ifdef BATTERY_SENSE_SAMPLES
+//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;
+#else
             uint32_t raw = analogRead(BATTERY_PIN);
+#endif
+
             float scaled;
 #ifndef VBAT_RAW_TO_SCALED
             scaled = 1000.0 * operativeAdcMultiplier * (AREF_VOLTAGE / 1024.0) * raw;
@@ -126,29 +136,42 @@ class AnalogBatteryLevel : public HasBatteryLevel
             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;
 };
@@ -169,11 +192,11 @@ bool Power::analogInit()
     // 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
@@ -197,7 +220,7 @@ bool Power::analogInit()
 
 bool Power::setup()
 {
-    bool found = axp192Init();
+    bool found = axpChipInit();
 
     if (!found) {
         found = analogInit();
@@ -210,11 +233,18 @@ bool Power::setup()
 
 void Power::shutdown()
 {
-#ifdef TBEAM_V10
+    screen->setOn(false);
+#if defined(USE_EINK) && defined(PIN_EINK_EN)
+    digitalWrite(PIN_EINK_EN, LOW); //power off backlight first
+#endif
+
+#ifdef HAS_PMU
     DEBUG_MSG("Shutting down\n");
-    axp.setChgLEDMode(AXP20X_LED_OFF);
-    axp.shutdown();
-#elif NRF52_SERIES
+    if(PMU) {
+        PMU->setChargingLedMode(XPOWERS_CHG_LED_OFF);
+        PMU->shutdown();
+    }
+#elif defined(ARCH_NRF52)
     playBeep();
     ledOff(PIN_LED1);
     ledOff(PIN_LED2);
@@ -234,8 +264,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
@@ -248,15 +278,15 @@ 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);
+            PowerStatus(hasBattery ? OptTrue : OptFalse, batteryLevel->isVbusIn() ? OptTrue : OptFalse,
+                        batteryLevel->isCharging() ? OptTrue : OptFalse, batteryVoltageMv, batteryChargePercent);
         DEBUG_MSG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d\n", powerStatus2.getHasUSB(),
                   powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
         newStatus.notifyObservers(&powerStatus2);
 
 // 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++;
@@ -282,41 +312,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");
-        powerFSM.trigger(EVENT_POWER_DISCONNECTED);
-    }
-    if (axp.isVbusPlugInIRQ()) {
-        DEBUG_MSG("USB plugged In\n");
-        powerFSM.trigger(EVENT_POWER_CONNECTED);
-    }
-    /*
-    Other things we could check if we cared...
+        PMU->getIrqStatus();
 
-    if (axp.isChargingIRQ()) {
-        DEBUG_MSG("Battery start charging\n");
+        if(PMU->isVbusRemoveIrq()){
+            DEBUG_MSG("USB unplugged\n");
+            powerFSM.trigger(EVENT_POWER_DISCONNECTED);
+        }
+
+        if (PMU->isVbusInsertIrq()) {
+            DEBUG_MSG("USB plugged In\n");
+            powerFSM.trigger(EVENT_POWER_CONNECTED);
+        }
+
+        /*
+        Other things we could check if we cared...
+
+        if (PMU->isBatChagerStartIrq()) {
+            DEBUG_MSG("Battery start charging\n");
+        }
+        if (PMU->isBatChagerDoneIrq()) {
+            DEBUG_MSG("Battery fully charged\n");
+        }
+        if (PMU->isBatInsertIrq()) {
+            DEBUG_MSG("Battery inserted\n");
+        }
+        if (PMU->isBatRemoveIrq()) {
+            DEBUG_MSG("Battery removed\n");
+        }
+        */
+        if (PMU->isPekeyLongPressIrq()) {
+            DEBUG_MSG("PEK long button press\n");
+            screen->setOn(false);
+        }
+
+        PMU->clearIrqStatus();
     }
-    if (axp.isChargingDoneIRQ()) {
-        DEBUG_MSG("Battery fully charged\n");
-    }
-    if (axp.isBattPlugInIRQ()) {
-        DEBUG_MSG("Battery inserted\n");
-    }
-    if (axp.isBattRemoveIRQ()) {
-        DEBUG_MSG("Battery removed\n");
-    }
-    if (axp.isPEKShortPressIRQ()) {
-        DEBUG_MSG("PEK short button press\n");
-    }
-    */
-    axp.clearIRQ();
 #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;
 }
@@ -329,128 +365,238 @@ 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
-
-            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;
-            }
-
-#if 0
-
-      // 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
+    // Use macro to distinguish which wire is used by PMU
+#ifdef PMU_USE_WIRE1
+        w = &Wire1;
+#else
+        w = &Wire;
 #endif
-            axp.debugCharging();
 
-#ifdef PMU_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
-            // 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);
-
-            axp.clearIRQ();
-#endif
-            readPowerStatus();
+    /**
+     * 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()) {
+            DEBUG_MSG("Warning: Failed to find AXP2101 power management\n");
+            delete PMU;
+            PMU = NULL;
         } else {
-            DEBUG_MSG("AXP192 Begin FAIL\n");
+            DEBUG_MSG("AXP2101 PMU init succeeded, using AXP2101 PMU\n");
         }
-    } else {
-        DEBUG_MSG("AXP192 not found\n");
     }
 
-    return axp192_found;
+    if (!PMU) {
+        PMU = new XPowersAXP192(*w);
+        if (!PMU->init()) {
+            DEBUG_MSG("Warning: Failed to find AXP192 power management\n");
+            delete PMU;
+            PMU = NULL;
+        } else {
+            DEBUG_MSG("AXP192 PMU init succeeded, using AXP192 PMU\n");
+        }
+    }
+
+    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
+        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);
+
+    } 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);
+
+    }
+    
+
+    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();
+
+    DEBUG_MSG("=======================================================================\n");
+    if (PMU->isChannelAvailable(XPOWERS_DCDC1)) {
+        DEBUG_MSG("DC1  : %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC1)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC1));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_DCDC2)) {
+        DEBUG_MSG("DC2  : %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC2)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC2));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_DCDC3)) {
+        DEBUG_MSG("DC3  : %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC3)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC3));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_DCDC4)) {
+        DEBUG_MSG("DC4  : %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC4)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC4));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_LDO2)) {
+        DEBUG_MSG("LDO2 : %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_LDO2)   ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_LDO2));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_LDO3)) {
+        DEBUG_MSG("LDO3 : %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_LDO3)   ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_LDO3));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO1)) {
+        DEBUG_MSG("ALDO1: %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO1)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO1));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO2)) {
+        DEBUG_MSG("ALDO2: %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO2)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO2));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO3)) {
+        DEBUG_MSG("ALDO3: %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO3)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO3));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_ALDO4)) {
+        DEBUG_MSG("ALDO4: %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO4)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO4));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_BLDO1)) {
+        DEBUG_MSG("BLDO1: %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_BLDO1)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_BLDO1));
+    }
+    if (PMU->isChannelAvailable(XPOWERS_BLDO2)) {
+        DEBUG_MSG("BLDO2: %s   Voltage:%u mV \n",  PMU->isPowerChannelEnable(XPOWERS_BLDO2)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_BLDO2));
+    }
+    DEBUG_MSG("=======================================================================\n");
+
+
+    //Set up the charging voltage, AXP2101/AXP192 4.2V gear is the same
+    // XPOWERS_AXP192_CHG_VOL_4V2 = XPOWERS_AXP2101_CHG_VOL_4V2
+    PMU->setChargeTargetVoltage(XPOWERS_AXP192_CHG_VOL_4V2);
+
+    // Set PMU shutdown voltage at 2.6V to maximize battery utilization
+    PMU->setSysPowerDownVoltage(2600);
+
+
+
+#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);
+
+        // 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 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*/
+
+            readPowerStatus();
+
+    pmu_found = true;
+
+    return pmu_found;
+
 #else
     return false;
 #endif

src/PowerFSM.cpp

@@ -12,11 +12,11 @@
 static bool isPowered()
 {
     // Circumvent the battery sensing logic and assumes constant power if no battery pin or power mgmt IC
-    #if !defined(BATTERY_PIN) && !defined(AXP192_SLAVE_ADDRESS)
+    #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
@@ -34,7 +34,7 @@ static void sdsEnter()
 {
     DEBUG_MSG("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(config.power.sds_secs * 1000);
 }
 
 extern Power *power;
@@ -51,8 +51,7 @@ 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);
+    DEBUG_MSG("lsEnter begin, ls_secs=%u\n", config.power.ls_secs);
     screen->setOn(false);
     secsSlept = 0; // How long have we been sleeping this time
 
@@ -63,10 +62,10 @@ static void lsIdle()
 {
     // DEBUG_MSG("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;
 
@@ -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;
@@ -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);
+    DEBUG_MSG("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");
@@ -333,45 +329,26 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateDARK, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
     powerFSM.add_transition(&stateON, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
 
-    powerFSM.add_timed_transition(&stateON, &stateDARK,
-                                  config.display.screen_on_secs ? config.display.screen_on_secs
-                                                                               : 60 * 1000 * 10,
-                                  NULL, "Screen-on timeout");
+    powerFSM.add_timed_transition(&stateON, &stateDARK, getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL, "Screen-on timeout");
 
     // On most boards we use light-sleep to be our main state, but on NRF52 we just stay in DARK
     State *lowPowerState = &stateLS;
 
-    uint32_t meshSds = 0;
-
-#ifndef NRF52_SERIES
+#ifdef ARCH_ESP32
     // We never enter light-sleep or NB states on NRF52 (because the CPU uses so little power normally)
 
-    // See: https://github.com/meshtastic/Meshtastic-device/issues/1071
+    // See: https://github.com/meshtastic/firmware/issues/1071
     if (isRouter || config.power.is_power_saving) {
-        powerFSM.add_timed_transition(&stateNB, &stateLS,
-                                      config.power.min_wake_secs ? config.power.min_wake_secs
-                                                                                : 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;
+        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 {
-
-        meshSds = UINT32_MAX;
-    }
-
-#else
+#elif defined (ARCH_NRF52)
     lowPowerState = &stateDARK;
-    meshSds = UINT32_MAX; // Workaround for now: Don't go into deep sleep on the RAK4631
 #endif
 
-    if (meshSds != UINT32_MAX)
-        powerFSM.add_timed_transition(lowPowerState, &stateSDS, meshSds * 1000, NULL, "mesh timeout");
+    if (config.power.sds_secs != UINT32_MAX)
+        powerFSM.add_timed_transition(lowPowerState, &stateSDS, config.power.sds_secs * 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/RedirectablePrint.cpp

@@ -1,6 +1,7 @@
 #include "configuration.h"
 #include "RedirectablePrint.h"
 #include "RTC.h"
+#include "NodeDB.h"
 #include "concurrency/OSThread.h"
 // #include "wifi/WiFiServerAPI.h"
 #include <assert.h>
@@ -30,7 +31,9 @@ size_t RedirectablePrint::write(uint8_t c)
     // optionally send chars to TCP also
     //WiFiServerPort::debugOut(c);
 
-    dest->write(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,19 +41,17 @@ 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);
@@ -107,4 +108,4 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
     }
 
     return r;
-}
+}

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;
 

src/SerialConsole.cpp

@@ -20,6 +20,9 @@ void consolePrintf(const char *format, ...)
     va_start(arg, format);
     console->vprintf(format, arg);
     va_end(arg);
+#ifdef ARCH_ESP32
+    console->flush();
+#endif
 }
 
 SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
@@ -30,7 +33,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
+#ifdef ARCH_NRF52
     time_t timeout = millis();
     while (!Port) {
         if ((millis() - timeout) < 5000) {
@@ -57,10 +60,15 @@ bool SerialConsole::checkIsConnected()
  */
 bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
 {
-    // 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;
+    // 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);
-}
+        return StreamAPI::handleToRadio(buf, len);
+    }else{
+        return false;
+    }
+}

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) {
-  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);
+#ifdef PIN_BUZZER
+  if (!config.device.buzzer_gpio)
+    config.device.buzzer_gpio = PIN_BUZZER;
 #endif
-    // to distinguish the notes, set a minimum time between them.
-    delay(1.3 * tone_duration.duration_ms);
+  if (config.device.buzzer_gpio) {
+    for (int i = 0; i < size; i++) {
+      const auto &tone_duration = tone_durations[i];
+      tone(config.device.buzzer_gpio, tone_duration.frequency_khz, tone_duration.duration_ms);
+      // to distinguish the notes, set a minimum time between them.
+      delay(1.3 * tone_duration.duration_ms);
+    }
   }
 }
 
-#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/configuration.h

@@ -62,79 +62,15 @@ 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
+// Nop definition for these attributes that are specific to ESP32
+#ifndef EXT_RAM_ATTR
+    #define EXT_RAM_ATTR
 #endif
-
-#ifdef PIN_BUTTON2
-#define BUTTON_PIN_ALT PIN_BUTTON2
+#ifndef IRAM_ATTR
+    #define IRAM_ATTR
 #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
-#define EXT_RAM_ATTR
-#define IRAM_ATTR
-#define RTC_DATA_ATTR
+#ifndef RTC_DATA_ATTR
+    #define RTC_DATA_ATTR
 #endif
 
 // -----------------------------------------------------------------------------
@@ -145,7 +81,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define DISABLE_NTP
 
 // Disable the welcome screen and allow 
-// #define DISABLE_WELCOME_UNSET
+//#define DISABLE_WELCOME_UNSET
 
 // -----------------------------------------------------------------------------
 // OLED & Input
@@ -158,19 +94,12 @@ 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
 // -----------------------------------------------------------------------------
@@ -179,6 +108,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MCP9808_ADDR 0x18
 #define INA_ADDR 0x40
 #define INA_ADDR_ALTERNATE 0x41
+#define QMC6310_ADDR 0x1C
+#define QMI8658_ADDR 0x6B
+#define QMC5883L_ADDR 0x1E
+#define SHTC3_ADDR 0x70
+#define LPS22HB_ADDR 0x5C
+#define LPS22HB_ADDR_ALT 0x5D
+
+// -----------------------------------------------------------------------------
+// Security
+// -----------------------------------------------------------------------------
+
+#define ATECC608B_ADDR 0x35
 
 // -----------------------------------------------------------------------------
 // GPS
@@ -190,109 +131,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/i2cScan.h

@@ -1,156 +0,0 @@
-#include "../configuration.h"
-#include "../main.h"
-#include <Wire.h>
-#include "mesh/generated/telemetry.pb.h"
-
-#ifndef NO_WIRE
-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);
-    DEBUG_MSG("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 == 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;
-    uint16_t registerValue = 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?
-                registerValue = getRegisterValue(addr, 0x04, 1);
-                if (registerValue == 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
-        if (addr == BME_ADDR || addr == BME_ADDR_ALTERNATE) {
-            registerValue = getRegisterValue(addr, 0xD0, 1); // GET_ID
-            if (registerValue == 0x61) {
-                DEBUG_MSG("BME-680 sensor found at address 0x%x\n", (uint8_t)addr);
-                nodeTelemetrySensorsMap[TelemetrySensorType_BME680] = addr;
-            } else if (registerValue == 0x60) {
-                DEBUG_MSG("BME-280 sensor found at address 0x%x\n", (uint8_t)addr);
-                nodeTelemetrySensorsMap[TelemetrySensorType_BME280] = addr;
-            }
-        }
-        if (addr == INA_ADDR || addr == INA_ADDR_ALTERNATE) {
-            registerValue = getRegisterValue(addr, 0xFE, 2);
-            DEBUG_MSG("Register MFG_UID: 0x%x\n", registerValue);
-            if (registerValue == 0x5449) {
-                DEBUG_MSG("INA260 sensor found at address 0x%x\n", (uint8_t)addr);
-                nodeTelemetrySensorsMap[TelemetrySensorType_INA260] = addr;
-            } else { // Assume INA219 if INA260 ID is not found
-                DEBUG_MSG("INA219 sensor found at address 0x%x\n", (uint8_t)addr);
-                nodeTelemetrySensorsMap[TelemetrySensorType_INA219] = addr;
-            }
-        }
-        if (addr == MCP9808_ADDR) {
-            nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808] = addr;
-            DEBUG_MSG("MCP9808 sensor found at address 0x%x\n", (uint8_t)addr);
-        }
-        } 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/i2cScan.h

@@ -0,0 +1,228 @@
+#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);
+
+    DEBUG_MSG("ATECC608B Serial Number: ");
+    for (int i = 0 ; i < 9 ; i++) {
+        DEBUG_MSG("%02x",atecc.serialNumber[i]);
+    }
+
+    DEBUG_MSG(", Rev Number: ");
+    for (int i = 0 ; i < 4 ; i++) {
+        DEBUG_MSG("%02x",atecc.revisionNumber[i]);
+    }
+    DEBUG_MSG("\n");
+
+    DEBUG_MSG("ATECC608B Config %s",atecc.configLockStatus ? "Locked" : "Unlocked");
+    DEBUG_MSG(", Data %s",atecc.dataOTPLockStatus ? "Locked" : "Unlocked");
+    DEBUG_MSG(", Slot 0 %s\n",atecc.slot0LockStatus ? "Locked" : "Unlocked");
+
+    if (atecc.configLockStatus && atecc.dataOTPLockStatus && atecc.slot0LockStatus) {
+        if (atecc.generatePublicKey() == false) {
+            DEBUG_MSG("ATECC608B Error generating public key\n");
+        } else {
+            DEBUG_MSG("ATECC608B Public Key: ");
+            for (int i = 0 ; i < 64 ; i++) {
+                DEBUG_MSG("%02x",atecc.publicKey64Bytes[i]);
+            }
+            DEBUG_MSG("\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);
+    DEBUG_MSG("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));
+    DEBUG_MSG("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) {
+            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");
+                }
+            }
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+            if (addr == ATECC608B_ADDR) {
+                keystore_found = addr;
+                if (atecc.begin(keystore_found) == true) {
+                    DEBUG_MSG("ATECC608B initialized\n");
+                } else {
+                    DEBUG_MSG("ATECC608B initialization failed\n");
+                }
+                printATECCInfo();
+            }
+#endif
+#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?
+                registerValue = getRegisterValue(addr, 0x04, 1);
+                if (registerValue == 0x02) { // KEYPAD_VERSION
+                    DEBUG_MSG("RAK14004 found\n");
+                    kb_model = 0x02;
+                } else {
+                    DEBUG_MSG("m5 cardKB found\n");
+                    kb_model = 0x00;
+                }
+            }
+            if (addr == ST7567_ADDRESS) {
+                screen_found = addr;
+                DEBUG_MSG("st7567 display found\n");
+            }
+#ifdef HAS_PMU
+            if (addr == XPOWERS_AXP192_AXP2101_ADDRESS) {
+                pmu_found = true;
+                DEBUG_MSG("axp192/axp2101 PMU found\n");
+            }
+#endif
+            if (addr == BME_ADDR || addr == BME_ADDR_ALTERNATE) {
+                registerValue = getRegisterValue(addr, 0xD0, 1); // GET_ID
+                if (registerValue == 0x61) {
+                    DEBUG_MSG("BME-680 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_BME680] = addr;
+                } else if (registerValue == 0x60) {
+                    DEBUG_MSG("BME-280 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_BME280] = addr;
+                } else {
+                    DEBUG_MSG("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);
+                DEBUG_MSG("Register MFG_UID: 0x%x\n", registerValue);
+                if (registerValue == 0x5449) {
+                    DEBUG_MSG("INA260 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_INA260] = addr;
+                } else { // Assume INA219 if INA260 ID is not found
+                    DEBUG_MSG("INA219 sensor found at address 0x%x\n", (uint8_t)addr);
+                    nodeTelemetrySensorsMap[TelemetrySensorType_INA219] = addr;
+                }
+            }
+            if (addr == MCP9808_ADDR) {
+                nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808] = addr;
+                DEBUG_MSG("MCP9808 sensor found\n");
+            }
+            if (addr == SHTC3_ADDR) {
+                DEBUG_MSG("SHTC3 sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_SHTC3] = addr;
+            }
+            if (addr == LPS22HB_ADDR || addr == LPS22HB_ADDR_ALT) {
+                DEBUG_MSG("LPS22HB sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_LPS22] = addr;
+            }
+
+            // High rate sensors, will be processed internally
+            if (addr == QMC6310_ADDR) {
+                DEBUG_MSG("QMC6310 Highrate 3-Axis magnetic sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_QMC6310] = addr;
+            }
+            if (addr == QMI8658_ADDR) {
+                DEBUG_MSG("QMI8658 Highrate 6-Axis inertial measurement sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_QMI8658] = addr;
+            }
+            if (addr == QMC5883L_ADDR) {
+                DEBUG_MSG("QMC5883L Highrate 3-Axis magnetic sensor found\n");
+                nodeTelemetrySensorsMap[TelemetrySensorType_QMC5883L] = addr;
+            }
+        } 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() {}
+#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

@@ -59,98 +59,204 @@ 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);
-        // Initialize the L76K Chip, use GPS + GLONASS
-        _serial_gps->write("$PCAS04,5*1C\r\n");
-        delay(250);
-        // only ask for RMC and GGA
-        _serial_gps->write("$PCAS03,1,0,0,0,1,0,0,0,0,0,,,0,0*02\r\n");
-        delay(250);
-        // 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);
-        // 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");
-            return true;
-        }  
 
-        // 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");
-            return true;
+        /*
+        * 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);
+            // only ask for RMC and GGA
+            _serial_gps->write("$PCAS03,1,0,0,0,1,0,0,0,0,0,,,0,0*02\r\n");
+            delay(250);
+            // Switch to Vehicle Mode, since SoftRF enables Aviation < 2g
+            _serial_gps->write("$PCAS11,3*1E\r\n");
+            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");
+                    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");
+                return true;
+            }
+
+            // disable GSA
+            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");
+                return true;
+            }
+
+            // disable GSV
+            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");
+                return true;
+            }
+
+            // disable VTG
+            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");
+                return true;
+            }
+
+            // enable RMC
+            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");
+                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");
+            }
         }
-
-        // disable GSA
-        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");
-            return true;
-        }
-
-        // disable GSV
-        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");
-            return true;
-        }
-
-        // disable VTG
-        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");
-            return true;
-        }
-
-        // enable RMC
-        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");
-            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
     }
 
     return true;
@@ -271,16 +377,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 +385,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,7 +402,7 @@ 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());
+        DEBUG_MSG("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);
@@ -325,14 +416,14 @@ int32_t GPS::runOnce()
         // if we have received valid NMEA claim we are connected
         setConnected();
     } else {
-#ifdef GPS_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");
-            devicestate.did_gps_reset = false;
-            nodeDB.saveToDisk();
+        if(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");
+                devicestate.did_gps_reset = false;
+                nodeDB.saveDeviceStateToDisk();
+            }
         }
-#endif
     }
 
     // If we are overdue for an update, turn on the GPS and at least publish the current status
@@ -432,17 +523,123 @@ int GPS::prepareDeepSleep(void *unused)
     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")) {
+                    DEBUG_MSG("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)) {
+        DEBUG_MSG("Warning: 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;
+        }
+
+        DEBUG_MSG("Module Info : \n");
+        DEBUG_MSG("Soft version: %s\n",info.swVersion);
+        DEBUG_MSG("Hard version: %s\n",info.hwVersion);
+        DEBUG_MSG("Extensions:%d\n",info.extensionNo);
+        for (int i = 0; i < info.extensionNo; i++) {
+            DEBUG_MSG("  %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]));
+                DEBUG_MSG("GetModel:%s\n",(char *)buffer);
+            }
+        }
+    }
+
+    if (strlen((char*)buffer)) {
+        DEBUG_MSG("UBlox GNSS init succeeded, using UBlox %s GNSS Module\n" , buffer);
+    }else{
+        DEBUG_MSG("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");
 #else

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);
 
@@ -146,6 +160,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;
 }
 
@@ -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);
+    // DEBUG_MSG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
 #endif
 
     // check if GPS has an acceptable lock
@@ -155,13 +162,13 @@ bool NMEAGPS::lookForLocation()
         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());
+    // DEBUG_MSG("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()) {
@@ -210,13 +217,10 @@ bool NMEAGPS::lookForLocation()
         }
     }
 
-/*
-    // 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;
 }
 

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

@@ -44,11 +44,15 @@ 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;
@@ -110,17 +114,21 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
 #elif defined(PCF8563_RTC)
         if(rtc_found == PCF8563_RTC) {
             PCF8563_Class rtc;
-            rtc.begin();
+#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);
+            rtc.setDateTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 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);
         }
-#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
 

src/gps/RTC.h

@@ -16,7 +16,7 @@ enum RTCQuality {
     RTCQualityFromNet = 2,
 
     /// Our time is based on NTP
-    RTCQualityNTP= 3,
+    RTCQualityNTP = 3,
 
     /// Our time is based on our own GPS
     RTCQualityGPS = 4

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,9 +46,9 @@ 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
     //setGeometry(GEOMETRY_RAWMODE, 300, 400);
 
@@ -110,14 +110,17 @@ bool EInkDisplay::forceDisplay(uint32_t msecLimit)
         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();
@@ -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;
     }      

src/graphics/Screen.cpp

@@ -20,7 +20,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 */
 #include "configuration.h"
-#ifndef NO_SCREEN
+#if HAS_SCREEN
 #include <OLEDDisplay.h>
 
 #include "GPS.h"
@@ -39,21 +39,22 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "target_specific.h"
 #include "utils.h"
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
 #include "esp_task_wdt.h"
 #include "mesh/http/WiFiAPClient.h"
 #endif
 
-using namespace meshtastic; /** @todo remove */
+#ifdef OLED_RU
+#include "fonts/OLEDDisplayFontsRU.h"
+#endif
 
-extern bool loadProto(const char *filename, size_t protoSize, size_t objSize, const pb_msgdesc_t *fields, void *dest_struct);
+using namespace meshtastic; /** @todo remove */
 
 namespace graphics
 {
 
 // This means the *visible* area (sh1106 can address 132, but shows 128 for example)
 #define IDLE_FRAMERATE 1 // in fps
-#define COMPASS_DIAM 44
 
 // DEBUG
 #define NUM_EXTRA_FRAMES 3 // text message and debug frame
@@ -65,6 +66,8 @@ static FrameCallback normalFrames[MAX_NUM_NODES + NUM_EXTRA_FRAMES];
 static uint32_t targetFramerate = IDLE_FRAMERATE;
 static char btPIN[16] = "888888";
 
+uint32_t logo_timeout = 5000; // 4 seconds for EACH logo
+    
 // This image definition is here instead of images.h because it's modified dynamically by the drawBattery function
 uint8_t imgBattery[16] = {0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xE7, 0x3C};
 
@@ -81,10 +84,6 @@ static char ourId[5];
 // GeoCoord object for the screen
 GeoCoord geoCoord;
 
-// OEM Config File
-static const char *oemConfigFile = "/prefs/oem.proto";
-OEMStore oemStore;
-
 #ifdef SHOW_REDRAWS
 static bool heartbeat = false;
 #endif
@@ -94,13 +93,17 @@ static uint16_t displayWidth, displayHeight;
 #define SCREEN_WIDTH displayWidth
 #define SCREEN_HEIGHT displayHeight
 
-#if defined(HAS_EINK) || defined(ILI9341_DRIVER)
+#if defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS)
 // The screen is bigger so use bigger fonts
 #define FONT_SMALL ArialMT_Plain_16
 #define FONT_MEDIUM ArialMT_Plain_24
 #define FONT_LARGE ArialMT_Plain_24
 #else
+#ifdef OLED_RU
+#define FONT_SMALL ArialMT_Plain_10_RU
+#else
 #define FONT_SMALL ArialMT_Plain_10
+#endif
 #define FONT_MEDIUM ArialMT_Plain_16
 #define FONT_LARGE ArialMT_Plain_24
 #endif
@@ -109,12 +112,10 @@ static uint16_t displayWidth, displayHeight;
 
 #define FONT_HEIGHT_SMALL fontHeight(FONT_SMALL)
 #define FONT_HEIGHT_MEDIUM fontHeight(FONT_MEDIUM)
+#define FONT_HEIGHT_LARGE fontHeight(FONT_LARGE)
 
 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)
 
-#ifndef SCREEN_TRANSITION_MSECS
-#define SCREEN_TRANSITION_MSECS 300
-#endif
 
 /**
  * Draw the icon with extra info printed around the corners
@@ -212,7 +213,7 @@ static void drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     display->setFont(FONT_SMALL);
     display->drawString(64 + x, y, "Creating SSL certificate");
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
     yield();
     esp_task_wdt_reset();
 #endif
@@ -228,38 +229,29 @@ static void drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 // Used when booting without a region set
 static void drawWelcomeScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
-
+    display->setFont(FONT_SMALL);
+    display->setTextAlignment(TEXT_ALIGN_CENTER);
+    display->drawString(64 + x, y, "//\\ E S H T /\\ S T / C");
+    display->drawString(64 + x, y + FONT_HEIGHT_SMALL, getDeviceName());
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    
     if ((millis() / 10000) % 2) {
-        display->setFont(FONT_SMALL);
-
-        display->setTextAlignment(TEXT_ALIGN_CENTER);
-        display->drawString(64 + x, y, "//\\ E S H T /\\ S T / C");
-
-        display->setTextAlignment(TEXT_ALIGN_LEFT);
-
         display->drawString(x, y + FONT_HEIGHT_SMALL * 2 - 3, "Set the region using the");
         display->drawString(x, y + FONT_HEIGHT_SMALL * 3 - 3, "Meshtastic Android, iOS,");
         display->drawString(x, y + FONT_HEIGHT_SMALL * 4 - 3, "Flasher or CLI client.");
     } else {
-        display->setFont(FONT_SMALL);
-
-        display->setTextAlignment(TEXT_ALIGN_CENTER);
-        display->drawString(64 + x, y, "//\\ E S H T /\\ S T / C");
-
-        display->setTextAlignment(TEXT_ALIGN_LEFT);
-
         display->drawString(x, y + FONT_HEIGHT_SMALL * 2 - 3, "Visit meshtastic.org");
         display->drawString(x, y + FONT_HEIGHT_SMALL * 3 - 3, "for more information.");
         display->drawString(x, y + FONT_HEIGHT_SMALL * 4 - 3, "");
     }
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
     yield();
     esp_task_wdt_reset();
 #endif
 }
 
-#ifdef HAS_EINK
+#ifdef USE_EINK
 /// Used on eink displays while in deep sleep
 static void drawSleepScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -291,22 +283,27 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
 
 static void drawFrameBluetooth(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
+    int x_offset = display->width() / 2;
+    int y_offset = display->height() == 64 ? 0 : 32;
     display->setTextAlignment(TEXT_ALIGN_CENTER);
     display->setFont(FONT_MEDIUM);
-    display->drawString(64 + x, y, "Bluetooth");
+    display->drawString(x_offset + x, y_offset + y, "Bluetooth");
 
     display->setFont(FONT_SMALL);
-    display->drawString(64 + x, FONT_HEIGHT_SMALL + y + 2, "Enter this code");
+    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM -4   : y_offset + FONT_HEIGHT_MEDIUM + 5;
+    display->drawString(x_offset + x, y_offset + y, "Enter this code");
 
     display->setFont(FONT_LARGE);
-    display->drawString(64 + x, 26 + y, btPIN);
+    String displayPin(btPIN);
+    String pin = displayPin.substring(0, 3) + " " + displayPin.substring(3, 6);
+    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
+    display->drawString(x_offset + x, y_offset + y, pin);
 
     display->setFont(FONT_SMALL);
-    char buf[30];
-    const char *name = "Name: ";
-    strcpy(buf, name);
-    strcat(buf, getDeviceName());
-    display->drawString(64 + x, 48 + y, buf);
+    String deviceName =  "Name: ";
+    deviceName.concat(getDeviceName());
+    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
+    display->drawString(x_offset + x, y_offset + y, deviceName);
 }
 
 static void drawFrameShutdown(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -317,6 +314,14 @@ static void drawFrameShutdown(OLEDDisplay *display, OLEDDisplayUiState *state, i
     display->drawString(64 + x, 26 + y, "Shutting down...");
 }
 
+static void drawFrameReboot(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    display->setTextAlignment(TEXT_ALIGN_CENTER);
+
+    display->setFont(FONT_MEDIUM);
+    display->drawString(64 + x, 26 + y, "Rebooting...");
+}
+
 static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     display->setTextAlignment(TEXT_ALIGN_CENTER);
@@ -329,9 +334,6 @@ static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, i
     } else {
         display->drawString(64 + x, FONT_HEIGHT_SMALL + y + 2, "Please wait . .  ");
     }
-
-    // display->setFont(FONT_LARGE);
-    // display->drawString(64 + x, 26 + y, btPIN);
 }
 
 /// Draw the last text message we received
@@ -516,6 +518,8 @@ static void drawGPSAltitude(OLEDDisplay *display, int16_t x, int16_t y, const GP
     } else {
         geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));
         displayLine = "Altitude: " + String(geoCoord.getAltitude()) + "m";
+        if (config.display.units == Config_DisplayConfig_DisplayUnits_IMPERIAL)
+            displayLine = "Altitude: " + String(geoCoord.getAltitude() * METERS_TO_FEET) + "ft";
         display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
     }
 }
@@ -534,21 +538,22 @@ static void drawGPScoordinates(OLEDDisplay *display, int16_t x, int16_t y, const
         display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
     } else {
 
-        if (gpsFormat != Config_DisplayConfig_GpsCoordinateFormat_GpsFormatDMS) {
+        geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));
+
+        if (gpsFormat != Config_DisplayConfig_GpsCoordinateFormat_DMS) {
             char coordinateLine[22];
-            geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));
-            if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_GpsFormatDec) { // Decimal Degrees
+            if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_DEC) { // Decimal Degrees
                 sprintf(coordinateLine, "%f %f", geoCoord.getLatitude() * 1e-7, geoCoord.getLongitude() * 1e-7);
-            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_GpsFormatUTM) { // Universal Transverse Mercator
+            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_UTM) { // Universal Transverse Mercator
                 sprintf(coordinateLine, "%2i%1c %06u %07u", geoCoord.getUTMZone(), geoCoord.getUTMBand(),
                         geoCoord.getUTMEasting(), geoCoord.getUTMNorthing());
-            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_GpsFormatMGRS) { // Military Grid Reference System
+            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_MGRS) { // Military Grid Reference System
                 sprintf(coordinateLine, "%2i%1c %1c%1c %05u %05u", geoCoord.getMGRSZone(), geoCoord.getMGRSBand(),
                         geoCoord.getMGRSEast100k(), geoCoord.getMGRSNorth100k(), geoCoord.getMGRSEasting(),
                         geoCoord.getMGRSNorthing());
-            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_GpsFormatOLC) { // Open Location Code
+            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_OLC) { // Open Location Code
                 geoCoord.getOLCCode(coordinateLine);
-            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_GpsFormatOSGR) { // Ordnance Survey Grid Reference
+            } else if (gpsFormat == Config_DisplayConfig_GpsCoordinateFormat_OSGR) { // Ordnance Survey Grid Reference
                 if (geoCoord.getOSGRE100k() == 'I' || geoCoord.getOSGRN100k() == 'I') // OSGR is only valid around the UK region
                     sprintf(coordinateLine, "%s", "Out of Boundary");
                 else
@@ -595,7 +600,7 @@ class Point
     void rotate(float radian)
     {
         float cos = cosf(radian), sin = sinf(radian);
-        float rx = x * cos - y * sin, ry = x * sin + y * cos;
+        float rx = x * cos + y * sin, ry = -x * sin + y * cos;
 
         x = rx;
         y = ry;
@@ -609,8 +614,10 @@ class Point
 
     void scale(float f)
     {
+        //We use -f here to counter the flip that happens
+        //on the y axis when drawing and rotating on screen
         x *= f;
-        y *= f;
+        y *= -f;
     }
 };
 
@@ -658,6 +665,26 @@ static bool hasPosition(NodeInfo *n)
     return n->has_position && (n->position.latitude_i != 0 || n->position.longitude_i != 0);
 }
 
+static uint16_t getCompassDiam(OLEDDisplay *display)
+{
+    uint16_t diam = 0;
+    // get the smaller of the 2 dimensions and subtract 20
+    if(display->getWidth() > display->getHeight()) {
+        diam = display->getHeight();
+        // if 2/3 of the other size would be smaller, use that
+        if (diam > (display->getWidth() * 2 / 3)) {
+            diam = display->getWidth() * 2 / 3;
+        }
+    } else {
+        diam = display->getWidth();
+        if (diam > (display->getHeight() * 2 / 3)) {
+            diam = display->getHeight() * 2 / 3;
+        }
+    }
+    
+    return diam - 20;
+};
+
 /// We will skip one node - the one for us, so we just blindly loop over all
 /// nodes
 static size_t nodeIndex;
@@ -674,7 +701,7 @@ static void drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t comp
 
     for (int i = 0; i < 4; i++) {
         arrowPoints[i]->rotate(headingRadian);
-        arrowPoints[i]->scale(COMPASS_DIAM * 0.6);
+        arrowPoints[i]->scale(getCompassDiam(display) * 0.6);
         arrowPoints[i]->translate(compassX, compassY);
     }
     drawLine(display, tip, tail);
@@ -682,16 +709,21 @@ static void drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t comp
     drawLine(display, rightArrow, tip);
 }
 
-// Draw the compass heading
-static void drawCompassHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading)
+// Draw north
+static void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading)
 {
-    Point N1(-0.04f, -0.65f), N2(0.04f, -0.65f);
-    Point N3(-0.04f, -0.55f), N4(0.04f, -0.55f);
+    //If north is supposed to be at the top of the compass we want rotation to be +0
+    if(config.display.compass_north_top)
+        myHeading = -0;
+    
+    Point N1(-0.04f, 0.65f), N2(0.04f, 0.65f);
+    Point N3(-0.04f, 0.55f), N4(0.04f, 0.55f);
     Point *rosePoints[] = {&N1, &N2, &N3, &N4};
 
     for (int i = 0; i < 4; i++) {
-        rosePoints[i]->rotate(myHeading);
-        rosePoints[i]->scale(-1 * COMPASS_DIAM);
+        // North on compass will be negative of heading
+        rosePoints[i]->rotate(-myHeading);
+        rosePoints[i]->scale(getCompassDiam(display));
         rosePoints[i]->translate(compassX, compassY);
     }
     drawLine(display, N1, N3);
@@ -756,13 +788,13 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
     const char *fields[] = {username, distStr, signalStr, lastStr, NULL};
 
     // coordinates for the center of the compass/circle
-    int16_t compassX = x + SCREEN_WIDTH - COMPASS_DIAM / 2 - 5, compassY = y + SCREEN_HEIGHT / 2;
+    int16_t compassX = x + SCREEN_WIDTH - getCompassDiam(display) / 2 - 5, compassY = y + SCREEN_HEIGHT / 2;
     bool hasNodeHeading = false;
 
     if (ourNode && hasPosition(ourNode)) {
         Position &op = ourNode->position;
         float myHeading = estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
-        drawCompassHeading(display, compassX, compassY, myHeading);
+        drawCompassNorth(display, compassX, compassY, myHeading);
 
         if (hasPosition(node)) {
             // display direction toward node
@@ -770,17 +802,26 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
             Position &p = node->position;
             float d =
                 GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
-            if (d < 2000)
-                snprintf(distStr, sizeof(distStr), "%.0f m", d);
-            else
-                snprintf(distStr, sizeof(distStr), "%.1f km", d / 1000);
 
-            // FIXME, also keep the guess at the operators heading and add/substract
-            // it.  currently we don't do this and instead draw north up only.
+            if (config.display.units == Config_DisplayConfig_DisplayUnits_IMPERIAL) {
+                if (d < (2 * MILES_TO_FEET))
+                    snprintf(distStr, sizeof(distStr), "%.0f ft", d * METERS_TO_FEET);
+                else
+                    snprintf(distStr, sizeof(distStr), "%.1f mi", d * METERS_TO_FEET / MILES_TO_FEET);
+            } else {
+                if (d < 2000)
+                    snprintf(distStr, sizeof(distStr), "%.0f m", d);
+                else
+                    snprintf(distStr, sizeof(distStr), "%.1f km", d / 1000);
+            }
+
             float bearingToOther =
-                GeoCoord::bearing(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
-            float headingRadian = bearingToOther - myHeading;
-            drawNodeHeading(display, compassX, compassY, headingRadian);
+                GeoCoord::bearing(DegD(op.latitude_i), DegD(op.longitude_i), DegD(p.latitude_i), DegD(p.longitude_i));
+            // If the top of the compass is a static north then bearingToOther can be drawn on the compass directly
+            // If the top of the compass is not a static north we need adjust bearingToOther based on heading
+            if(!config.display.compass_north_top)
+                bearingToOther -= myHeading;
+            drawNodeHeading(display, compassX, compassY, bearingToOther);
         }
     }
     if (!hasNodeHeading)
@@ -788,7 +829,7 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
         // Debug info for gps lock errors
         // DEBUG_MSG("ourNode %d, ourPos %d, theirPos %d\n", !!ourNode, ourNode && hasPosition(ourNode), hasPosition(node));
         display->drawString(compassX - FONT_HEIGHT_SMALL / 4, compassY - FONT_HEIGHT_SMALL / 2, "?");
-    display->drawCircle(compassX, compassY, COMPASS_DIAM / 2);
+    display->drawCircle(compassX, compassY, getCompassDiam(display) / 2);
 
     // Must be after distStr is populated
     drawColumns(display, x, y, fields);
@@ -843,7 +884,7 @@ Screen::Screen(uint8_t address, int sda, int scl) : OSThread("Screen"), cmdQueue
  */
 void Screen::doDeepSleep()
 {
-#ifdef HAS_EINK
+#ifdef USE_EINK
     static FrameCallback sleepFrames[] = {drawSleepScreen};
     static const int sleepFrameCount = sizeof(sleepFrames) / sizeof(sleepFrames[0]);
     ui.setFrames(sleepFrames, sleepFrameCount);
@@ -884,16 +925,13 @@ void Screen::setup()
     dispdev.setDetected(screen_model);
 #endif
 
-    // Load OEM config from Proto file if existent
-    loadProto(oemConfigFile, OEMStore_size, sizeof(oemConfigFile), OEMStore_fields, &oemStore);
-
     // Initialising the UI will init the display too.
     ui.init();
 
     displayWidth = dispdev.width();
     displayHeight = dispdev.height();
 
-    ui.setTimePerTransition(SCREEN_TRANSITION_MSECS);
+    ui.setTimePerTransition(0);
 
     ui.setIndicatorPosition(BOTTOM);
     // Defines where the first frame is located in the bar.
@@ -907,6 +945,9 @@ void Screen::setup()
     // Set the utf8 conversion function
     dispdev.setFontTableLookupFunction(customFontTableLookup);
 
+    if (strlen(oemStore.oem_text) > 0)
+        logo_timeout *= 2;
+
     // Add frames.
     static FrameCallback bootFrames[] = {drawBootScreen};
     static const int bootFrameCount = sizeof(bootFrames) / sizeof(bootFrames[0]);
@@ -922,8 +963,12 @@ void Screen::setup()
 
 #ifdef SCREEN_MIRROR
     dispdev.mirrorScreen();
-#elif defined(SCREEN_FLIP_VERTICALLY)
-    dispdev.flipScreenVertically();
+#else
+    // Standard behaviour is to FLIP the screen (needed on T-Beam). If this config item is set, unflip it, and thereby logically flip it.
+    // If you have a headache now, you're welcome.
+    if (!config.display.flip_screen) {
+        dispdev.flipScreenVertically();
+    }
 #endif
 
     // Get our hardware ID
@@ -935,9 +980,11 @@ void Screen::setup()
     handleSetOn(true);
 
     // On some ssd1306 clones, the first draw command is discarded, so draw it
-    // twice initially.
+    // twice initially. Skip this for EINK Displays to save a few seconds during boot
     ui.update();
+#ifndef USE_EINK
     ui.update();
+#endif
     serialSinceMsec = millis();
 
     // Subscribe to status updates
@@ -954,7 +1001,7 @@ void Screen::setup()
 void Screen::forceDisplay()
 {
     // Nasty hack to force epaper updates for 'key' frames.  FIXME, cleanup.
-#ifdef HAS_EINK
+#ifdef USE_EINK
     dispdev.forceDisplay();
 #endif
 }
@@ -969,32 +1016,34 @@ int32_t Screen::runOnce()
         return RUN_SAME;
     }
 
-    // Show boot screen for first 5 seconds, then switch to normal operation.
+    // Show boot screen for first logo_timeout seconds, then switch to normal operation.
     // serialSinceMsec adjusts for additional serial wait time during nRF52 bootup
     static bool showingBootScreen = true;
-    if (showingBootScreen && (millis() > (5000 + serialSinceMsec))) {
+    if (showingBootScreen && (millis() > (logo_timeout + serialSinceMsec))) {
         DEBUG_MSG("Done with boot screen...\n");
         stopBootScreen();
         showingBootScreen = false;
     }
 
-    // If we have an OEM Boot screen, toggle after 2,5 seconds
+    // If we have an OEM Boot screen, toggle after logo_timeout seconds
     if (strlen(oemStore.oem_text) > 0) {
         static bool showingOEMBootScreen = true;
-        if (showingOEMBootScreen && (millis() > (2500 + serialSinceMsec))) {
+        if (showingOEMBootScreen && (millis() > ((logo_timeout / 2) + serialSinceMsec))) {
             DEBUG_MSG("Switch to OEM screen...\n");
             // Change frames.
             static FrameCallback bootOEMFrames[] = {drawOEMBootScreen};
             static const int bootOEMFrameCount = sizeof(bootOEMFrames) / sizeof(bootOEMFrames[0]);
             ui.setFrames(bootOEMFrames, bootOEMFrameCount);
             ui.update();
+#ifndef USE_EINK            
             ui.update();
+#endif
             showingOEMBootScreen = false;
         }
     }
 
 #ifndef DISABLE_WELCOME_UNSET
-    if (showingNormalScreen && config.lora.region == Config_LoRaConfig_RegionCode_Unset) {
+    if (showingNormalScreen && config.lora.region == Config_LoRaConfig_RegionCode_UNSET) {
         setWelcomeFrames();
     }
 #endif
@@ -1032,6 +1081,9 @@ int32_t Screen::runOnce()
         case Cmd::START_SHUTDOWN_SCREEN:
             handleShutdownScreen();
             break;
+        case Cmd::START_REBOOT_SCREEN:
+            handleRebootScreen();
+            break;
         default:
             DEBUG_MSG("BUG: invalid cmd\n");
         }
@@ -1052,13 +1104,8 @@ int32_t Screen::runOnce()
     // otherwise that breaks animations.
     if (targetFramerate != IDLE_FRAMERATE && ui.getUiState()->frameState == FIXED) {
         // oldFrameState = ui.getUiState()->frameState;
-        DEBUG_MSG("Setting idle framerate\n");
         targetFramerate = IDLE_FRAMERATE;
 
-#ifndef NO_ESP32
-        setCPUFast(false); // Turn up the CPU to improve screen animations
-#endif
-
         ui.setTargetFPS(targetFramerate);
         forceDisplay();
     }
@@ -1180,7 +1227,7 @@ void Screen::setFrames()
     // call a method on debugInfoScreen object (for more details)
     normalFrames[numframes++] = &Screen::drawDebugInfoSettingsTrampoline;
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
     if (isWifiAvailable()) {
         // call a method on debugInfoScreen object (for more details)
         normalFrames[numframes++] = &Screen::drawDebugInfoWiFiTrampoline;
@@ -1224,6 +1271,18 @@ void Screen::handleShutdownScreen()
     setFastFramerate();
 }
 
+void Screen::handleRebootScreen()
+{
+    DEBUG_MSG("showing reboot screen\n");
+    showingNormalScreen = false;
+
+    static FrameCallback rebootFrames[] = {drawFrameReboot};
+
+    ui.disableAllIndicators();
+    ui.setFrames(rebootFrames, 1);
+    setFastFramerate();
+}
+
 void Screen::handleStartFirmwareUpdateScreen()
 {
     DEBUG_MSG("showing firmware screen\n");
@@ -1270,7 +1329,6 @@ void Screen::handleOnPress()
     // If we are in a transition, the press must have bounced, drop it.
     if (ui.getUiState()->frameState == FIXED) {
         ui.nextFrame();
-        DEBUG_MSG("Setting LastScreenTransition\n");
         lastScreenTransition = millis();
         setFastFramerate();
     }
@@ -1282,15 +1340,9 @@ void Screen::handleOnPress()
 
 void Screen::setFastFramerate()
 {
-    DEBUG_MSG("Setting fast framerate\n");
-
     // We are about to start a transition so speed up fps
     targetFramerate = SCREEN_TRANSITION_FRAMERATE;
 
-#ifndef NO_ESP32
-    setCPUFast(true); // Turn up the CPU to improve screen animations
-#endif
-
     ui.setTargetFPS(targetFramerate);
     setInterval(0); // redraw ASAP
     runASAP = true;
@@ -1342,9 +1394,8 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 // Jm
 void DebugInfo::drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
-#ifdef HAS_WIFI
-    const char *wifiName = config.wifi.ssid;
-    const char *wifiPsw = config.wifi.psk;
+#if HAS_WIFI
+    const char *wifiName = config.network.wifi_ssid;
 
     displayedNodeNum = 0; // Not currently showing a node pane
 
@@ -1353,11 +1404,7 @@ void DebugInfo::drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, i
     // The coordinates define the left starting point of the text
     display->setTextAlignment(TEXT_ALIGN_LEFT);
 
-    if (isSoftAPForced()) {
-        display->drawString(x, y, String("WiFi: Software AP (Admin)"));
-    } else if (config.wifi.ap_mode) {
-        display->drawString(x, y, String("WiFi: Software AP"));
-    } else if (WiFi.status() != WL_CONNECTED) {
+    if (WiFi.status() != WL_CONNECTED) {
         display->drawString(x, y, String("WiFi: Not Connected"));
     } else {
         display->drawString(x, y, String("WiFi: Connected"));
@@ -1378,25 +1425,14 @@ void DebugInfo::drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, i
     - WL_NO_SHIELD: assigned when no WiFi shield is present;
 
     */
-    if (WiFi.status() == WL_CONNECTED || isSoftAPForced() || config.wifi.ap_mode) {
-        if (config.wifi.ap_mode || isSoftAPForced()) {
-            display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "IP: " + String(WiFi.softAPIP().toString().c_str()));
-
-            // Number of connections to the AP. Default max for the esp32 is 4
-            display->drawString(x + SCREEN_WIDTH - display->getStringWidth("(" + String(WiFi.softAPgetStationNum()) + "/4)"),
-                                y + FONT_HEIGHT_SMALL * 1, "(" + String(WiFi.softAPgetStationNum()) + "/4)");
-        } else {
-            display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "IP: " + String(WiFi.localIP().toString().c_str()));
-        }
-
+    if (WiFi.status() == WL_CONNECTED) {
+        display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "IP: " + String(WiFi.localIP().toString().c_str()));
     } else if (WiFi.status() == WL_NO_SSID_AVAIL) {
         display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "SSID Not Found");
     } else if (WiFi.status() == WL_CONNECTION_LOST) {
         display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "Connection Lost");
     } else if (WiFi.status() == WL_CONNECT_FAILED) {
         display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "Connection Failed");
-        //} else if (WiFi.status() == WL_DISCONNECTED) {
-        //    display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "Disconnected");
     } else if (WiFi.status() == WL_IDLE_STATUS) {
         display->drawString(x, y + FONT_HEIGHT_SMALL * 1, "Idle ... Reconnecting");
     } else {
@@ -1463,24 +1499,8 @@ void DebugInfo::drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, i
         }
     }
 
-    if (isSoftAPForced()) {
-        if ((millis() / 10000) % 2) {
-            display->drawString(x, y + FONT_HEIGHT_SMALL * 2, "SSID: meshtasticAdmin");
-        } else {
-            display->drawString(x, y + FONT_HEIGHT_SMALL * 2, "PWD: 12345678");
-        }
+    display->drawString(x, y + FONT_HEIGHT_SMALL * 2, "SSID: " + String(wifiName));
 
-    } else {
-        if (config.wifi.ap_mode) {
-            if ((millis() / 10000) % 2) {
-                display->drawString(x, y + FONT_HEIGHT_SMALL * 2, "SSID: " + String(wifiName));
-            } else {
-                display->drawString(x, y + FONT_HEIGHT_SMALL * 2, "PWD: " + String(wifiPsw));
-            }
-        } else {
-            display->drawString(x, y + FONT_HEIGHT_SMALL * 2, "SSID: " + String(wifiName));
-        }
-    }
     display->drawString(x, y + FONT_HEIGHT_SMALL * 3, "http://meshtastic.local");
 
     /* Display a heartbeat pixel that blinks every time the frame is redrawn */
@@ -1519,25 +1539,25 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
     auto mode = "";
 
     switch (config.lora.modem_preset) {
-    case Config_LoRaConfig_ModemPreset_ShortSlow:
+    case Config_LoRaConfig_ModemPreset_SHORT_SLOW:
         mode = "ShortS";
         break;
-    case Config_LoRaConfig_ModemPreset_ShortFast:
+    case Config_LoRaConfig_ModemPreset_SHORT_FAST:
         mode = "ShortF";
         break;
-    case Config_LoRaConfig_ModemPreset_MedSlow:
+    case Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
         mode = "MedS";
         break;
-    case Config_LoRaConfig_ModemPreset_MedFast:
+    case Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
         mode = "MedF";
         break;
-    case Config_LoRaConfig_ModemPreset_LongSlow:
+    case Config_LoRaConfig_ModemPreset_LONG_SLOW:
         mode = "LongS";
         break;
-    case Config_LoRaConfig_ModemPreset_LongFast:
+    case Config_LoRaConfig_ModemPreset_LONG_FAST:
         mode = "LongF";
         break;
-    case Config_LoRaConfig_ModemPreset_VLongSlow:
+    case Config_LoRaConfig_ModemPreset_VERY_LONG_SLOW:
         mode = "VeryL";
         break;
     default:
@@ -1596,7 +1616,7 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
 
     // Line 3
     if (config.display.gps_format !=
-        Config_DisplayConfig_GpsCoordinateFormat_GpsFormatDMS) // if DMS then don't draw altitude
+        Config_DisplayConfig_GpsCoordinateFormat_DMS) // if DMS then don't draw altitude
         drawGPSAltitude(display, x, y + FONT_HEIGHT_SMALL * 2, gpsStatus);
 
     // Line 4
@@ -1612,6 +1632,9 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
 // adjust Brightness cycle trough 1 to 254 as long as attachDuringLongPress is true
 void Screen::adjustBrightness()
 {
+    if (!useDisplay)
+        return;
+
     if (brightness == 254) {
         brightness = 0;
     } else {
@@ -1665,4 +1688,5 @@ int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 }
 
 } // namespace graphics
-#endif // NO_SCREEN
+
+#endif // HAS_SCREEN

src/graphics/Screen.h

@@ -1,6 +1,8 @@
 #pragma once
 
-#ifdef NO_SCREEN
+#include "configuration.h"
+
+#if !HAS_SCREEN
 #include "power.h"
 namespace graphics
 {
@@ -8,7 +10,7 @@ namespace graphics
 class Screen 
 {
   public:
-    Screen(char){}
+    explicit Screen(char){}
     void onPress() {}
     void setup() {}
     void setOn(bool) {}
@@ -18,6 +20,7 @@ class Screen
     void forceDisplay() {}
     void startBluetoothPinScreen(uint32_t pin) {}
     void stopBluetoothPinScreen() {}
+    void startRebootScreen() {}
 };
 }
 
@@ -54,6 +57,16 @@ class Screen
 #define BRIGHTNESS_DEFAULT 150
 #endif
 
+// Meters to feet conversion
+#ifndef METERS_TO_FEET
+#define METERS_TO_FEET 3.28
+#endif
+
+// Feet to miles conversion
+#ifndef MILES_TO_FEET
+#define MILES_TO_FEET 5280
+#endif
+
 namespace graphics
 {
 
@@ -118,8 +131,7 @@ class Screen : public concurrency::OSThread
     void setOn(bool on)
     {
         if (!on)
-            handleSetOn(
-                false); // We handle off commands immediately, because they might be called because the CPU is shutting down
+            handleSetOn(false); // We handle off commands immediately, because they might be called because the CPU is shutting down
         else
             enqueueCmd(ScreenCmd{.cmd = on ? Cmd::SET_ON : Cmd::SET_OFF});
     }
@@ -165,6 +177,13 @@ class Screen : public concurrency::OSThread
         enqueueCmd(cmd);
     }
 
+    void startRebootScreen()
+    {
+        ScreenCmd cmd;
+        cmd.cmd = Cmd::START_REBOOT_SCREEN;
+        enqueueCmd(cmd);
+    }
+
     /// Stops showing the bluetooth PIN screen.
     void stopBluetoothPinScreen() { enqueueCmd(ScreenCmd{.cmd = Cmd::STOP_BLUETOOTH_PIN_SCREEN}); }
 
@@ -202,19 +221,34 @@ class Screen : public concurrency::OSThread
         uint8_t last = LASTCHAR; // get last char
         LASTCHAR = ch;
 
-        switch (last) { // conversion depnding on first UTF8-character
-        case 0xC2: {
-            SKIPREST = false;
-            return (uint8_t)ch;
-        }
-        case 0xC3: {
-            SKIPREST = false;
-            return (uint8_t)(ch | 0xC0);
-        }
+        switch (last) { // conversion depending on first UTF8-character
+            case 0xC2: {
+                SKIPREST = false;
+                return (uint8_t)ch;
+            }
+            case 0xC3: {
+                SKIPREST = false;
+                return (uint8_t)(ch | 0xC0);
+            }
+            // map UTF-8 cyrillic chars to it Windows-1251 (CP-1251) ASCII codes
+            // note: in this case we must use compatible font - provided ArialMT_Plain_10/16/24 by 'ThingPulse/esp8266-oled-ssd1306' library
+            // have empty chars for non-latin ASCII symbols
+            case 0xD0: {
+                SKIPREST = false;
+                if (ch == 129) return (uint8_t)(168); // Ё
+                if (ch > 143 && ch < 192) return (uint8_t)(ch + 48);
+                break;
+            }
+            case 0xD1: {
+                SKIPREST = false;
+                if (ch == 145) return (uint8_t)(184); // ё
+                if (ch > 127 && ch < 144) return (uint8_t)(ch + 112);
+                break;
+            }
         }
 
         // We want to strip out prefix chars for two-byte char formats
-        if (ch == 0xC2 || ch == 0xC3 || ch == 0x82)
+        if (ch == 0xC2 || ch == 0xC3 || ch == 0x82 || ch == 0xD0 || ch == 0xD1)
             return (uint8_t)0;
 
         // If we already returned an unconvertable-character symbol for this unconvertable-character sequence, return NULs for the
@@ -278,6 +312,7 @@ class Screen : public concurrency::OSThread
     void handlePrint(const char *text);
     void handleStartFirmwareUpdateScreen();
     void handleShutdownScreen();
+    void handleRebootScreen();
     /// Rebuilds our list of frames (screens) to default ones.
     void setFrames();
 
@@ -315,7 +350,7 @@ class Screen : public concurrency::OSThread
     SSD1306Wire dispdev;
 #elif defined(ST7735_CS) || defined(ILI9341_DRIVER)
     TFTDisplay dispdev;
-#elif defined(HAS_EINK)
+#elif defined(USE_EINK)
     EInkDisplay dispdev;
 #elif defined(USE_ST7567)
     ST7567Wire dispdev;

src/graphics/TFTDisplay.cpp

@@ -22,13 +22,23 @@ void TFTDisplay::display(void)
 {
     concurrency::LockGuard g(spiLock);
 
-    // FIXME - only draw bits have changed (use backbuf similar to the other displays)
-    // tft.drawBitmap(0, 0, buffer, 128, 64, TFT_YELLOW, TFT_BLACK);
-    for (uint16_t y = 0; y < displayHeight; y++) {
-        for (uint16_t x = 0; x < displayWidth; x++) {
+    uint16_t x,y;
+
+    for (y = 0; y < displayHeight; y++) {
+        for (x = 0; x < displayWidth; x++) {
             // get src pixel in the page based ordering the OLED lib uses FIXME, super inefficent
             auto isset = buffer[x + (y / 8) * displayWidth] & (1 << (y & 7));
-            tft.drawPixel(x, y, isset ? TFT_WHITE : TFT_BLACK);
+            auto dblbuf_isset = buffer_back[x + (y / 8) * displayWidth] & (1 << (y & 7));
+            if (isset != dblbuf_isset) {
+                tft.drawPixel(x, y, isset ? TFT_WHITE : TFT_BLACK);
+            }
+        }
+    }
+    // Copy the Buffer to the Back Buffer
+    for (y = 0; y < (displayHeight / 8); y++) {
+        for (x = 0; x < displayWidth; x++) {
+            uint16_t pos = x + y * displayWidth;
+            buffer_back[pos] = buffer[pos];
         }
     }
 }

src/graphics/fonts/OLEDDisplayFontsRU.cpp

@@ -0,0 +1,426 @@
+#include "OLEDDisplayFontsRU.h"
+
+// Font generated or edited with the glyphEditor
+const uint8_t ArialMT_Plain_10_RU[] PROGMEM = {
+	0x0A, // Width: 10
+	0x0D, // Height: 13
+	0x20, // First char: 32
+	0xE0, // Number of chars: 224
+	
+	// Jump Table:
+	0xFF, 0xFF, 0x00, 0x0A, // 32
+	0x00, 0x00, 0x04, 0x03, // 33
+	0x00, 0x04, 0x05, 0x04, // 34
+	0x00, 0x09, 0x09, 0x06, // 35
+	0x00, 0x12, 0x0A, 0x06, // 36
+	0x00, 0x1C, 0x10, 0x09, // 37
+	0x00, 0x2C, 0x0E, 0x08, // 38
+	0x00, 0x3A, 0x01, 0x02, // 39
+	0x00, 0x3B, 0x06, 0x04, // 40
+	0x00, 0x41, 0x06, 0x04, // 41
+	0x00, 0x47, 0x05, 0x04, // 42
+	0x00, 0x4C, 0x09, 0x06, // 43
+	0x00, 0x55, 0x04, 0x03, // 44
+	0x00, 0x59, 0x03, 0x03, // 45
+	0x00, 0x5C, 0x04, 0x03, // 46
+	0x00, 0x60, 0x05, 0x04, // 47
+	0x00, 0x65, 0x0A, 0x06, // 48
+	0x00, 0x6F, 0x08, 0x05, // 49
+	0x00, 0x77, 0x0A, 0x06, // 50
+	0x00, 0x81, 0x0A, 0x06, // 51
+	0x00, 0x8B, 0x0B, 0x07, // 52
+	0x00, 0x96, 0x0A, 0x06, // 53
+	0x00, 0xA0, 0x0A, 0x06, // 54
+	0x00, 0xAA, 0x09, 0x06, // 55
+	0x00, 0xB3, 0x0A, 0x06, // 56
+	0x00, 0xBD, 0x0A, 0x06, // 57
+	0x00, 0xC7, 0x04, 0x03, // 58
+	0x00, 0xCB, 0x04, 0x03, // 59
+	0x00, 0xCF, 0x0A, 0x06, // 60
+	0x00, 0xD9, 0x09, 0x06, // 61
+	0x00, 0xE2, 0x09, 0x06, // 62
+	0x00, 0xEB, 0x0B, 0x07, // 63
+	0x00, 0xF6, 0x14, 0x0B, // 64
+	0x01, 0x0A, 0x0E, 0x08, // 65
+	0x01, 0x18, 0x0C, 0x07, // 66
+	0x01, 0x24, 0x0C, 0x07, // 67
+	0x01, 0x30, 0x0B, 0x07, // 68
+	0x01, 0x3B, 0x0C, 0x07, // 69
+	0x01, 0x47, 0x09, 0x06, // 70
+	0x01, 0x50, 0x0D, 0x08, // 71
+	0x01, 0x5D, 0x0C, 0x07, // 72
+	0x01, 0x69, 0x04, 0x03, // 73
+	0x01, 0x6D, 0x08, 0x05, // 74
+	0x01, 0x75, 0x0E, 0x08, // 75
+	0x01, 0x83, 0x0C, 0x07, // 76
+	0x01, 0x8F, 0x10, 0x09, // 77
+	0x01, 0x9F, 0x0C, 0x07, // 78
+	0x01, 0xAB, 0x0E, 0x08, // 79
+	0x01, 0xB9, 0x0B, 0x07, // 80
+	0x01, 0xC4, 0x0E, 0x08, // 81
+	0x01, 0xD2, 0x0C, 0x07, // 82
+	0x01, 0xDE, 0x0C, 0x07, // 83
+	0x01, 0xEA, 0x0B, 0x07, // 84
+	0x01, 0xF5, 0x0C, 0x07, // 85
+	0x02, 0x01, 0x0D, 0x08, // 86
+	0x02, 0x0E, 0x11, 0x0A, // 87
+	0x02, 0x1F, 0x0E, 0x08, // 88
+	0x02, 0x2D, 0x0D, 0x08, // 89
+	0x02, 0x3A, 0x0C, 0x07, // 90
+	0x02, 0x46, 0x06, 0x04, // 91
+	0x02, 0x4C, 0x06, 0x04, // 92
+	0x02, 0x52, 0x04, 0x03, // 93
+	0x02, 0x56, 0x09, 0x06, // 94
+	0x02, 0x5F, 0x0C, 0x07, // 95
+	0x02, 0x6B, 0x03, 0x03, // 96
+	0x02, 0x6E, 0x0A, 0x06, // 97
+	0x02, 0x78, 0x0A, 0x06, // 98
+	0x02, 0x82, 0x0A, 0x06, // 99
+	0x02, 0x8C, 0x0A, 0x06, // 100
+	0x02, 0x96, 0x0A, 0x06, // 101
+	0x02, 0xA0, 0x05, 0x04, // 102
+	0x02, 0xA5, 0x0A, 0x06, // 103
+	0x02, 0xAF, 0x0A, 0x06, // 104
+	0x02, 0xB9, 0x04, 0x03, // 105
+	0x02, 0xBD, 0x04, 0x03, // 106
+	0x02, 0xC1, 0x08, 0x05, // 107
+	0x02, 0xC9, 0x04, 0x03, // 108
+	0x02, 0xCD, 0x10, 0x09, // 109
+	0x02, 0xDD, 0x0A, 0x06, // 110
+	0x02, 0xE7, 0x0A, 0x06, // 111
+	0x02, 0xF1, 0x0A, 0x06, // 112
+	0x02, 0xFB, 0x0A, 0x06, // 113
+	0x03, 0x05, 0x05, 0x04, // 114
+	0x03, 0x0A, 0x08, 0x05, // 115
+	0x03, 0x12, 0x06, 0x04, // 116
+	0x03, 0x18, 0x0A, 0x06, // 117
+	0x03, 0x22, 0x09, 0x06, // 118
+	0x03, 0x2B, 0x0E, 0x08, // 119
+	0x03, 0x39, 0x0A, 0x06, // 120
+	0x03, 0x43, 0x09, 0x06, // 121
+	0x03, 0x4C, 0x0A, 0x06, // 122
+	0x03, 0x56, 0x06, 0x04, // 123
+	0x03, 0x5C, 0x04, 0x03, // 124
+	0x03, 0x60, 0x05, 0x04, // 125
+	0x03, 0x65, 0x09, 0x06, // 126
+	0xFF, 0xFF, 0x00, 0x0A, // 127
+	0xFF, 0xFF, 0x00, 0x0A, // 128
+	0xFF, 0xFF, 0x00, 0x0A, // 129
+	0xFF, 0xFF, 0x00, 0x0A, // 130
+	0xFF, 0xFF, 0x00, 0x0A, // 131
+	0xFF, 0xFF, 0x00, 0x0A, // 132
+	0xFF, 0xFF, 0x00, 0x0A, // 133
+	0xFF, 0xFF, 0x00, 0x0A, // 134
+	0xFF, 0xFF, 0x00, 0x0A, // 135
+	0xFF, 0xFF, 0x00, 0x0A, // 136
+	0xFF, 0xFF, 0x00, 0x0A, // 137
+	0xFF, 0xFF, 0x00, 0x0A, // 138
+	0xFF, 0xFF, 0x00, 0x0A, // 139
+	0xFF, 0xFF, 0x00, 0x0A, // 140
+	0xFF, 0xFF, 0x00, 0x0A, // 141
+	0xFF, 0xFF, 0x00, 0x0A, // 142
+	0xFF, 0xFF, 0x00, 0x0A, // 143
+	0xFF, 0xFF, 0x00, 0x0A, // 144
+	0xFF, 0xFF, 0x00, 0x0A, // 145
+	0xFF, 0xFF, 0x00, 0x0A, // 146
+	0xFF, 0xFF, 0x00, 0x0A, // 147
+	0xFF, 0xFF, 0x00, 0x0A, // 148
+	0xFF, 0xFF, 0x00, 0x0A, // 149
+	0xFF, 0xFF, 0x00, 0x0A, // 150
+	0xFF, 0xFF, 0x00, 0x0A, // 151
+	0xFF, 0xFF, 0x00, 0x0A, // 152
+	0xFF, 0xFF, 0x00, 0x0A, // 153
+	0xFF, 0xFF, 0x00, 0x0A, // 154
+	0xFF, 0xFF, 0x00, 0x0A, // 155
+	0xFF, 0xFF, 0x00, 0x0A, // 156
+	0xFF, 0xFF, 0x00, 0x0A, // 157
+	0xFF, 0xFF, 0x00, 0x0A, // 158
+	0xFF, 0xFF, 0x00, 0x0A, // 159
+	0xFF, 0xFF, 0x00, 0x0A, // 160
+	0x03, 0x6E, 0x04, 0x03, // 161
+	0x03, 0x72, 0x0A, 0x06, // 162
+	0x03, 0x7C, 0x0C, 0x07, // 163
+	0x03, 0x88, 0x0A, 0x06, // 164
+	0x03, 0x92, 0x0A, 0x06, // 165
+	0x03, 0x9C, 0x04, 0x03, // 166
+	0x03, 0xA0, 0x0A, 0x06, // 167
+	0x03, 0xAA, 0x0C, 0x07, // 168
+	0x03, 0xB6, 0x0D, 0x08, // 169
+	0x03, 0xC3, 0x07, 0x05, // 170
+	0x03, 0xCA, 0x0A, 0x06, // 171
+	0x03, 0xD4, 0x09, 0x06, // 172
+	0x03, 0xDD, 0x03, 0x03, // 173
+	0x03, 0xE0, 0x0D, 0x08, // 174
+	0x03, 0xED, 0x0B, 0x07, // 175
+	0x03, 0xF8, 0x07, 0x05, // 176
+	0x03, 0xFF, 0x0A, 0x06, // 177
+	0x04, 0x09, 0x05, 0x04, // 178
+	0x04, 0x0E, 0x05, 0x04, // 179
+	0x04, 0x13, 0x05, 0x04, // 180
+	0x04, 0x18, 0x0A, 0x06, // 181
+	0x04, 0x22, 0x09, 0x06, // 182
+	0x04, 0x2B, 0x03, 0x03, // 183
+	0x04, 0x2E, 0x0B, 0x07, // 184
+	0x04, 0x39, 0x0B, 0x07, // 185
+	0x04, 0x44, 0x07, 0x05, // 186
+	0x04, 0x4B, 0x0A, 0x06, // 187
+	0x04, 0x55, 0x10, 0x09, // 188
+	0x04, 0x65, 0x10, 0x09, // 189
+	0x04, 0x75, 0x10, 0x09, // 190
+	0x04, 0x85, 0x0A, 0x06, // 191
+	0x04, 0x8F, 0x0C, 0x07, // 192
+	0x04, 0x9B, 0x0C, 0x07, // 193
+	0x04, 0xA7, 0x0C, 0x07, // 194
+	0x04, 0xB3, 0x0B, 0x07, // 195
+	0x04, 0xBE, 0x0C, 0x07, // 196
+	0x04, 0xCA, 0x0C, 0x07, // 197
+	0x04, 0xD6, 0x0C, 0x07, // 198
+	0x04, 0xE2, 0x0C, 0x07, // 199
+	0x04, 0xEE, 0x0C, 0x07, // 200
+	0x04, 0xFA, 0x0C, 0x07, // 201
+	0x05, 0x06, 0x0C, 0x07, // 202
+	0x05, 0x12, 0x0C, 0x07, // 203
+	0x05, 0x1E, 0x0C, 0x07, // 204
+	0x05, 0x2A, 0x0C, 0x07, // 205
+	0x05, 0x36, 0x0C, 0x07, // 206
+	0x05, 0x42, 0x0C, 0x07, // 207
+	0x05, 0x4E, 0x0B, 0x07, // 208
+	0x05, 0x59, 0x0C, 0x07, // 209
+	0x05, 0x65, 0x0B, 0x07, // 210
+	0x05, 0x70, 0x0C, 0x07, // 211
+	0x05, 0x7C, 0x0B, 0x07, // 212
+	0x05, 0x87, 0x0C, 0x07, // 213
+	0x05, 0x93, 0x0C, 0x07, // 214
+	0x05, 0x9F, 0x0C, 0x07, // 215
+	0x05, 0xAB, 0x0C, 0x07, // 216
+	0x05, 0xB7, 0x0E, 0x08, // 217
+	0x05, 0xC5, 0x0C, 0x07, // 218
+	0x05, 0xD1, 0x0C, 0x07, // 219
+	0x05, 0xDD, 0x0C, 0x07, // 220
+	0x05, 0xE9, 0x0C, 0x07, // 221
+	0x05, 0xF5, 0x0C, 0x07, // 222
+	0x06, 0x01, 0x0C, 0x07, // 223
+	0x06, 0x0D, 0x0C, 0x07, // 224
+	0x06, 0x19, 0x0C, 0x07, // 225
+	0x06, 0x25, 0x0C, 0x07, // 226
+	0x06, 0x31, 0x0B, 0x07, // 227
+	0x06, 0x3C, 0x0C, 0x07, // 228
+	0x06, 0x48, 0x0B, 0x07, // 229
+	0x06, 0x53, 0x0C, 0x07, // 230
+	0x06, 0x5F, 0x0C, 0x07, // 231
+	0x06, 0x6B, 0x0C, 0x07, // 232
+	0x06, 0x77, 0x0C, 0x07, // 233
+	0x06, 0x83, 0x0C, 0x07, // 234
+	0x06, 0x8F, 0x0C, 0x07, // 235
+	0x06, 0x9B, 0x0C, 0x07, // 236
+	0x06, 0xA7, 0x0C, 0x07, // 237
+	0x06, 0xB3, 0x0C, 0x07, // 238
+	0x06, 0xBF, 0x0C, 0x07, // 239
+	0x06, 0xCB, 0x0B, 0x07, // 240
+	0x06, 0xD6, 0x0C, 0x07, // 241
+	0x06, 0xE2, 0x0B, 0x07, // 242
+	0x06, 0xED, 0x0C, 0x07, // 243
+	0x06, 0xF9, 0x0B, 0x07, // 244
+	0x07, 0x04, 0x0C, 0x07, // 245
+	0x07, 0x10, 0x0C, 0x07, // 246
+	0x07, 0x1C, 0x0C, 0x07, // 247
+	0x07, 0x28, 0x0C, 0x07, // 248
+	0x07, 0x34, 0x0E, 0x08, // 249
+	0x07, 0x42, 0x0C, 0x07, // 250
+	0x07, 0x4E, 0x0C, 0x07, // 251
+	0x07, 0x5A, 0x0C, 0x07, // 252
+	0x07, 0x66, 0x0C, 0x07, // 253
+	0x07, 0x72, 0x0C, 0x07, // 254
+	0x07, 0x7E, 0x0C, 0x07, // 255
+	
+	// Font Data:
+	0x00, 0x00, 0xF8, 0x02, // 33
+	0x38, 0x00, 0x00, 0x00, 0x38, // 34
+	0xA0, 0x03, 0xE0, 0x00, 0xB8, 0x03, 0xE0, 0x00, 0xB8, // 35
+	0x30, 0x01, 0x28, 0x02, 0xF8, 0x07, 0x48, 0x02, 0x90, 0x01, // 36
+	0x00, 0x00, 0x30, 0x00, 0x48, 0x00, 0x30, 0x03, 0xC0, 0x00, 0xB0, 0x01, 0x48, 0x02, 0x80, 0x01, // 37
+	0x80, 0x01, 0x50, 0x02, 0x68, 0x02, 0xA8, 0x02, 0x18, 0x01, 0x80, 0x03, 0x80, 0x02, // 38
+	0x38, // 39
+	0xE0, 0x03, 0x10, 0x04, 0x08, 0x08, // 40
+	0x08, 0x08, 0x10, 0x04, 0xE0, 0x03, // 41
+	0x28, 0x00, 0x18, 0x00, 0x28, // 42
+	0x40, 0x00, 0x40, 0x00, 0xF0, 0x01, 0x40, 0x00, 0x40, // 43
+	0x00, 0x00, 0x00, 0x06, // 44
+	0x80, 0x00, 0x80, // 45
+	0x00, 0x00, 0x00, 0x02, // 46
+	0x00, 0x03, 0xE0, 0x00, 0x18, // 47
+	0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF0, 0x01, // 48
+	0x00, 0x00, 0x20, 0x00, 0x10, 0x00, 0xF8, 0x03, // 49
+	0x10, 0x02, 0x08, 0x03, 0x88, 0x02, 0x48, 0x02, 0x30, 0x02, // 50
+	0x10, 0x01, 0x08, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01, // 51
+	0xC0, 0x00, 0xA0, 0x00, 0x90, 0x00, 0x88, 0x00, 0xF8, 0x03, 0x80, // 52
+	0x60, 0x01, 0x38, 0x02, 0x28, 0x02, 0x28, 0x02, 0xC8, 0x01, // 53
+	0xF0, 0x01, 0x28, 0x02, 0x28, 0x02, 0x28, 0x02, 0xD0, 0x01, // 54
+	0x08, 0x00, 0x08, 0x03, 0xC8, 0x00, 0x38, 0x00, 0x08, // 55
+	0xB0, 0x01, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01, // 56
+	0x70, 0x01, 0x88, 0x02, 0x88, 0x02, 0x88, 0x02, 0xF0, 0x01, // 57
+	0x00, 0x00, 0x20, 0x02, // 58
+	0x00, 0x00, 0x20, 0x06, // 59
+	0x00, 0x00, 0x40, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x10, 0x01, // 60
+	0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, // 61
+	0x00, 0x00, 0x10, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0x40, // 62
+	0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0xC8, 0x02, 0x48, 0x00, 0x30, // 63
+	0x00, 0x00, 0xC0, 0x03, 0x30, 0x04, 0xD0, 0x09, 0x28, 0x0A, 0x28, 0x0A, 0xC8, 0x0B, 0x68, 0x0A, 0x10, 0x05, 0xE0, 0x04, // 64
+	0x00, 0x02, 0xC0, 0x01, 0xB0, 0x00, 0x88, 0x00, 0xB0, 0x00, 0xC0, 0x01, 0x00, 0x02, // 65
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xF0, 0x01, // 66
+	0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01, // 67
+	0x00, 0x00, 0xF8, 0x03, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01, 0xE0, // 68
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, // 69
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0x08, // 70
+	0x00, 0x00, 0xE0, 0x00, 0x10, 0x01, 0x08, 0x02, 0x48, 0x02, 0x50, 0x01, 0xC0, // 71
+	0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03, // 72
+	0x00, 0x00, 0xF8, 0x03, // 73
+	0x00, 0x03, 0x00, 0x02, 0x00, 0x02, 0xF8, 0x01, // 74
+	0x00, 0x00, 0xF8, 0x03, 0x80, 0x00, 0x60, 0x00, 0x90, 0x00, 0x08, 0x01, 0x00, 0x02, // 75
+	0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, // 76
+	0x00, 0x00, 0xF8, 0x03, 0x30, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x30, 0x00, 0xF8, 0x03, // 77
+	0x00, 0x00, 0xF8, 0x03, 0x30, 0x00, 0x40, 0x00, 0x80, 0x01, 0xF8, 0x03, // 78
+	0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF0, 0x01, // 79
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x30, // 80
+	0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x03, 0x08, 0x03, 0xF0, 0x02, // 81
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0xC8, 0x00, 0x30, 0x03, // 82
+	0x00, 0x00, 0x30, 0x01, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x90, 0x01, // 83
+	0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, // 84
+	0x00, 0x00, 0xF8, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xF8, 0x01, // 85
+	0x08, 0x00, 0x70, 0x00, 0x80, 0x01, 0x00, 0x02, 0x80, 0x01, 0x70, 0x00, 0x08, // 86
+	0x18, 0x00, 0xE0, 0x01, 0x00, 0x02, 0xF0, 0x01, 0x08, 0x00, 0xF0, 0x01, 0x00, 0x02, 0xE0, 0x01, 0x18, // 87
+	0x00, 0x02, 0x08, 0x01, 0x90, 0x00, 0x60, 0x00, 0x90, 0x00, 0x08, 0x01, 0x00, 0x02, // 88
+	0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0xC0, 0x03, 0x20, 0x00, 0x10, 0x00, 0x08, // 89
+	0x08, 0x03, 0x88, 0x02, 0xC8, 0x02, 0x68, 0x02, 0x38, 0x02, 0x18, 0x02, // 90
+	0x00, 0x00, 0xF8, 0x0F, 0x08, 0x08, // 91
+	0x18, 0x00, 0xE0, 0x00, 0x00, 0x03, // 92
+	0x08, 0x08, 0xF8, 0x0F, // 93
+	0x40, 0x00, 0x30, 0x00, 0x08, 0x00, 0x30, 0x00, 0x40, // 94
+	0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, // 95
+	0x08, 0x00, 0x10, // 96
+	0x00, 0x00, 0x00, 0x03, 0xA0, 0x02, 0xA0, 0x02, 0xE0, 0x03, // 97
+	0x00, 0x00, 0xF8, 0x03, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01, // 98
+	0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0x40, 0x01, // 99
+	0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0xF8, 0x03, // 100
+	0x00, 0x00, 0xC0, 0x01, 0xA0, 0x02, 0xA0, 0x02, 0xC0, 0x02, // 101
+	0x20, 0x00, 0xF0, 0x03, 0x28, // 102
+	0x00, 0x00, 0xC0, 0x05, 0x20, 0x0A, 0x20, 0x0A, 0xE0, 0x07, // 103
+	0x00, 0x00, 0xF8, 0x03, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x03, // 104
+	0x00, 0x00, 0xE8, 0x03, // 105
+	0x00, 0x08, 0xE8, 0x07, // 106
+	0xF8, 0x03, 0x80, 0x00, 0xC0, 0x01, 0x20, 0x02, // 107
+	0x00, 0x00, 0xF8, 0x03, // 108
+	0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x03, // 109
+	0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x03, // 110
+	0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01, // 111
+	0x00, 0x00, 0xE0, 0x0F, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01, // 112
+	0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0xE0, 0x0F, // 113
+	0x00, 0x00, 0xE0, 0x03, 0x20, // 114
+	0x40, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0x20, 0x01, // 115
+	0x20, 0x00, 0xF8, 0x03, 0x20, 0x02, // 116
+	0x00, 0x00, 0xE0, 0x01, 0x00, 0x02, 0x00, 0x02, 0xE0, 0x03, // 117
+	0x20, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x20, // 118
+	0xE0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x20, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xE0, 0x01, // 119
+	0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02, // 120
+	0x20, 0x00, 0xC0, 0x09, 0x00, 0x06, 0xC0, 0x01, 0x20, // 121
+	0x20, 0x02, 0x20, 0x03, 0xA0, 0x02, 0x60, 0x02, 0x20, 0x02, // 122
+	0x80, 0x00, 0x78, 0x0F, 0x08, 0x08, // 123
+	0x00, 0x00, 0xF8, 0x0F, // 124
+	0x08, 0x08, 0x78, 0x0F, 0x80, // 125
+	0xC0, 0x00, 0x40, 0x00, 0xC0, 0x00, 0x80, 0x00, 0xC0, // 126
+	0x00, 0x00, 0xA0, 0x0F, // 161
+	0x00, 0x00, 0xC0, 0x01, 0xA0, 0x0F, 0x78, 0x02, 0x40, 0x01, // 162
+	0x40, 0x02, 0x70, 0x03, 0xC8, 0x02, 0x48, 0x02, 0x08, 0x02, 0x10, 0x02, // 163
+	0x00, 0x00, 0xE0, 0x01, 0x20, 0x01, 0x20, 0x01, 0xE0, 0x01, // 164
+	0x48, 0x01, 0x70, 0x01, 0xC0, 0x03, 0x70, 0x01, 0x48, 0x01, // 165
+	0x00, 0x00, 0x38, 0x0F, // 166
+	0xD0, 0x04, 0x28, 0x09, 0x48, 0x09, 0x48, 0x0A, 0x90, 0x05, // 167
+	0x00, 0x00, 0xE0, 0x03, 0xA8, 0x02, 0xA0, 0x02, 0xA8, 0x02, 0x20, 0x02, // 168
+	0xE0, 0x00, 0x10, 0x01, 0x48, 0x02, 0xA8, 0x02, 0xA8, 0x02, 0x10, 0x01, 0xE0, // 169
+	0x68, 0x00, 0x68, 0x00, 0x68, 0x00, 0x78, // 170
+	0x00, 0x00, 0x80, 0x01, 0x40, 0x02, 0x80, 0x01, 0x40, 0x02, // 171
+	0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, // 172
+	0x80, 0x00, 0x80, // 173
+	0xE0, 0x00, 0x10, 0x01, 0xE8, 0x02, 0x68, 0x02, 0xC8, 0x02, 0x10, 0x01, 0xE0, // 174
+	0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, // 175
+	0x00, 0x00, 0x38, 0x00, 0x28, 0x00, 0x38, // 176
+	0x40, 0x02, 0x40, 0x02, 0xF0, 0x03, 0x40, 0x02, 0x40, 0x02, // 177
+	0x48, 0x00, 0x68, 0x00, 0x58, // 178
+	0x48, 0x00, 0x58, 0x00, 0x68, // 179
+	0x00, 0x00, 0x10, 0x00, 0x08, // 180
+	0x00, 0x00, 0xE0, 0x0F, 0x00, 0x02, 0x00, 0x02, 0xE0, 0x03, // 181
+	0x70, 0x00, 0xF8, 0x0F, 0x08, 0x00, 0xF8, 0x0F, 0x08, // 182
+	0x00, 0x00, 0x40, // 183
+	0x00, 0x00, 0xC0, 0x01, 0xA8, 0x02, 0xA0, 0x02, 0xA8, 0x02, 0xC0, // 184
+	0x00, 0x00, 0xF0, 0x03, 0x40, 0x00, 0x80, 0x00, 0xF8, 0x03, 0x08, // 185
+	0x30, 0x00, 0x48, 0x00, 0x48, 0x00, 0x30, // 186
+	0x00, 0x00, 0x40, 0x02, 0x80, 0x01, 0x40, 0x02, 0x80, 0x01, // 187
+	0x00, 0x00, 0x10, 0x02, 0x78, 0x01, 0xC0, 0x00, 0x20, 0x01, 0x90, 0x01, 0xC8, 0x03, 0x00, 0x01, // 188
+	0x00, 0x00, 0x10, 0x02, 0x78, 0x01, 0x80, 0x00, 0x60, 0x00, 0x50, 0x02, 0x48, 0x03, 0xC0, 0x02, // 189
+	0x48, 0x00, 0x58, 0x00, 0x68, 0x03, 0x80, 0x00, 0x60, 0x01, 0x90, 0x01, 0xC8, 0x03, 0x00, 0x01, // 190
+	0x00, 0x00, 0x00, 0x06, 0x00, 0x09, 0xA0, 0x09, 0x00, 0x04, // 191
+	0x00, 0x00, 0xF0, 0x03, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0xF0, 0x03, // 192
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x88, 0x01, // 193
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01, // 194
+	0x00, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x18, // 195
+	0x00, 0x00, 0x00, 0x02, 0xFC, 0x03, 0x04, 0x02, 0xFC, 0x03, 0x00, 0x02, // 196
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0x08, 0x02, // 197
+	0x00, 0x00, 0xB8, 0x03, 0x40, 0x00, 0xF8, 0x03, 0x40, 0x00, 0xB8, 0x03, // 198
+	0x00, 0x00, 0x08, 0x02, 0x48, 0x02, 0x48, 0x02, 0x48, 0x02, 0xB0, 0x01, // 199
+	0x00, 0x00, 0xF8, 0x03, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0xF8, 0x03, // 200
+	0x00, 0x00, 0xE0, 0x03, 0x08, 0x01, 0x90, 0x00, 0x48, 0x00, 0xE0, 0x03, // 201
+	0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x08, 0x02, // 202
+	0x00, 0x00, 0x00, 0x02, 0xF0, 0x01, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, // 203
+	0x00, 0x00, 0xF8, 0x03, 0x10, 0x00, 0x60, 0x00, 0x10, 0x00, 0xF8, 0x03, // 204
+	0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03, // 205
+	0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF0, 0x01, // 206
+	0x00, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, // 207
+	0x00, 0x00, 0xF8, 0x03, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x30, // 208
+	0x00, 0x00, 0xF0, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01, // 209
+	0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, 0x08, 0x00, 0x08, // 210
+	0x00, 0x00, 0x38, 0x00, 0x40, 0x02, 0x40, 0x02, 0x40, 0x02, 0xF8, 0x01, // 211
+	0x00, 0x00, 0x70, 0x00, 0x88, 0x00, 0xF8, 0x03, 0x88, 0x00, 0x70, // 212
+	0x00, 0x00, 0x18, 0x03, 0xA0, 0x00, 0x40, 0x00, 0xA0, 0x00, 0x18, 0x03, // 213
+	0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x02, // 214
+	0x00, 0x00, 0x38, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03, // 215
+	0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, // 216
+	0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x02, 0xF8, 0x03, 0x00, 0x06, // 217
+	0x00, 0x00, 0x08, 0x00, 0xF8, 0x03, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01, // 218
+	0x00, 0x00, 0xF8, 0x03, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01, 0xF8, 0x03, // 219
+	0x00, 0x00, 0xF8, 0x03, 0x40, 0x02, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01, // 220
+	0x00, 0x00, 0x10, 0x01, 0x08, 0x02, 0x48, 0x02, 0x48, 0x02, 0xF0, 0x01, // 221
+	0x00, 0x00, 0xF8, 0x03, 0x40, 0x00, 0xF0, 0x01, 0x08, 0x02, 0xF0, 0x01, // 222
+	0x00, 0x00, 0x30, 0x02, 0x48, 0x01, 0xC8, 0x00, 0x48, 0x00, 0xF8, 0x03, // 223
+	0x00, 0x00, 0x00, 0x01, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xC0, 0x03, // 224
+	0x00, 0x00, 0xE0, 0x01, 0x50, 0x02, 0x50, 0x02, 0x48, 0x02, 0x88, 0x01, // 225
+	0x00, 0x00, 0xE0, 0x03, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0x40, 0x01, // 226
+	0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x60, // 227
+	0x00, 0x00, 0x00, 0x02, 0xC0, 0x03, 0x20, 0x02, 0xE0, 0x03, 0x00, 0x02, // 228
+	0x00, 0x00, 0xC0, 0x01, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xC0, // 229
+	0x00, 0x00, 0x60, 0x03, 0x80, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x60, 0x03, // 230
+	0x00, 0x00, 0x20, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0x40, 0x01, // 231
+	0x00, 0x00, 0xE0, 0x03, 0x00, 0x01, 0x80, 0x00, 0x40, 0x00, 0xE0, 0x03, // 232
+	0x00, 0x00, 0xE0, 0x03, 0x00, 0x01, 0x98, 0x00, 0x40, 0x00, 0xE0, 0x03, // 233
+	0x00, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02, // 234
+	0x00, 0x00, 0x00, 0x02, 0xC0, 0x01, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03, // 235
+	0x00, 0x00, 0xE0, 0x03, 0x40, 0x00, 0x80, 0x00, 0x40, 0x00, 0xE0, 0x03, // 236
+	0x00, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xE0, 0x03, // 237
+	0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0xC0, 0x01, // 238
+	0x00, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03, // 239
+	0x00, 0x00, 0xE0, 0x03, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x40, // 240
+	0x00, 0x00, 0xC0, 0x01, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x40, 0x02, // 241
+	0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x03, 0x20, 0x00, 0x20, // 242
+	0x00, 0x00, 0x60, 0x00, 0x80, 0x02, 0x80, 0x02, 0x80, 0x02, 0xE0, 0x01, // 243
+	0x00, 0x00, 0xC0, 0x00, 0x20, 0x01, 0xE0, 0x03, 0x20, 0x01, 0xC0, // 244
+	0x00, 0x00, 0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02, // 245
+	0x00, 0x00, 0xE0, 0x03, 0x00, 0x02, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x02, // 246
+	0x00, 0x00, 0x60, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xE0, 0x03, // 247
+	0x00, 0x00, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, // 248
+	0x00, 0x00, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x02, 0xE0, 0x03, 0x00, 0x06, // 249
+	0x00, 0x00, 0x20, 0x00, 0xE0, 0x03, 0x80, 0x02, 0x80, 0x02, 0x00, 0x01, // 250
+	0x00, 0x00, 0xE0, 0x03, 0x80, 0x02, 0x80, 0x02, 0x00, 0x01, 0xE0, 0x03, // 251
+	0x00, 0x00, 0xE0, 0x03, 0x80, 0x02, 0x80, 0x02, 0x80, 0x02, 0x00, 0x01, // 252
+	0x00, 0x00, 0x40, 0x01, 0x20, 0x02, 0xA0, 0x02, 0xA0, 0x02, 0xC0, 0x01, // 253
+	0x00, 0x00, 0xE0, 0x03, 0x80, 0x00, 0xC0, 0x01, 0x20, 0x02, 0xC0, 0x01, // 254
+	0x00, 0x00, 0x40, 0x02, 0xA0, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0xE0, 0x03, // 255
+};

src/graphics/fonts/OLEDDisplayFontsRU.h

@@ -0,0 +1,11 @@
+#ifndef OLEDDISPLAYFONTSRU_h
+#define OLEDDISPLAYFONTSRU_h
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#elif __MBED__
+#define PROGMEM
+#endif
+
+extern const uint8_t ArialMT_Plain_10_RU[] PROGMEM;
+#endif

src/input/InputBroker.h

@@ -1,9 +1,13 @@
 #pragma once
 #include "Observer.h"
 
+#define ANYKEY 0xFF
+#define MATRIXKEY 0xFE
+
 typedef struct _InputEvent {
     const char* source;
     char inputEvent;
+    char kbchar;
 } InputEvent;
 class InputBroker :
     public Observable<const InputEvent *>

src/input/RotaryEncoderInterruptBase.cpp

@@ -34,7 +34,7 @@ void RotaryEncoderInterruptBase::init(
 int32_t RotaryEncoderInterruptBase::runOnce()
 {
     InputEvent e;
-    e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
+    e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
     e.source = this->_originName;
 
     if (this->action == ROTARY_ACTION_PRESSED) {
@@ -48,7 +48,7 @@ int32_t RotaryEncoderInterruptBase::runOnce()
         e.inputEvent = this->_eventCcw;
     }
 
-    if (e.inputEvent != ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE) {
+    if (e.inputEvent != ModuleConfig_CannedMessageConfig_InputEventChar_NONE) {
         this->notifyObservers(&e);
     }
 

src/input/RotaryEncoderInterruptBase.h

@@ -33,8 +33,8 @@ class RotaryEncoderInterruptBase : public Observable<const InputEvent *>, privat
   private:
     uint8_t _pinA = 0;
     uint8_t _pinB = 0;
-    char _eventCw = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
-    char _eventCcw = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
-    char _eventPressed = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
+    char _eventCw = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventCcw = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventPressed = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
     const char *_originName;
 };

src/input/UpDownInterruptBase.h

@@ -16,8 +16,8 @@ class UpDownInterruptBase : public Observable<const InputEvent *>
   private:
     uint8_t _pinDown = 0;
     uint8_t _pinUp = 0;
-    char _eventDown = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
-    char _eventUp = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
-    char _eventPressed = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
+    char _eventDown = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventUp = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+    char _eventPressed = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
     const char *_originName;
 };

src/input/UpDownInterruptImpl1.cpp

@@ -17,9 +17,9 @@ void UpDownInterruptImpl1::init()
     uint8_t pinDown = moduleConfig.canned_message.inputbroker_pin_b;
     uint8_t pinPress = moduleConfig.canned_message.inputbroker_pin_press;
 
-    char eventDown = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_DOWN);
-    char eventUp = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_UP);
-    char eventPressed = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_SELECT);
+    char eventDown = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_DOWN);
+    char eventUp = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_UP);
+    char eventPressed = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_SELECT);
 
     UpDownInterruptBase::init(pinDown, pinUp, pinPress, eventDown, eventUp, eventPressed, UpDownInterruptImpl1::handleIntDown,
                               UpDownInterruptImpl1::handleIntUp, UpDownInterruptImpl1::handleIntPressed);

src/input/cardKbI2cImpl.cpp

@@ -16,6 +16,5 @@ void CardKbI2cImpl::init()
         return;
     }
 
-    DEBUG_MSG("registerSource\n");
     inputBroker->registerSource(this);
 }

src/input/facesKbI2cImpl.cpp

@@ -1,20 +0,0 @@
-#include "facesKbI2cImpl.h"
-#include "InputBroker.h"
-
-FacesKbI2cImpl *facesKbI2cImpl;
-
-FacesKbI2cImpl::FacesKbI2cImpl() :
-    KbI2cBase("facesKB")
-{
-}
-
-void FacesKbI2cImpl::init()
-{
-    if (faceskb_found != FACESKB_ADDR)
-    {
-        // Input device is not detected.
-        return;
-    }
-
-    inputBroker->registerSource(this);
-}

src/input/facesKbI2cImpl.h

@@ -1,20 +0,0 @@
-#pragma once
-#include "kbI2cBase.h"
-#include "main.h"
-
-/**
- * @brief The idea behind this class to have static methods for the event handlers.
- *      Check attachInterrupt() at RotaryEncoderInteruptBase.cpp
- *      Technically you can have as many rotary encoders hardver attached
- *      to your device as you wish, but you always need to have separate event
- *      handlers, thus you need to have a RotaryEncoderInterrupt implementation.
- */
-class FacesKbI2cImpl :
-    public KbI2cBase
-{
-  public:
-    FacesKbI2cImpl();
-    void init();
-};
-
-extern FacesKbI2cImpl *facesKbI2cImpl;

src/input/kbI2cBase.cpp

@@ -2,48 +2,114 @@
 #include "configuration.h"
 #include <Wire.h>
 
+extern uint8_t cardkb_found;
+extern uint8_t kb_model;
+
 KbI2cBase::KbI2cBase(const char *name) : concurrency::OSThread(name)
 {
     this->_originName = name;
 }
 
+uint8_t read_from_14004(uint8_t reg, uint8_t *data, uint8_t length)
+{
+  uint8_t readflag = 0;
+  Wire.beginTransmission(CARDKB_ADDR);
+  Wire.write(reg);
+  Wire.endTransmission();    // stop transmitting
+  delay(20);
+  Wire.requestFrom(CARDKB_ADDR, (int)length);
+  int i = 0;
+  while ( Wire.available() ) // slave may send less than requested
+  {
+    data[i++] = Wire.read(); // receive a byte as a proper uint8_t
+    readflag = 1;
+  }
+  return readflag;
+}
+
+void write_to_14004(uint8_t reg, uint8_t data)
+{
+  Wire.beginTransmission(CARDKB_ADDR);
+  Wire.write(reg);
+  Wire.write(data);
+  Wire.endTransmission();    // stop transmitting
+}
+
 int32_t KbI2cBase::runOnce()
 {
-    InputEvent e;
-    e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE;
-    e.source = this->_originName;
-
-    Wire.requestFrom(CARDKB_ADDR, 1);
-
-    while (Wire.available()) {
-        char c = Wire.read();
-        switch (c) {
-        case 0x1b: // ESC
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_CANCEL;
-            break;
-        case 0x08: // Back
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_BACK;
-            break;
-        case 0xb5: // Up
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_UP;
-            break;
-        case 0xb6: // Down
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_DOWN;
-            break;
-        case 0xb4: // Left
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_LEFT;
-            break;
-        case 0xb7: // Right
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_RIGHT;
-            break;
-        case 0x0d: // Enter
-            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_KEY_SELECT;
-            break;
-        }
+    if (cardkb_found != CARDKB_ADDR){
+        // Input device is not detected.
+        return INT32_MAX;
     }
 
-    if (e.inputEvent != ModuleConfig_CannedMessageConfig_InputEventChar_KEY_NONE) {
-        this->notifyObservers(&e);
+    if (kb_model == 0x02) {
+        // RAK14004
+        uint8_t rDataBuf[8] = {0};
+        uint8_t PrintDataBuf = 0;
+        if (read_from_14004(0x01, rDataBuf, 0x04) == 1) {
+            for (uint8_t aCount = 0; aCount < 0x04; aCount++) {
+                for (uint8_t bCount = 0; bCount < 0x04; bCount++ ) {
+                    if (((rDataBuf[aCount] >> bCount) & 0x01) == 0x01) {
+                        PrintDataBuf = aCount * 0x04 + bCount + 1;
+                    }
+                }
+            }
+        }
+        if (PrintDataBuf != 0) {
+            DEBUG_MSG("RAK14004 key 0x%x pressed\n", PrintDataBuf);
+            InputEvent e;
+            e.inputEvent = MATRIXKEY;
+            e.source = this->_originName;
+            e.kbchar = PrintDataBuf;
+            this->notifyObservers(&e);
+        }
+    } else {
+        // m5 cardkb
+        Wire.requestFrom(CARDKB_ADDR, 1);
+
+        while (Wire.available()) {
+            char c = Wire.read();
+            InputEvent e;
+            e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+            e.source = this->_originName;
+            switch (c) {
+            case 0x1b: // ESC
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL;
+                break;
+            case 0x08: // Back
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_BACK;
+                e.kbchar = c;
+                break;
+            case 0xb5: // Up
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_UP;
+                break;
+            case 0xb6: // Down
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_DOWN;
+                break;
+            case 0xb4: // Left
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_LEFT;
+                e.kbchar = c;
+                break;
+            case 0xb7: // Right
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT;
+                e.kbchar = c;
+                break;
+            case 0x0d: // Enter
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_SELECT;
+                break;
+            case 0x00: //nopress
+                e.inputEvent = ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+                break;
+            default: // all other keys
+                e.inputEvent = ANYKEY;
+                e.kbchar = c;
+                break;
+            }
+
+            if (e.inputEvent != ModuleConfig_CannedMessageConfig_InputEventChar_NONE) {
+                this->notifyObservers(&e);
+            }
+        }
     }
     return 500;
 }

src/main.cpp

@@ -17,9 +17,9 @@
 #include "SPILock.h"
 #include "concurrency/OSThread.h"
 #include "concurrency/Periodic.h"
-#include "debug/axpDebug.h"
-#include "debug/einkScan.h"
-#include "debug/i2cScan.h"
+#include "detect/axpDebug.h"
+#include "detect/einkScan.h"
+#include "detect/i2cScan.h"
 #include "graphics/Screen.h"
 #include "main.h"
 #include "modules/Modules.h"
@@ -30,29 +30,35 @@
 // #include <driver/rtc_io.h>
 
 #include "mesh/http/WiFiAPClient.h"
+#include "mesh/eth/ethClient.h"
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
 #include "mesh/http/WebServer.h"
-
-#ifdef USE_NEW_ESP32_BLUETOOTH
-#include "esp32/ESP32Bluetooth.h"
-#else
-#include "nimble/BluetoothUtil.h"
+#include "nimble/NimbleBluetooth.h"
 #endif
 
-#endif
-
-#if defined(HAS_WIFI) || defined(PORTDUINO)
+#if HAS_WIFI
 #include "mesh/wifi/WiFiServerAPI.h"
 #include "mqtt/MQTT.h"
 #endif
 
+#if HAS_ETHERNET
+#include "mesh/eth/ethServerAPI.h"
+#include "mqtt/MQTT.h"
+#endif
+
 #include "LLCC68Interface.h"
 #include "RF95Interface.h"
 #include "SX1262Interface.h"
 #include "SX1268Interface.h"
+#include "SX1280Interface.h"
+#if !HAS_RADIO && defined(ARCH_PORTDUINO)
+#include "platform/portduino/SimRadio.h"
+#endif
 
+#if HAS_BUTTON
 #include "ButtonThread.h"
+#endif
 #include "PowerFSMThread.h"
 
 using namespace concurrency;
@@ -78,20 +84,23 @@ uint8_t cardkb_found;
 // 0x02 for RAK14004 and 0x00 for cardkb
 uint8_t kb_model;
 
-// The I2C address of the Faces Keyboard (if found)
-uint8_t faceskb_found;
-
 // The I2C address of the RTC Module (if found)
 uint8_t rtc_found;
 
+// Keystore Chips
+uint8_t keystore_found;
+#ifndef ARCH_PORTDUINO
+ATECCX08A atecc;
+#endif
+
 bool eink_found = true;
 
 uint32_t serialSinceMsec;
 
-bool axp192_found;
+bool pmu_found;
 
 // Array map of sensor types (as array index) and i2c address as value we'll find in the i2c scan
-uint8_t nodeTelemetrySensorsMap[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+uint8_t nodeTelemetrySensorsMap[_TelemetrySensorType_MAX + 1] = { 0 }; // one is enough, missing elements will be initialized to 0 anyway.
 
 Router *router = NULL; // Users of router don't care what sort of subclass implements that API
 
@@ -126,11 +135,16 @@ static int32_t ledBlinker()
 
 uint32_t timeLastPowered = 0;
 
+#if HAS_BUTTON
 bool ButtonThread::shutdown_on_long_stop = false;
+#endif
 
 static Periodic *ledPeriodic;
-static OSThread *powerFSMthread, *buttonThread;
+static OSThread *powerFSMthread;
+#if HAS_BUTTON
+static OSThread *buttonThread;
 uint32_t ButtonThread::longPressTime = 0;
+#endif
 
 RadioInterface *rIf = NULL;
 
@@ -157,9 +171,7 @@ void setup()
 #endif
 
 #ifdef DEBUG_PORT
-    if (!config.device.serial_disabled) {
         consoleInit(); // Set serial baud rate and init our mesh console
-    }
 #endif
 
     serialSinceMsec = millis();
@@ -184,10 +196,8 @@ void setup()
     digitalWrite(RESET_OLED, 1);
 #endif
 
-    bool forceSoftAP = 0;
-
 #ifdef BUTTON_PIN
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
 
     // If the button is connected to GPIO 12, don't enable the ability to use
     // meshtasticAdmin on the device.
@@ -198,12 +208,6 @@ void setup()
     delay(10);
 #endif
 
-    // BUTTON_PIN is pulled high by a 12k resistor.
-    if (!digitalRead(BUTTON_PIN)) {
-        forceSoftAP = 1;
-        DEBUG_MSG("Setting forceSoftAP = 1\n");
-    }
-
 #endif
 #endif
 
@@ -216,9 +220,13 @@ void setup()
     // router = new DSRRouter();
     router = new ReliableRouter();
 
+#ifdef I2C_SDA1
+    Wire1.begin(I2C_SDA1, I2C_SCL1);
+#endif
+
 #ifdef I2C_SDA
     Wire.begin(I2C_SDA, I2C_SCL);
-#elif !defined(NO_WIRE)
+#elif HAS_WIRE
     Wire.begin();
 #endif
 
@@ -231,13 +239,46 @@ void setup()
     delay(1);
 #endif
 
+#ifdef RAK4630
+    // We need to enable 3.3V periphery in order to scan it
+    pinMode(PIN_3V3_EN, OUTPUT);
+    digitalWrite(PIN_3V3_EN, 1);
+#endif
+
+
+    // Currently only the tbeam has a PMU
+    // PMU initialization needs to be placed before scanI2Cdevice
+    power = new Power();
+    power->setStatusHandler(powerStatus);
+    powerStatus->observe(&power->newStatus);
+    power->setup(); // Must be after status handler is installed, so that handler gets notified of the initial configuration
+
+
+#ifdef LILYGO_TBEAM_S3_CORE
+    // In T-Beam-S3-core, the I2C device cannot be scanned before power initialization, otherwise the device will be stuck
+    // PCF8563 RTC in tbeam-s3 uses Wire1 to share I2C bus
+    Wire1.beginTransmission(PCF8563_RTC);
+    if (Wire1.endTransmission() == 0){
+        rtc_found = PCF8563_RTC;
+        DEBUG_MSG("PCF8563 RTC found\n");
+    }
+#endif
+
+    // We need to scan here to decide if we have a screen for nodeDB.init()
     scanI2Cdevice();
+
+#ifdef HAS_SDCARD
+    setupSDCard();
+#endif
+
 #ifdef RAK4630
     // scanEInkDevice();
 #endif
 
+#if HAS_BUTTON
     // Buttons & LED
     buttonThread = new ButtonThread();
+#endif
 
 #ifdef LED_PIN
     pinMode(LED_PIN, OUTPUT);
@@ -247,7 +288,7 @@ void setup()
     // Hello
     DEBUG_MSG("Meshtastic hwvendor=%d, swver=%s\n", HW_VENDOR, optstr(APP_VERSION));
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
     // Don't init display if we don't have one or we are waking headless due to a timer event
     if (wakeCause == ESP_SLEEP_WAKEUP_TIMER)
         screen_found = 0; // forget we even have the hardware
@@ -255,23 +296,22 @@ void setup()
     esp32Setup();
 #endif
 
-#ifdef NRF52_SERIES
+#ifdef ARCH_NRF52
     nrf52Setup();
 #endif
-    playStartMelody();
     // We do this as early as possible because this loads preferences from flash
     // but we need to do this after main cpu iniot (esp32setup), because we need the random seed set
     nodeDB.init();
 
-    // Currently only the tbeam has a PMU
-    power = new Power();
-    power->setStatusHandler(powerStatus);
-    powerStatus->observe(&power->newStatus);
-    power->setup(); // Must be after status handler is installed, so that handler gets notified of the initial configuration
+    playStartMelody();
+
+    // fixed screen override?
+    if (config.display.oled != Config_DisplayConfig_OledType_OLED_AUTO)
+        screen_model = config.display.oled;
 
     // Init our SPI controller (must be before screen and lora)
     initSPI();
-#ifdef NO_ESP32
+#ifndef ARCH_ESP32
     SPI.begin();
 #else
     // ESP32
@@ -299,14 +339,14 @@ void setup()
     setupModules();
 
     // Do this after service.init (because that clears error_code)
-#ifdef AXP192_SLAVE_ADDRESS
-    if (!axp192_found)
-        RECORD_CRITICALERROR(CriticalErrorCode_NoAXP192); // Record a hardware fault for missing hardware
+#ifdef HAS_PMU
+    if (!pmu_found)
+        RECORD_CRITICALERROR(CriticalErrorCode_NO_AXP192); // Record a hardware fault for missing hardware
 #endif
 
         // Don't call screen setup until after nodedb is setup (because we need
         // the current region name)
-#if defined(ST7735_CS) || defined(HAS_EINK) || defined(ILI9341_DRIVER)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER)
     screen->setup();
 #else
     if (screen_found)
@@ -322,7 +362,7 @@ void setup()
         DEBUG_MSG("GPS FactoryReset requested\n");
         if (gps->factoryReset()) { // If we don't succeed try again next time
             devicestate.did_gps_reset = true;
-            nodeDB.saveToDisk();
+            nodeDB.saveToDisk(SEGMENT_DEVICESTATE);
         }
     }
 
@@ -347,6 +387,19 @@ void setup()
     }
 #endif
 
+#if defined(USE_SX1280) && !defined(ARCH_PORTDUINO)
+    if (!rIf) {
+        rIf = new SX1280Interface(SX128X_CS, SX128X_DIO1, SX128X_RESET, SX128X_BUSY, SPI);
+        if (!rIf->init()) {
+            DEBUG_MSG("Warning: Failed to find SX1280 radio\n");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            DEBUG_MSG("SX1280 Radio init succeeded, using SX1280 radio\n");
+        }
+    }
+#endif
+
 #if defined(USE_SX1262)
     if (!rIf) {
         rIf = new SX1262Interface(SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY, SPI);
@@ -386,7 +439,7 @@ void setup()
     }
 #endif
 
-#ifdef USE_SIM_RADIO
+#ifdef ARCH_PORTDUINO
     if (!rIf) {
         rIf = new SimRadio;
         if (!rIf->init()) {
@@ -399,27 +452,32 @@ void setup()
     }
 #endif
 
-#if defined(PORTDUINO) || defined(HAS_WIFI)
+#if HAS_WIFI || HAS_ETHERNET
     mqttInit();
 #endif
 
+#ifndef ARCH_PORTDUINO
     // Initialize Wifi
-    initWifi(forceSoftAP);
+    initWifi();
 
-#ifndef NO_ESP32
+    // Initialize Ethernet
+    initEthernet();
+#endif
+
+#ifdef ARCH_ESP32
     // Start web server thread.
     webServerThread = new WebServerThread();
 #endif
 
-#ifdef PORTDUINO
-    initApiServer();
+#ifdef ARCH_PORTDUINO
+    initApiServer(TCPPort);
 #endif
 
     // Start airtime logger thread.
     airTime = new AirTime();
 
     if (!rIf)
-        RECORD_CRITICALERROR(CriticalErrorCode_NoRadio);
+        RECORD_CRITICALERROR(CriticalErrorCode_NO_RADIO);
     else {
         router->addInterface(rIf);
 
@@ -452,10 +510,10 @@ void loop()
 
     // heap_caps_check_integrity_all(true); // FIXME - disable this expensive check
 
-#ifndef NO_ESP32
+#ifdef ARCH_ESP32
     esp32Loop();
 #endif
-#ifdef NRF52_SERIES
+#ifdef ARCH_NRF52
     nrf52Loop();
 #endif
     powerCommandsCheck();

src/main.h

@@ -6,20 +6,29 @@
 #include "PowerStatus.h"
 #include "graphics/Screen.h"
 #include "mesh/generated/telemetry.pb.h"
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+#include <SparkFun_ATECCX08a_Arduino_Library.h>
+#endif
 
 extern uint8_t screen_found;
 extern uint8_t screen_model;
 extern uint8_t cardkb_found;
 extern uint8_t kb_model;
-extern uint8_t faceskb_found;
 extern uint8_t rtc_found;
+extern uint8_t keystore_found;
 
 extern bool eink_found;
-extern bool axp192_found;
+extern bool pmu_found;
 extern bool isCharging;
 extern bool isUSBPowered;
 
-extern uint8_t nodeTelemetrySensorsMap[12];
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+extern ATECCX08A atecc;
+#endif
+
+extern uint8_t nodeTelemetrySensorsMap[_TelemetrySensorType_MAX + 1];
+
+extern int TCPPort; // set by Portduino
 
 // Global Screen singleton.
 extern graphics::Screen *screen;

src/mesh/Channels.cpp

@@ -62,13 +62,6 @@ Channel &Channels::fixupChannel(ChannelIndex chIndex)
         // Convert the old string "Default" to our new short representation
         if (strcmp(channelSettings.name, "Default") == 0)
             *channelSettings.name = '\0';
-
-        /* Convert any old usage of the defaultpsk into our new short representation.
-        if (channelSettings.psk.size == sizeof(defaultpsk) &&
-            memcmp(channelSettings.psk.bytes, defaultpsk, sizeof(defaultpsk)) == 0) {
-            *channelSettings.psk.bytes = 1;
-            channelSettings.psk.size = 1;
-        } */
     }
 
     hashes[chIndex] = generateHash(chIndex);
@@ -85,8 +78,8 @@ void Channels::initDefaultChannel(ChannelIndex chIndex)
     ChannelSettings &channelSettings = ch.settings;
     Config_LoRaConfig &loraConfig = config.lora;
 
-    loraConfig.modem_preset = Config_LoRaConfig_ModemPreset_LongFast; // Default to Long Range & Fast
-
+    loraConfig.modem_preset = Config_LoRaConfig_ModemPreset_LONG_FAST; // Default to Long Range & Fast
+    loraConfig.use_preset = true;
     loraConfig.tx_power = 0; // default
     uint8_t defaultpskIndex = 1;
     channelSettings.psk.bytes[0] = defaultpskIndex;
@@ -124,7 +117,22 @@ CryptoKey Channels::getKey(ChannelIndex chIndex)
             DEBUG_MSG("Expanding short PSK #%d\n", pskIndex);
             if (pskIndex == 0)
                 k.length = 0; // Turn off encryption
-            else {
+            else if (oemStore.oem_aes_key.size > 1) {
+                // Use the OEM key
+                DEBUG_MSG("Using OEM Key with %d bytes\n", oemStore.oem_aes_key.size);
+                memcpy(k.bytes, oemStore.oem_aes_key.bytes , oemStore.oem_aes_key.size);
+                k.length = oemStore.oem_aes_key.size;
+                // Bump up the last byte of PSK as needed
+                uint8_t *last = k.bytes + oemStore.oem_aes_key.size - 1;
+                *last = *last + pskIndex - 1; // index of 1 means no change vs defaultPSK
+                if (k.length < 16) {
+                    DEBUG_MSG("Warning: OEM provided a too short AES128 key - padding\n");
+                    k.length = 16;
+                } else if (k.length < 32 && k.length != 16) {
+                    DEBUG_MSG("Warning: OEM provided a too short AES256 key - padding\n");
+                    k.length = 32;
+                }
+            } else {
                 memcpy(k.bytes, defaultpsk, sizeof(defaultpsk));
                 k.length = sizeof(defaultpsk);
                 // Bump up the last byte of PSK as needed
@@ -210,35 +218,37 @@ const char *Channels::getName(size_t chIndex)
         // Per mesh.proto spec, if bandwidth is specified we must ignore modemPreset enum, we assume that in that case
         // the app fucked up and forgot to set channelSettings.name
 
-        if (config.lora.bandwidth != 0)
-            channelName = "Custom";
-        else
+        if (config.lora.use_preset) {
             switch (config.lora.modem_preset) {
-            case Config_LoRaConfig_ModemPreset_ShortSlow:
-                channelName = "ShortS";
+            case Config_LoRaConfig_ModemPreset_SHORT_SLOW:
+                channelName = "ShortSlow";
                 break;
-            case Config_LoRaConfig_ModemPreset_ShortFast:
-                channelName = "ShortF";
+            case Config_LoRaConfig_ModemPreset_SHORT_FAST:
+                channelName = "ShortFast";
                 break;
-            case Config_LoRaConfig_ModemPreset_MedSlow:
-                channelName = "MedS";
+            case Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
+                channelName = "MediumSlow";
                 break;
-            case Config_LoRaConfig_ModemPreset_MedFast:
-                channelName = "MedF";
+            case Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+                channelName = "MediumFast";
                 break;
-            case Config_LoRaConfig_ModemPreset_LongSlow:
-                channelName = "LongS";
+            case Config_LoRaConfig_ModemPreset_LONG_SLOW:
+                channelName = "LongSlow";
                 break;
-            case Config_LoRaConfig_ModemPreset_LongFast:
-                channelName = "LongF";
+            case Config_LoRaConfig_ModemPreset_LONG_FAST:
+                channelName = "LongFast";
                 break;
-            case Config_LoRaConfig_ModemPreset_VLongSlow:
-                channelName = "VeryL";
+            case Config_LoRaConfig_ModemPreset_VERY_LONG_SLOW:
+                channelName = "VLongSlow";
                 break;
             default:
                 channelName = "Invalid";
                 break;
             }
+        }
+        else {
+            channelName = "Custom";
+        }
     }
 
     return channelName;
@@ -257,7 +267,7 @@ their nodes
 *
 * This function will also need to be implemented in GUI apps that talk to the radio.
 *
-* https://github.com/meshtastic/Meshtastic-device/issues/269
+* https://github.com/meshtastic/firmware/issues/269
 */
 const char *Channels::getPrimaryName()
 {

src/mesh/Channels.h

@@ -74,7 +74,7 @@ class Channels
      *
      * This function will also need to be implemented in GUI apps that talk to the radio.
      *
-     * https://github.com/meshtastic/Meshtastic-device/issues/269
+     * https://github.com/meshtastic/firmware/issues/269
     */
     const char *getPrimaryName();