Update protobuf ref

* 2.0

* Catch the right version of the common files

.clang-format

@@ -0,0 +1,6 @@
+Language: Cpp
+IndentWidth: 4
+ColumnLimit: 130
+PointerAlignment: Right
+BreakBeforeBraces: Linux
+AllowShortFunctionsOnASingleLine: Inline

.github/ISSUE_TEMPLATE/Bug Report.yml

@@ -0,0 +1,76 @@
+name: Bug Report
+description: File a bug report
+title: "[Bug]: "
+labels: ["bug", "triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+
+  - type: dropdown
+    id: category
+    attributes:
+      label: Category
+      description: How would you catagorize this issue?
+      multiple: true
+      options:
+        - Hardware Compatibility
+        - BLE
+        - Serial
+        - WiFi
+        - Other
+    validations:
+      required: true
+
+  - type: dropdown
+    id: hardware
+    attributes:
+      label: Hardware
+      description: What hardware are you encountering this issue on?
+      multiple: true
+      options:
+        - Not Applicable
+        - T-Beam
+        - T-Beam 0.7
+        - T-Lora v1
+        - T-Lora v1.3
+        - T-Lora v2 1.6
+        - T-Echo
+        - Rak4631
+        - Rak11200
+        - Heltec v1
+        - Heltec v2
+        - Heltec v2.1
+        - Relay v1
+        - Relay v2
+        - DIY
+        - Other
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: Firmware Version
+      description: This can be found on the device's screen or via one of the apps.
+      placeholder: x.x.x.yyyyyyy
+    validations:
+      required: true
+
+  - type: textarea
+    id: body
+    attributes:
+      label: Description
+      description: Please provide details on what steps you performed for this to happen.
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: If you have any log output to help in diagnosing your bug, please provide it here.
+      render: Shell
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/New Board.yml

@@ -0,0 +1,46 @@
+name: New Board
+description: Request us to support new hardware
+title: "[Board]: "
+labels: ["enhancement", "triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for requesting a new board, this will not gurantee that we will support it, but will be on our radar.
+
+  - type: dropdown
+    id: soc
+    attributes:
+      label: SOC
+      description: What SOC does your board have?
+      multiple: true
+      options:
+        - NRF52
+        - ESP32
+        - Other
+    validations:
+      required: true
+
+  - type: input
+    id: lora
+    attributes:
+      label: Lora IC
+      description: What LoRa IC does the board have?
+    validations:
+      required: true
+      
+  - type: input
+    id: link
+    attributes:
+      label: Product Link
+      description: Where can we find this product?
+    validations:
+      required: true
+
+  - type: textarea
+    id: body
+    attributes:
+      label: Description
+      description: Please provide any further details you think we may need.
+    validations:
+      required: true

.github/pull_request_template.md

@@ -0,0 +1,13 @@
+## Thank you for sending in a pull request, here's some tips to get started!
+
+(Please delete all these tips and replace with your text)
+
+- Before starting on some new big chunk of code, it it is optional but highly recommended to open an issue first
+  to say "hey, I think this idea X should be implemented and I'm starting work on it. My general plan is Y, any feedback
+  is appreciated." This will allow other devs to potentially save you time by not accidentially duplicating work etc...
+- Please do not check in files that don't have real changes
+- Please do not reformat lines that you didn't have to change the code on
+- We recommend using the [Visual Studio Code](https://platformio.org/install/ide?install=vscode) editor and the 'clang-format' extension,
+  because automatically follows our indentation rules and it's auto reformatting will not cause spurious changes to lines.
+- If your PR fixes a bug, mention "fixes #bugnum" somewhere in your pull request description.
+- If your other co-developers have comments on your PR please tweak as needed.

.github/workflows/main.yml

@@ -1,19 +0,0 @@
-name: Continuous Integration
-on: push
-
-jobs:
-  main:
-    name: Main
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-      - name: Setup Python
-        uses: actions/setup-python@master
-        with:
-          python-version: 3.x
-      - name: Install Platform IO
-        run: |
-          python -m pip install --upgrade pip
-          pip install -U platformio
-      - name: Build
-        run: platformio run

.github/workflows/main_matrix.yml

@@ -0,0 +1,508 @@
+name: CI
+on:
+  # # Triggers the workflow on push but only for the master branch
+  push:
+    branches: [master]
+    paths-ignore:
+      - "**.md"
+      - "version.properties"
+
+  # Note: This is different from "pull_request". Need to specify ref when doing checkouts.
+  pull_request_target:
+    branches: [master]
+    paths-ignore:
+      - "**.md"
+      #- "**.yml"
+
+  workflow_dispatch:
+
+jobs:
+  check:
+    strategy:
+      fail-fast: false
+      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: meshtastic-dr-dev
+          - board: rak4631
+          - board: rak4631_eink
+          - board: t-echo
+          - board: nano-g1
+          - board: station-g1
+          - board: m5stack-core
+          - board: m5stack-coreink
+          - board: tbeam-s3-core
+        # - board: pico
+
+    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@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 and install platformio
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio
+
+      - name: Upgrade platformio
+        run: |
+          pio upgrade
+
+      - name: Check ${{ matrix.board }}
+        run: bin/check-all.sh ${{ matrix.board }}
+
+  build-esp32:
+    strategy:
+      fail-fast: false
+      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: meshtastic-dr-dev
+          - board: nano-g1
+          - board: station-g1
+          - board: m5stack-core
+          - 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: 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
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio adafruit-nrfutil
+
+      - name: Upgrade platformio
+        run: |
+          pio upgrade
+
+      - 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 ${{ matrix.board }}
+
+      - name: Pull OTA Firmware
+        uses: dsaltares/fetch-gh-release-asset@master
+        with:
+          repo: "meshtastic/Meshtastic-OTA"
+          file: "firmware.bin"
+          target: "release/bleota.bin"
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - 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-${{ matrix.board }}-${{ steps.version.outputs.version }}.zip
+          path: |
+            release/*.bin
+            release/*.elf
+          retention-days: 90
+
+  build-nrf52:
+    strategy:
+      fail-fast: false
+      max-parallel: 2
+      matrix:
+        include:
+          - board: rak4631
+          - board: rak4631_eink
+          - board: t-echo
+          - board: pca10059_diy_eink
+
+    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@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
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio adafruit-nrfutil
+
+      - name: Upgrade platformio
+        run: |
+          pio upgrade
+
+      - name: Build NRF52
+        run: bin/build-nrf52.sh ${{ matrix.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-${{ matrix.board }}-${{ steps.version.outputs.version }}.zip
+          path: |
+            release/*.uf2
+            release/*.elf
+            release/*.zip
+          retention-days: 90
+
+  build-rpi2040:
+    strategy:
+      fail-fast: false
+      max-parallel: 2
+      matrix:
+        include:
+          - board: pico
+
+    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@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
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio adafruit-nrfutil
+
+      - name: Upgrade platformio
+        run: |
+          pio upgrade
+
+      - name: Build Raspberry Pi 2040
+        run: ./bin/build-rpi2040.sh ${{ matrix.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-${{ matrix.board }}-${{ steps.version.outputs.version }}.zip
+          path: |
+            release/*.uf2
+            release/*.elf
+          retention-days: 90
+
+  build-native:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        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@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
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio adafruit-nrfutil
+          pip install -U meshtastic --pre
+
+      - name: Upgrade platformio
+        run: |
+          pio upgrade
+
+      # We now run integration test before other build steps (to quickly see runtime failures)
+      - name: Build for native
+        run: platformio run -e native
+      - name: Integration test
+        run: |
+          .pio/build/native/program &
+          sleep 20 # 5 seconds was not enough
+          echo "Simulator started, launching python test..."
+          python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
+
+      - name: Build Native
+        run: bin/build-native.sh
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: firmware-native-${{ steps.version.outputs.version }}.zip
+          path: |
+            release/meshtasticd_linux_amd64
+            release/device-*.sh
+            release/device-*.bat
+          retention-days: 90
+
+  after-checks:
+    runs-on: ubuntu-latest
+    needs: [check]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+  gather-artifacts:
+    runs-on: ubuntu-latest
+    needs: [build-esp32, build-nrf52, build-native, build-rpi2040]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - uses: actions/download-artifact@v3
+        with:
+          path: ./
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Move files up
+        run: mv -b -t ./ ./*tbeam-2*/littlefs*.bin ./*tbeam-2*/bleota.bin ./**/firmware*.bin ./*t-echo*/Meshtastic_nRF52_factory_erase.uf2 ./**/firmware-*.uf2 ./**/firmware-*-ota.zip ./**/*.elf ./**/meshtasticd_linux_amd64 ./*native*/*device-*.sh ./*native*/*device-*.bat
+
+      - name: Repackage in single firmware zip
+        uses: actions/upload-artifact@v3
+        with:
+          name: firmware-${{ steps.version.outputs.version }}
+          path: |
+            ./*.bin
+            ./*.uf2
+            ./firmware-*-ota.zip
+            ./meshtasticd_linux_amd64
+            ./device-*.sh
+            ./device-*.bat
+          retention-days: 90
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: firmware-${{ steps.version.outputs.version }}
+          path: ./output
+
+      # For diagnostics
+      - 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
+
+      - name: Repackage in single elfs zip
+        uses: actions/upload-artifact@v3
+        with:
+          name: debug-elfs-${{ steps.version.outputs.version }}.zip
+          path: ./*.elf
+          retention-days: 90
+
+      - name: Create request artifacts
+        if: ${{ github.event_name == 'pull_request_target' || github.event_name == 'pull_request' }}
+        uses: gavv/pull-request-artifacts@v1.0.0
+        with:
+          commit: ${{ (github.event.pull_request_target || github.event.pull_request).head.sha }}
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          artifacts-token: ${{ secrets.ARTIFACTS_TOKEN }}
+          artifacts-repo: meshtastic/artifacts
+          artifacts-branch: device
+          artifacts-dir: pr
+          artifacts: ./firmware-${{ steps.version.outputs.version }}.zip
+
+  release-artifacts:
+    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 -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 -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 Device ${{ 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: ./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/update_protobufs.yml

@@ -0,0 +1,33 @@
+name: "Update protobufs and regenerate classes"
+on: workflow_dispatch
+
+jobs:
+  update-protobufs:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Update submodule
+        run: |
+          git submodule update --remote protobufs
+
+      - name: Download nanopb
+        run: |
+          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.6-linux-x86.tar.gz
+          tar xvzf nanopb-0.4.6-linux-x86.tar.gz
+          mv nanopb-0.4.6-linux-x86 nanopb-0.4.6
+
+      - name: Re-generate protocol buffers
+        run: |
+          ./bin/regen-protos.sh
+
+      - name: Create pull request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          add-paths: |
+            protobufs
+            src/mesh

.gitignore

@@ -6,6 +6,26 @@ main/credentials.h
 .vscode/*
 !.vscode/settings.json
 !.vscode/tasks.json
-!.vscode/launch.json
 !.vscode/extensions.json
 *.code-workspace
+
+.idea
+
+.DS_Store
+Thumbs.db
+.autotools
+.built
+.context
+.cproject
+.vagrant
+nanopb*
+flash.uf2
+cmake-build*
+__pycache__
+
+*.swp
+*.swo
+*~
+
+venv/
+release/

.gitmodules

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

.vscode/extensions.json

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

.vscode/launch.json

@@ -1,32 +0,0 @@
-// AUTOMATICALLY GENERATED FILE. PLEASE DO NOT MODIFY IT MANUALLY
-
-// PIO Unified Debugger
-//
-// Documentation: https://docs.platformio.org/page/plus/debugging.html
-// Configuration: https://docs.platformio.org/page/projectconf/section_env_debug.html
-
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug",
-            "executable": "/home/kevinh/development/meshtastic/meshtastic-esp32/.pio/build/esp32/firmware.elf",
-            "toolchainBinDir": "/home/kevinh/.platformio/packages/toolchain-xtensa32/bin",
-            "preLaunchTask": {
-                "type": "PlatformIO",
-                "task": "Pre-Debug"
-            },
-            "internalConsoleOptions": "openOnSessionStart"
-        },
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug (skip Pre-Debug)",
-            "executable": "/home/kevinh/development/meshtastic/meshtastic-esp32/.pio/build/esp32/firmware.elf",
-            "toolchainBinDir": "/home/kevinh/.platformio/packages/toolchain-xtensa32/bin",
-            "internalConsoleOptions": "openOnSessionStart"
-        }
-    ]
-}

.vscode/settings.json

@@ -42,10 +42,39 @@
         "typeinfo": "cpp",
         "string": "cpp",
         "*.xbm": "cpp",
-        "list": "cpp"
+        "list": "cpp",
+        "atomic": "cpp",
+        "memory_resource": "cpp",
+        "optional": "cpp",
+        "string_view": "cpp",
+        "cassert": "cpp",
+        "iterator": "cpp",
+        "shared_mutex": "cpp",
+        "iostream": "cpp",
+        "esp_nimble_hci.h": "c",
+        "map": "cpp",
+        "random": "cpp",
+        "*.tpp": "cpp"
     },
     "cSpell.words": [
+        "Blox",
+        "EINK",
+        "HFSR",
         "Meshtastic",
-        "descs"
-    ]
+        "NEMAGPS",
+        "NMEAGPS",
+        "RDEF",
+        "Ublox",
+        "bkpt",
+        "cfsr",
+        "descs",
+        "ocrypto",
+        "protobufs",
+        "wifi"
+    ],
+    "C_Cpp.dimInactiveRegions": true,
+    "cmake.configureOnOpen": true,
+    "protoc": {
+        "compile_on_save": false,
+    }
 }

.vscode/tasks.json

@@ -0,0 +1,17 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"type": "PlatformIO",
+			"task": "Build",
+			"problemMatcher": [
+				"$platformio"
+			],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"label": "PlatformIO: Build"
+		}
+	]
+}

README.md

@@ -1,103 +1,18 @@
-# Meshtastic-esp32
-This is the device side code for the [meshtastic.org](https://www.meshtastic.org) project.  
+# Meshtastic Firmware
 
-![Continuous Integration](https://github.com/meshtastic/Meshtastic-esp32/workflows/Continuous%20Integration/badge.svg)
+![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)
 
-Meshtastic is a project that lets you use
-inexpensive GPS mesh radios as an extensible, super long battery life mesh GPS communicator.  These radios are great for hiking, skiing, paragliding - 
-essentially any hobby where you don't have reliable internet access.  Each member of your private mesh can always see the location and distance of all other
-members and any text messages sent to your group chat.
+## Overview
 
-The radios automatically create a mesh to forward packets as needed, so everyone in the group can receive messages from even the furthest member.  The radios
-will optionally work with your phone, but no phone is required.
+This repository contains the device firmware for the Meshtastic project.
 
-Typical time between recharging the radios should be about eight days.
+**[Building Instructions](https://meshtastic.org/docs/developers/Firmware/build)**
+**[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)**
 
-This project is currently early-alpha, but if you have questions please join our chat [![Join the chat at https://gitter.im/Meshtastic/community](https://badges.gitter.im/Meshtastic/community.svg)](https://gitter.im/Meshtastic/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge).
+## Stats
 
-This software is 100% open source and developed by a group of hobbyist experimenters.  No warranty is provided, if you'd like to improve it - we'd love your help.  Please post in the chat.  
-
-## Supported hardware
-We currently support three models of radios.  The [TTGO T-Beam](https://www.aliexpress.com/item/4000119152086.html), [TTGO LORA32](https://www.banggood.com/LILYGO-TTGO-LORA32-868Mhz-SX1276-ESP32-Oled-Display-bluetooth-WIFI-Lora-Development-Module-Board-p-1248652.html?cur_warehouse=UK) and the [Heltec LoRa 32](https://heltec.org/project/wifi-lora-32/).  Most users should buy the T-Beam and a 18650 battery (total cost less than $35).  Make 
-sure to buy the frequency range which is legal for your country.  For the USA, you should buy the 915MHz version.  Getting a version that include a screen
-is optional, but highly recommended.
-
-See (meshtastic.org) for 3D printable cases.
-
-## Installing the firmware
-Prebuilt binaries for the supported radios is available in our [releases](https://github.com/meshtastic/Meshtastic-esp32/releases).  Your initial installation has to happen over USB from your Mac, Windows or Linux PC.   Once our software is installed, all future software updates happen over bluetooth from your phone.
-
-The instructions currently require a few commmand lines, but it should be pretty straightforward.  Please post comments on our group chat if you have problems or successes.  Steps to install:
-
-1. Purchase a radio (see above) with the correct frequencies for your country (915MHz for US or JP, 470MHz for CN, 870MHz for EU).
-2. Install "pip".  Pip is the python package manager we use to get the esptool installer app.  Instructions [here](https://www.makeuseof.com/tag/install-pip-for-python/).
-3. Run "pip install --upgrade esptool" to get esptool installed on your machine
-4. Connect your radio to your USB port
-5. Confirm that your device is talking to your PC by running "esptool.py chip_id".  The Heltec build also works on the TTGO LORA32 radio. You should see something like:
-```
-mydir$ esptool.py chip_id
-esptool.py v2.6
-Found 2 serial ports
-Serial port /dev/ttyUSB0
-Connecting....
-Detecting chip type... ESP32
-Chip is ESP32D0WDQ6 (revision 1)
-Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
-MAC: 24:6f:28:b5:36:71
-Uploading stub...
-Running stub...
-Stub running...
-Warning: ESP32 has no Chip ID. Reading MAC instead.
-MAC: 24:6f:28:b5:36:71
-Hard resetting via RTS pin...
-```
-6. Install the correct firmware for your board with "esptool.py write_flash 0x10000 firmware-_board_-_country_.bin".  For instance "esptool.py write_flash 0x10000 release/firmware-HELTEC-US-0.0.3.bin". You should see something like this:
-```
-~/development/meshtastic/meshtastic-esp32$ esptool.py write_flash 0x10000 release/firmware-HELTEC-US-0.0.3.bin 
-esptool.py v2.6
-Found 2 serial ports
-Serial port /dev/ttyUSB0
-Connecting......
-Detecting chip type... ESP32
-Chip is ESP32D0WDQ6 (revision 1)
-Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
-MAC: 24:6f:28:b5:36:71
-Uploading stub...
-Running stub...
-Stub running...
-Configuring flash size...
-Auto-detected Flash size: 8MB
-Compressed 1184800 bytes to 652635...
-Wrote 1184800 bytes (652635 compressed) at 0x00010000 in 57.6 seconds (effective 164.5 kbit/s)...
-Hash of data verified.
-
-Leaving...
-Hard resetting via RTS pin...
-```
-7. The board will boot and show the Meshtastic logo.
-8. Please post a comment on our chat so we know if these instructions worked for you ;-).  If you find bugs/have-questions post there also - we will be rapidly iterating over the next few weeks.
-
-## Meshtastic Android app
-The source code for the (optional) Meshtastic Android app is [here](https://github.com/meshtastic/Meshtastic-Android).  
-
-Alpha test builds are current available by opting into our alpha test group.  See (www.meshtastic.org) for instructions.  
-
-After our rate of change slows a bit, we will make beta builds available here (without needing to join the alphatest group):
-[![Download at https://play.google.com/store/apps/details?id=com.geeksville.mesh](https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png)](https://play.google.com/store/apps/details?id=com.geeksville.mesh&referrer=utm_source%3Dgithub%26utm_medium%3Desp32-readme%26utm_campaign%3Dmeshtastic-esp32%2520readme%26anid%3Dadmob&pcampaignid=pcampaignidMKT-Other-global-all-co-prtnr-py-PartBadge-Mar2515-1)
-
-# Development
-The following sections are probably only interesting if you want to join us in developing the software.  
-
-## Power measurements
-Since one of the main goals of this project is long battery life, it is important to consider that in our software/protocol design.  Based on initial measurements it seems that the current code should run about three days between charging, and with a bit more software work (see the [TODO list](TODO.md)) a battery life of eight days should be quite doable.  Our current power measurements/model is in [this spreadsheet](https://docs.google.com/spreadsheets/d/1ft1bS3iXqFKU8SApU8ZLTq9r7QQEGESYnVgdtvdT67k/edit?usp=sharing).
-
-## Build instructions
-This project uses the simple PlatformIO build system. You can use the IDE, but for brevity
-in these instructions I describe use of their command line tool.
-
-1. Purchase a suitable radio (see above)
-2. Install [PlatformIO](https://platformio.org/platformio-ide)
-3. Download this git repo and cd into it
-4. Plug the radio into your USB port
-4. Type "pio run -t upload" (This command will fetch dependencies, build the project and install it on the board via USB)
-5. Platform IO also installs a very nice VisualStudio Code based IDE, see their [tutorial](https://docs.platformio.org/en/latest/tutorials/espressif32/arduino_debugging_unit_testing.html) if you'd like to use it
+![Alt](https://repobeats.axiom.co/api/embed/a92f097d9197ae853e780ec53d7d126e545629ab.svg "Repobeats analytics image")

TODO.md

@@ -1,192 +0,0 @@
-# High priority
-
-Items to complete soon (next couple of alpha releases).
-
-* lower wait_bluetooth_secs to 30 seconds once we have the GPS power on (but GPS in sleep mode) across light sleep.  For the time
-being I have it set at 2 minutes to ensure enough time for a GPS lock from scratch.
-
-* use gps sleep mode instead of killing its power (to allow fast position when we wake)
-* enable fast lock and low power inside the gps chip
-* remeasure wake time power draws now that we run CPU down at 80MHz
-
-# AXP192 tasks
-* "AXP192 interrupt is not firing, remove this temporary polling of battery state"
-* make debug info screen show real data (including battery level & charging) - close corresponding github issue
-
-# Medium priority
-
-Items to complete before the first beta release.
-
-* Make a FAQ
-* good source of battery/signal/gps icons https://materialdesignicons.com/
-* investigate changing routing to https://github.com/sudomesh/LoRaLayer2 ?
-* check fcc rules on duty cycle.  we might not need to freq hop.  https://www.sunfiretesting.com/LoRa-FCC-Certification-Guide/
-* use fuse bits to store the board type and region.  So one load can be used on all boards
-* research and implement better mesh algorithm
-* the BLE stack is leaking about 200 bytes each time we go to light sleep
-* rx signal measurements -3 marginal, -9 bad, 10 great, -10 means almost unusable.  So scale this into % signal strength.  preferably as a graph, with an X indicating loss of comms.  
-* assign every "channel" a random shared 8 bit sync word (per 4.2.13.6 of datasheet) - use that word to filter packets before even checking CRC.  This will ensure our CPU will only wake for packets on our "channel"  
-* Note: we do not do address filtering at the chip level, because we might need to route for the mesh
-* add basic crypto - https://github.com/chegewara/esp32-mbedtls-aes-test/blob/master/main/main.c https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation - use ECB at first (though it is shit) because it doesn't require us to send 16 bytes of IV with each packet.  Then OFB per example
-* add frequency hopping, dependent on the gps time, make the switch moment far from the time anyone is going to be transmitting
-* share channel settings over Signal (or qr code) by embedding an an URL which is handled by the MeshUtil app.
-* publish update articles on the web
-
-# Pre-beta priority
-
-During the beta timeframe the following improvements 'would be nice' (and yeah - I guess some of these items count as features, but it is a hobby project ;-) )
-
-* If the phone doesn't read fromradio mailbox within X seconds, assume the phone is gone and we can stop queing location msgs 
-for it (because it will redownload the nodedb when it comes back)
-* Figure out why the RF95 ISR is never seeing RH_RF95_VALID_HEADER, so it is not protecting our rx packets from getting stomped on by sends
-* fix the frequency error reading in the RF95 RX code (can't do floating point math in an ISR ;-) 
-* See CustomRF95::send and fix the problem of dropping partially received packets if we want to start sending
-* make sure main cpu is not woken for packets with bad crc or not addressed to this node - do that in the radio hw
-* triple check fcc compliance
-* pick channel center frequency based on channel name? "dolphin" would hash to 900Mhz, "cat" to 905MHz etc?  allows us to hide the concept of channel # from hte user.
-* scan to find channels with low background noise? (Use CAD mode of the RF95 to automatically find low noise channels)
-* make a no bluetooth configured yet screen - include this screen in the loop if the user hasn't yet paired
-* if radio params change fundamentally, discard the nodedb
-* reneable the bluetooth battery level service on the T-BEAM, because we can read battery level there
-
-# Spinoff project ideas
-
-* an open source version of https://www.burnair.ch/skynet/ 
-* a paragliding app like http://airwhere.co.uk/ 
-* a version with a solar cell for power, just mounted high to permanently provide routing for nodes in a valley.  Someone just pointed me at disaster.radio
-* How do avalanche beacons work?  Could this do that as well?  possibly by using beacon mode feature of the RF95?
-* provide generalized (but slow) internet message forwarding servie if one of our nodes has internet connectivity
-
-# Low priority
-
-Items after the first final candidate release.
-
-* use variable length arduino Strings in protobufs (instead of current fixed buffers)
-* use BLEDevice::setPower to lower our BLE transmit power - extra range doesn't help us, it costs amps and it increases snoopability
-* make an install script to let novices install software on their boards
-* use std::map<NodeInfo*, std::string> in node db
-* make a HAM build: yep - that's a great idea.  I'll add it to the TODO.  should be pretty painless - just a new frequency list, a bool to say 'never do encryption' and use hte callsign as that node's unique id.  -from Girts
-* don't forward redundant pings or ping responses to the phone, it just wastes phone battery
-* use https://platformio.org/lib/show/1260/OneButton if necessary
-* don't send location packets if we haven't moved
-* scrub default radio config settings for bandwidth/range/speed
-* answer to pings (because some other user is looking at our nodeinfo) with our latest location (not a stale location)
-* show radio and gps signal strength as an image
-* only BLE advertise for a short time after the screen is on and button pressed - to save power and prevent people for sniffing for our BT app.
-* make mesh aware network timing state machine (sync wake windows to gps time)
-* split out the software update utility so other projects can use it.  Have the appload specify the URL for downloads.
-* read the PMU battery fault indicators and blink/led/warn user on screen
-* the AXP debug output says it is trying to charge at 700mA, but the max I've seen is 180mA, so AXP registers probably need to be set to tell them the circuit can only provide 300mAish max. So that the low charge rate kicks in faster and we don't wear out batteries.
-* increase the max charging rate a bit for 18650s, currently it limits to 180mA (at 4V).  Work backwards from the 500mA USB limit (at 5V) and let the AXP charge at that rate.
-* discard very old nodedb records (> 1wk)
-* using the genpartitions based table doesn't work on TTGO so for now I stay with my old memory map
-* We let anyone BLE scan for us (FIXME, perhaps only allow that until we are paired with a phone and configured) 
-* use two different buildenv flags for ttgo vs lora32. https://docs.platformio.org/en/latest/ide/vscode.html#key-bindings
-* sim gps data for testing nodes that don't have hardware
-* do debug serial logging to android over bluetooth
-* break out my bluetooth OTA software as a seperate library so others can use it
-* Heltec LoRa32 has 8MB flash, use a bigger partition table if needed - TTGO is 4MB but has PSRAM
-* add a watchdog timer
-* handle millis() rollover in GPS.getTime - otherwise we will break after 50 days
-* report esp32 device code bugs back to the mothership via android
-
-# Done
-
-* change the partition table to take advantage of the 4MB flash on the wroom: http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
-* wrap in nice MeshRadio class
-* add mesh send & rx
-* make message send from android go to service, then to mesh radio
-* make message receive from radio go through to android
-* test loopback tx/rx path code without using radio
-* notify phone when rx packets arrive, currently the phone polls at startup only
-* figure out if we can use PA_BOOST - yes, it seems to be on both boards
-* implement new ble characteristics
-* have MeshService keep a node DB by sniffing user messages
-* have a state machine return the correct FromRadio packet to the phone, it isn't always going to be a MeshPacket.  Do a notify on fromnum to force the radio to read our state machine generated packets
-* send my_node_num when phone sends WantsNodes
-* have meshservice periodically send location data on mesh (if device has a GPS)
-* implement getCurrentTime() - set based off gps but then updated locally
-* make default owner record have valid usernames
-* message loop between node 0x28 and 0x7c
-* check in my radiolib fixes
-* figure out what is busted with rx
-* send our owner info at boot, reply if we see anyone send theirs
-* add manager layers
-* confirm second device receives that gps message and updates device db
-* send correct hw vendor in the bluetooth info - needed so the android app can update different radio models
-* correctly map nodeids to nodenums, currently we just do a proof of concept by always doing a broadcast
-* add interrupt detach/sleep mode config to lora radio so we can enable deepsleep without panicing
-* make jtag work on second board
-* implement regen owner and radio prefs
-* use a better font
-* make nice screens (boot, about to sleep, debug info (gps signal, #people), latest text, person info - one frame per person on network)
-* turn framerate from ui->state.frameState to 1 fps (or less) unless in transition
-* switch to my gui layout manager
-* make basic gui. different screens: debug, one page for each user in the user db, last received text message
-* make button press cycle between screens
-* save our node db on entry to sleep
-* fix the logo
-* sent/received packets (especially if a node was just reset) have variant of zero sometimes - I think there is a bug (race-condtion?) in the radio send/rx path.
-* DONE dynamic nodenum assignment tasks
-* make jtag debugger id stable: https://askubuntu.com/questions/49910/how-to-distinguish-between-identical-usb-to-serial-adapters
-* reported altitude is crap
-* good tips on which bands might be more free https://github.com/TheThingsNetwork/ttn/issues/119
-* finish power measurements (GPS on during sleep vs LCD on during sleep vs LORA on during sleep) and est battery life
-* make screen sleep behavior work
-* make screen advance only when a new node update arrives, a new text arrives or the user presses a button, turn off screen after a while
-* after reboot, channel number is getting reset to zero! fix!
-* send user and location events much less often
-* send location (or if not available user) when the user wakes the device from display sleep (both for testing and to improve user experience)
-* make real implementation of getNumOnlineNodes
-* very occasionally send our position and user packet based on the schedule in the radio info (if for nothing else so that other nodes update last_seen)
-* show real text info on the text screen
-* apply radio settings from android land
-* cope with nodes that have 0xff or 0x00 as the last byte of their mac
-* allow setting full radio params from android
-* add receive timestamps to messages, inserted by esp32 when message is received but then shown on the phone
-* update build to generate both board types
-* have node info screen show real info (including distance and heading)
-* blink the power led less often
-* have radiohead ISR send messages to RX queue directly, to allow that thread to block until we have something to send
-* move lora rx/tx to own thread and block on IO
-* keep our pseudo time moving forward even if we enter deep sleep (use esp32 rtc)
-* for non GPS equipped devices, set time from phone
-* GUI on oled hangs for a few seconds occasionally, but comes back
-* update local GPS position (but do not broadcast) at whatever rate the GPS is giving it
-* don't send our times to other nodes
-* don't trust times from other nodes
-* draw compass rose based off local walking track
-* add requestResponse optional bool - use for location broadcasts when sending tests
-* post sample video to signal forum
-* support non US frequencies
-* send pr https://github.com/ThingPulse/esp8266-oled-ssd1306 to tell them about this project
-* document rules for sleep wrt lora/bluetooth/screen/gps.  also: if I have text messages (only) for the phone, then give a few seconds in the hopes BLE can get it across before we have to go back to sleep.
-* wake from light sleep as needed for our next scheduled periodic task (needed for gps position broadcasts etc)
-* turn bluetooth off based on our sleep policy
-* blink LED while in LS sleep mode
-* scrolling between screens based on press is busted
-* Use Neo-M8M API to put it in sleep mode (on hold until my new boards arrive)
-* update the prebuilt bins for different regulatory regions
-* don't enter NB state if we've recently talked to the phone (to prevent breaking syncing or bluetooth sw update)
-* have sw update prevent BLE sleep
-* manually delete characteristics/descs
-* leave lora receiver always on
-* protobufs are sometimes corrupted after sleep!
-* stay awake while charging
-* check gps battery voltage
-* if a position report includes ground truth time and we don't have time yet, set our clock from that.  It is better than nothing.
-* retest BLE software update for both board types
-* report on wikifactory
-* send note to the guy who designed the cases
-* turn light sleep on aggressively (while lora is on but BLE off)
-* Use the Periodic class for both position and user periodic broadcasts
-* don't treat north as up, instead adjust shown bearings for our guess at the users heading (i.e. subtract one from the other)
-* sendToMesh can currently block for a long time, instead have it just queue a packet for a radio freertos thread
-* don't even power on bluetooth until we have some data to send to the android phone.  Most of the time we should be sleeping in a lowpower "listening for lora" only mode.  Once we have some packets for the phone, then power on bluetooth
-until the phone pulls those packets.  Ever so often power on bluetooth just so we can see if the phone wants to send some packets.  Possibly might need ULP processor to help with this wake process.
-* do hibernation mode to get power draw down to 2.5uA https://lastminuteengineers.com/esp32-sleep-modes-power-consumption/ 
-* fix GPS.zeroOffset calculation it is wrong
-* (needs testing) fixed the following during a plane flight:
- Have state machine properly enter deep sleep based on loss of mesh and phone comms.
- Default to enter deep sleep if no LORA received for two hours (indicates user has probably left the mesh).
-* (fixed I think) text messages are not showing on local screen if screen was on

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#657509856ce97e9dddeffb89a559f544faefd5cd
+  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#657509856ce97e9dddeffb89a559f544faefd5cd
+  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,20 @@
+; The Portduino based sim environment on top of any host OS, all hardware will be simulated
+[portduino_base]
+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
+  https://github.com/meshtastic/RadioLib.git#5582ac30578ff3f53f20630a00b2a8a4b8f92c74
+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,56 +0,0 @@
-#!/bin/bash
-
-set -e
-
-source bin/version.sh
-
-COUNTRIES="US EU CN JP"
-# COUNTRIES=US
-
-SRCMAP=.pio/build/esp32/output.map
-SRCBIN=.pio/build/esp32/firmware.bin
-OUTDIR=release/latest
-
-# We keep all old builds (and their map files in the archive dir)
-ARCHIVEDIR=release/archive 
-
-rm -f $OUTDIR/firmware*
-
-for COUNTRY in $COUNTRIES; do 
-
-    HWVERSTR="1.0-$COUNTRY"
-    COMMONOPTS="-DAPP_VERSION=$VERSION -DHW_VERSION_$COUNTRY -DHW_VERSION=$HWVERSTR -Wall -Wextra -Wno-missing-field-initializers -Isrc -Os -Wl,-Map,.pio/build/esp32/output.map -DAXP_DEBUG_PORT=Serial"
-
-    export PLATFORMIO_BUILD_FLAGS="-DT_BEAM_V10 $COMMONOPTS"
-    echo "Building with $PLATFORMIO_BUILD_FLAGS"
-    rm -f $SRCBIN $SRCMAP
-    pio run # -v
-    cp $SRCBIN $OUTDIR/firmware-TBEAM-$COUNTRY-$VERSION.bin
-    #cp $SRCMAP $ARCHIVEDIR/firmware-TBEAM-$COUNTRY-$VERSION.map
-
-    export PLATFORMIO_BUILD_FLAGS="-DHELTEC_LORA32 $COMMONOPTS"
-    rm -f $SRCBIN $SRCMAP
-    pio run # -v
-    cp $SRCBIN $OUTDIR/firmware-HELTEC-$COUNTRY-$VERSION.bin
-    #cp $SRCMAP $ARCHIVEDIR/firmware-HELTEC-$COUNTRY-$VERSION.map
-done
-
-# keep the bins in archive also
-cp $OUTDIR/firmware* $ARCHIVEDIR
-
-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">$VERSION</string>
-</resources>
-XML
-
-rm -f $ARCHIVEDIR/firmware-$VERSION.zip
-zip $ARCHIVEDIR/firmware-$VERSION.zip $OUTDIR/firmware-*-$VERSION.bin
-
-echo BUILT ALL

bin/build-all.sh.legacy

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

bin/build-esp32.sh

@@ -0,0 +1,39 @@
+#!/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
+
+# 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 
+
+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 ESP32 bin file"
+SRCBIN=.pio/build/$1/firmware.factory.bin
+cp $SRCBIN $OUTDIR/$basename.bin
+
+echo "Building Filesystem for ESP32 targets"
+pio run --environment tbeam -t buildfs
+cp .pio/build/tbeam/littlefs.bin $OUTDIR/littlefs-$VERSION.bin
+cp bin/device-install.* $OUTDIR
+cp bin/device-update.* $OUTDIR

bin/build-native.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+set -e
+
+VERSION=`bin/buildinfo.py long`
+SHORT_VERSION=`bin/buildinfo.py short`
+
+OUTDIR=release/
+
+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 
+
+pio run --environment native
+cp .pio/build/native/program $OUTDIR/meshtasticd_linux_amd64
+
+cp bin/device-install.* $OUTDIR
+cp bin/device-update.* $OUTDIR
+

bin/build-nrf52.sh

@@ -0,0 +1,39 @@
+#!/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
+
+# 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 
+
+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
+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
+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,36 @@
+#!/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
+
+# 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 
+
+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/buildinfo.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+import configparser
+import sys
+from readprops import readProps
+
+
+verObj = readProps('version.properties')
+propName = sys.argv[1]
+print(f"{verObj[propName]}")

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-all.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# Note: This is a prototype for how we could add static code analysis to the CI.
+
+set -e
+
+VERSION=`bin/buildinfo.py long`
+
+# The shell vars the build tool expects to find
+export APP_VERSION=$VERSION
+
+if [[ $# -gt 0 ]]; then
+    # can override which environment by passing arg
+    BOARDS="$@"
+else
+    BOARDS="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v1 heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo pca10059_diy_eink"
+fi
+
+echo "BOARDS:${BOARDS}"
+
+CHECK=""
+for BOARD in $BOARDS; do
+     CHECK="${CHECK} -e ${BOARD}"
+done
+
+pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt" $CHECK --skip-packages --pattern="src/" --fail-on-defect=low --fail-on-defect=medium --fail-on-defect=high

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

@@ -0,0 +1,42 @@
+@ECHO OFF
+
+set PYTHON=python
+
+goto GETOPTS
+:HELP
+echo Usage: %~nx0 [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME^|FILENAME]
+echo Flash image file to device, but first erasing and writing system information
+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.
+goto EOF
+
+:GETOPTS
+if /I "%1"=="-h" goto HELP
+if /I "%1"=="--help" goto HELP
+if /I "%1"=="-F" set "FILENAME=%2" & SHIFT
+if /I "%1"=="-p" set ESPTOOL_PORT=%2 & SHIFT
+if /I "%1"=="-P" set PYTHON=%2 & SHIFT
+SHIFT
+IF NOT "__%1__"=="____" goto GETOPTS
+
+IF "__%FILENAME%__" == "____" (
+    echo "Missing FILENAME"
+	goto HELP
+)
+IF EXIST %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 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 0x300000 %%f
+    )
+) else (
+    echo "Invalid file: %FILENAME%"
+	goto HELP
+)
+
+:EOF

bin/device-install.sh

@@ -0,0 +1,59 @@
+#!/bin/sh
+
+PYTHON=${PYTHON:-$(which python3 python|head -n 1)}
+
+set -e
+
+# Usage info
+show_help() {
+cat << EOF
+Usage: $(basename $0) [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME|FILENAME]
+Flash image file to device, but first erasing and writing system information"
+
+    -h               Display this help and exit
+    -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
+}
+
+
+while getopts ":hp:P:f:" opt; do
+    case "${opt}" in
+        h)
+            show_help
+            exit 0
+            ;;
+        p)  export ESPTOOL_PORT=${OPTARG}
+	    ;;
+        P)  PYTHON=${OPTARG}
+            ;;
+        f)  FILENAME=${OPTARG}
+            ;;
+        *)
+ 	    echo "Invalid flag."
+            show_help >&2
+            exit 1
+            ;;
+    esac
+done
+shift "$((OPTIND-1))"
+
+[ -z "$FILENAME" -a -n "$1" ] && {
+    FILENAME=$1
+    shift
+}
+
+if [ -f "${FILENAME}" ]; then
+	echo "Trying to flash ${FILENAME}, but first erasing and writing system information"
+	"$PYTHON" -m esptool  erase_flash
+	"$PYTHON" -m esptool  write_flash 0x00 ${FILENAME}
+    "$PYTHON" -m esptool  write_flash 0x260000 bleota.bin
+	"$PYTHON" -m esptool  write_flash 0x300000 littlefs-*.bin
+
+else
+	echo "Invalid file: ${FILENAME}"
+	show_help
+fi
+
+exit 0

bin/device-update.bat

@@ -0,0 +1,37 @@
+@ECHO OFF
+
+set PYTHON=python
+
+goto GETOPTS
+:HELP
+echo Usage: %~nx0 [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME^|FILENAME]
+echo Flash image file to device, leave existing system intact.
+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.
+goto EOF
+
+:GETOPTS
+if /I "%1"=="-h" goto HELP
+if /I "%1"=="--help" goto HELP
+if /I "%1"=="-F" set "FILENAME=%2" & SHIFT
+if /I "%1"=="-p" set ESPTOOL_PORT=%2 & SHIFT
+if /I "%1"=="-P" set PYTHON=%2 & SHIFT
+SHIFT
+IF NOT "__%1__"=="____" goto GETOPTS
+
+IF "__%FILENAME%__" == "____" (
+    echo "Missing FILENAME"
+	goto HELP
+)
+IF EXIST %FILENAME% (
+    echo Trying to flash update %FILENAME%
+    %PYTHON% -m esptool --baud 115200 write_flash 0x00 %FILENAME%
+) else (
+    echo "Invalid file: %FILENAME%"
+	goto HELP
+)
+
+:EOF

bin/device-update.sh

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+PYTHON=${PYTHON:-$(which python3 python|head -n 1)}
+
+# Usage info
+show_help() {
+cat << EOF
+Usage: $(basename $0) [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME|FILENAME]
+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.
+EOF
+}
+
+
+while getopts ":hp:P:f:" opt; do
+    case "${opt}" in
+        h)
+            show_help
+            exit 0
+            ;;
+        p)  export ESPTOOL_PORT=${OPTARG}
+	    ;;
+        P)  PYTHON=${OPTARG}
+            ;;
+        f)  FILENAME=${OPTARG}
+            ;;
+        *)
+ 	    echo "Invalid flag."
+            show_help >&2
+            exit 1
+            ;;
+    esac
+done
+shift "$((OPTIND-1))"
+
+[ -z "$FILENAME" -a -n "$1" ] && {
+    FILENAME=$1
+    shift
+}
+
+if [ -f "${FILENAME}" ]; then
+	echo "Trying to flash update ${FILENAME}."
+	$PYTHON -m esptool --baud 115200 write_flash 0x00 ${FILENAME}
+else
+	echo "Invalid file: ${FILENAME}"
+	show_help
+fi
+
+exit 0

bin/dump-ram-users.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+arm-none-eabi-readelf -s -e .pio/build/nrf52dk/firmware.elf | head -80
+
+nm -CSr --size-sort .pio/build/nrf52dk/firmware.elf  | grep '^200'

bin/exception_decoder.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+
+"""ESP Exception Decoder
+
+github:  https://github.com/janLo/EspArduinoExceptionDecoder
+license: GPL v3
+author:  Jan Losinski
+
+Meshtastic notes:
+* original version is at: https://github.com/janLo/EspArduinoExceptionDecoder
+* version that's checked into meshtastic repo is based on: https://github.com/me21/EspArduinoExceptionDecoder
+  which adds in ESP32 Backtrace decoding.
+* this also updates the defaults to use ESP32, instead of ESP8266 and defaults to the built firmware.bin
+
+To use, copy the "Backtrace: 0x...." line to a file, e.g., backtrace.txt, then run:
+$ bin/exception_decoder.py backtrace.txt
+"""
+
+import argparse
+import re
+import subprocess
+from collections import namedtuple
+
+import sys
+
+import os
+
+EXCEPTIONS = [
+    "Illegal instruction",
+    "SYSCALL instruction",
+    "InstructionFetchError: Processor internal physical address or data error during instruction fetch",
+    "LoadStoreError: Processor internal physical address or data error during load or store",
+    "Level1Interrupt: Level-1 interrupt as indicated by set level-1 bits in the INTERRUPT register",
+    "Alloca: MOVSP instruction, if caller's registers are not in the register file",
+    "IntegerDivideByZero: QUOS, QUOU, REMS, or REMU divisor operand is zero",
+    "reserved",
+    "Privileged: Attempt to execute a privileged operation when CRING ? 0",
+    "LoadStoreAlignmentCause: Load or store to an unaligned address",
+    "reserved",
+    "reserved",
+    "InstrPIFDataError: PIF data error during instruction fetch",
+    "LoadStorePIFDataError: Synchronous PIF data error during LoadStore access",
+    "InstrPIFAddrError: PIF address error during instruction fetch",
+    "LoadStorePIFAddrError: Synchronous PIF address error during LoadStore access",
+    "InstTLBMiss: Error during Instruction TLB refill",
+    "InstTLBMultiHit: Multiple instruction TLB entries matched",
+    "InstFetchPrivilege: An instruction fetch referenced a virtual address at a ring level less than CRING",
+    "reserved",
+    "InstFetchProhibited: An instruction fetch referenced a page mapped with an attribute that does not permit instruction fetch",
+    "reserved",
+    "reserved",
+    "reserved",
+    "LoadStoreTLBMiss: Error during TLB refill for a load or store",
+    "LoadStoreTLBMultiHit: Multiple TLB entries matched for a load or store",
+    "LoadStorePrivilege: A load or store referenced a virtual address at a ring level less than CRING",
+    "reserved",
+    "LoadProhibited: A load referenced a page mapped with an attribute that does not permit loads",
+    "StoreProhibited: A store referenced a page mapped with an attribute that does not permit stores"
+]
+
+PLATFORMS = {
+    "ESP8266": "lx106",
+    "ESP32": "esp32"
+}
+
+BACKTRACE_REGEX = re.compile(r"(?:\s+(0x40[0-2](?:\d|[a-f]|[A-F]){5}):0x(?:\d|[a-f]|[A-F]){8})\b")
+EXCEPTION_REGEX = re.compile("^Exception \\((?P<exc>[0-9]*)\\):$")
+COUNTER_REGEX = re.compile('^epc1=(?P<epc1>0x[0-9a-f]+) epc2=(?P<epc2>0x[0-9a-f]+) epc3=(?P<epc3>0x[0-9a-f]+) '
+                           'excvaddr=(?P<excvaddr>0x[0-9a-f]+) depc=(?P<depc>0x[0-9a-f]+)$')
+CTX_REGEX = re.compile("^ctx: (?P<ctx>.+)$")
+POINTER_REGEX = re.compile('^sp: (?P<sp>[0-9a-f]+) end: (?P<end>[0-9a-f]+) offset: (?P<offset>[0-9a-f]+)$')
+STACK_BEGIN = '>>>stack>>>'
+STACK_END = '<<<stack<<<'
+STACK_REGEX = re.compile(
+    '^(?P<off>[0-9a-f]+):\W+(?P<c1>[0-9a-f]+) (?P<c2>[0-9a-f]+) (?P<c3>[0-9a-f]+) (?P<c4>[0-9a-f]+)(\W.*)?$')
+
+StackLine = namedtuple("StackLine", ["offset", "content"])
+
+
+class ExceptionDataParser(object):
+    def __init__(self):
+        self.exception = None
+
+        self.epc1 = None
+        self.epc2 = None
+        self.epc3 = None
+        self.excvaddr = None
+        self.depc = None
+
+        self.ctx = None
+
+        self.sp = None
+        self.end = None
+        self.offset = None
+
+        self.stack = []
+
+    def _parse_backtrace(self, line):
+        if line.startswith('Backtrace:'):
+            self.stack = [StackLine(offset=0, content=(addr,)) for addr in BACKTRACE_REGEX.findall(line)]
+            return None
+        return self._parse_backtrace
+
+    def _parse_exception(self, line):
+        match = EXCEPTION_REGEX.match(line)
+        if match is not None:
+            self.exception = int(match.group('exc'))
+            return self._parse_counters
+        return self._parse_exception
+
+    def _parse_counters(self, line):
+        match = COUNTER_REGEX.match(line)
+        if match is not None:
+            self.epc1 = match.group("epc1")
+            self.epc2 = match.group("epc2")
+            self.epc3 = match.group("epc3")
+            self.excvaddr = match.group("excvaddr")
+            self.depc = match.group("depc")
+            return self._parse_ctx
+        return self._parse_counters
+
+    def _parse_ctx(self, line):
+        match = CTX_REGEX.match(line)
+        if match is not None:
+            self.ctx = match.group("ctx")
+            return self._parse_pointers
+        return self._parse_ctx
+
+    def _parse_pointers(self, line):
+        match = POINTER_REGEX.match(line)
+        if match is not None:
+            self.sp = match.group("sp")
+            self.end = match.group("end")
+            self.offset = match.group("offset")
+            return self._parse_stack_begin
+        return self._parse_pointers
+
+    def _parse_stack_begin(self, line):
+        if line == STACK_BEGIN:
+            return self._parse_stack_line
+        return self._parse_stack_begin
+
+    def _parse_stack_line(self, line):
+        if line != STACK_END:
+            match = STACK_REGEX.match(line)
+            if match is not None:
+                self.stack.append(StackLine(offset=match.group("off"),
+                                            content=(match.group("c1"), match.group("c2"), match.group("c3"),
+                                                     match.group("c4"))))
+            return self._parse_stack_line
+        return None
+
+    def parse_file(self, file, platform, stack_only=False):
+        if platform == 'ESP32':
+            func = self._parse_backtrace
+        else:
+            func = self._parse_exception
+            if stack_only:
+                func = self._parse_stack_begin
+
+        for line in file:
+            func = func(line.strip())
+            if func is None:
+                break
+
+        if func is not None:
+            print("ERROR: Parser not complete!")
+            sys.exit(1)
+
+
+class AddressResolver(object):
+    def __init__(self, tool_path, elf_path):
+        self._tool = tool_path
+        self._elf = elf_path
+        self._address_map = {}
+
+    def _lookup(self, addresses):
+        cmd = [self._tool, "-aipfC", "-e", self._elf] + [addr for addr in addresses if addr is not None]
+
+        if sys.version_info[0] < 3:
+            output = subprocess.check_output(cmd)
+        else:
+            output = subprocess.check_output(cmd, encoding="utf-8")
+
+        line_regex = re.compile("^(?P<addr>[0-9a-fx]+): (?P<result>.+)$")
+
+        last = None
+        for line in output.splitlines():
+            line = line.strip()
+            match = line_regex.match(line)
+
+            if match is None:
+                if last is not None and line.startswith('(inlined by)'):
+                    line = line [12:].strip()
+                    self._address_map[last] += ("\n  \-> inlined by: " + line)
+                continue
+
+            if match.group("result") == '?? ??:0':
+                continue
+
+            self._address_map[match.group("addr")] = match.group("result")
+            last = match.group("addr")
+
+    def fill(self, parser):
+        addresses = [parser.epc1, parser.epc2, parser.epc3, parser.excvaddr, parser.sp, parser.end, parser.offset]
+        for line in parser.stack:
+            addresses.extend(line.content)
+
+        self._lookup(addresses)
+
+    def _sanitize_addr(self, addr):
+        if addr.startswith("0x"):
+            addr = addr[2:]
+
+        fill = "0" * (8 - len(addr))
+        return "0x" + fill + addr
+
+    def resolve_addr(self, addr):
+        out = self._sanitize_addr(addr)
+
+        if out in self._address_map:
+            out += ": " + self._address_map[out]
+
+        return out
+
+    def resolve_stack_addr(self, addr, full=True):
+        addr = self._sanitize_addr(addr)
+        if addr in self._address_map:
+            return addr + ": " + self._address_map[addr]
+
+        if full:
+            return "[DATA (0x" + addr + ")]"
+
+        return None
+
+
+def print_addr(name, value, resolver):
+    print("{}:{} {}".format(name, " " * (8 - len(name)), resolver.resolve_addr(value)))
+
+
+def print_stack_full(lines, resolver):
+    print("stack:")
+    for line in lines:
+        print(str(line.offset) + ":")
+        for content in line.content:
+            print("  " + resolver.resolve_stack_addr(content))
+
+
+def print_stack(lines, resolver):
+    print("stack:")
+    for line in lines:
+        for content in line.content:
+            out = resolver.resolve_stack_addr(content, full=False)
+            if out is None:
+                continue
+            print(out)
+
+
+def print_result(parser, resolver, platform, full=True, stack_only=False):
+    if platform == 'ESP8266' and not stack_only:
+        print('Exception: {} ({})'.format(parser.exception, EXCEPTIONS[parser.exception]))
+
+        print("")
+        print_addr("epc1", parser.epc1, resolver)
+        print_addr("epc2", parser.epc2, resolver)
+        print_addr("epc3", parser.epc3, resolver)
+        print_addr("excvaddr", parser.excvaddr, resolver)
+        print_addr("depc", parser.depc, resolver)
+
+        print("")
+        print("ctx: " + parser.ctx)
+
+        print("")
+        print_addr("sp", parser.sp, resolver)
+        print_addr("end", parser.end, resolver)
+        print_addr("offset", parser.offset, resolver)
+
+        print("")
+    if full:
+        print_stack_full(parser.stack, resolver)
+    else:
+        print_stack(parser.stack, resolver)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="decode ESP Stacktraces.")
+
+    parser.add_argument("-p", "--platform", help="The platform to decode from", choices=PLATFORMS.keys(),
+                        default="ESP32")
+    parser.add_argument("-t", "--tool", help="Path to the xtensa toolchain",
+                        default="~/.platformio/packages/toolchain-xtensa32/")
+    parser.add_argument("-e", "--elf", help="path to elf file",
+                        default=".pio/build/esp32/firmware.elf")
+    parser.add_argument("-f", "--full", help="Print full stack dump", action="store_true")
+    parser.add_argument("-s", "--stack_only", help="Decode only a stractrace", action="store_true")
+    parser.add_argument("file", help="The file to read the exception data from ('-' for STDIN)", default="-")
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    if args.file == "-":
+        file = sys.stdin
+    else:
+        if not os.path.exists(args.file):
+            print("ERROR: file " + args.file + " not found")
+            sys.exit(1)
+        file = open(args.file, "r")
+
+    addr2line = os.path.join(os.path.abspath(os.path.expanduser(args.tool)),
+                             "bin/xtensa-" + PLATFORMS[args.platform] + "-elf-addr2line")
+    if os.name == 'nt':
+        addr2line += '.exe'
+    if not os.path.exists(addr2line):
+        print("ERROR: addr2line not found (" + addr2line + ")")
+
+    elf_file = os.path.abspath(os.path.expanduser(args.elf))
+    if not os.path.exists(elf_file):
+        print("ERROR: elf file not found (" + elf_file + ")")
+
+    parser = ExceptionDataParser()
+    resolver = AddressResolver(addr2line, elf_file)
+
+    parser.parse_file(file, args.platform, args.stack_only)
+    resolver.fill(parser)
+
+    print_result(parser, resolver, args.platform, args.full, args.stack_only)

bin/gen-images.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -e 
+
+# regen the design bins first
+cd design
+bin/generate-pngs.sh
+cd ..
+
+# assumes 50 wide, 28 high
+convert design/logo/png/Mesh_Logo_Black_Small.png -background white -alpha Background src/graphics/img/icon.xbm
+
+inkscape --batch-process -o images/compass.png -w 48 -h 48 images/location_searching-24px.svg
+convert compass.png -background white -alpha Background src/graphics/img/compass.xbm
+
+inkscape --batch-process -o images/face.png -w 13 -h 13 images/face-24px.svg
+
+inkscape --batch-process -o images/pin.png -w 13 -h 13 images/room-24px.svg
+convert pin.png -background white -alpha Background src/graphics/img/pin.xbm

bin/genpartitions.py

@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python2
 
 # This is a layout for 4MB of flash
 # Name,   Type, SubType, Offset,  Size, Flags

bin/lora32-openocd.cfg

@@ -1,61 +0,0 @@
-# Example OpenOCD configuration file for ESP-WROOM-32 module.
-# By default, the following configuration is used:
-# - dual core debugging
-# - support for listing FreeRTOS tasks is enabled
-# - OpenOCD is configured to set SPI flash voltage at 3.3V
-#   by keeping MTDI bootstrapping pin low
-#
-# Use variables listed below to customize this.
-# Variables can be modified in this file or set on the command line.
-#
-# For example, OpenOCD can be started for single core ESP32 debugging on
-# ESP-WROVER-KIT with ESP-WROOM-32 module as follows:
-#
-#   openocd -f interface/ftdi/esp32_devkitj_v1.cfg -c 'set ESP32_ONLYCPU 1' -f board/esp-wroom-32.cfg
-#
-# If a different JTAG interface is used, change the first -f option.
-#
-# If OpenOCD is built from source, pass an additional -s option to specify
-# the location of 'tcl' directory:
-#
-#    src/openocd -s tcl <rest of the command line>
-#
-# Note:
-#   For ESP32-WROVER module use 'esp32-wrover.cfg' configuration file
-#   ESP-WROOM-32 and ESP32-WROVER have different flash voltage setting
-
-
-# The ESP32 only supports JTAG.
-transport select jtag
-
-# The speed of the JTAG interface, in KHz. If you get DSR/DIR errors (and they
-# do not relate to OpenOCD trying to read from a memory range without physical
-# memory being present there), you can try lowering this.
-#
-# On DevKit-J, this can go as high as 20MHz if CPU frequency is 80MHz, or 26MHz
-# if CPU frequency is 160MHz or 240MHz.
-adapter_khz 20000
-
-# If single core debugging is required, uncomment the following line
-# set ESP32_ONLYCPU 1
-
-# To disable RTOS support, uncomment the following line
-# set ESP32_RTOS none
-
-# Tell OpenOCD which SPI flash voltage is used by the board (3.3 or 1.8)
-# The TDI pin of ESP32 is also a bootstrap pin that selects the voltage the SPI flash
-# chip runs at. When a hard reset happens (e.g. because someone switches the board off
-# and on) the ESP32 will use the current TDI value as the bootstrap value because the
-# JTAG adapter overrides the pull-up or pull-down resistor that is supposed to do the
-# bootstrapping. These lines basically set the idle value of the TDI line to a
-# specified value, therefore reducing the chance of a bad bootup due to a bad flash
-# voltage greatly.
-# This option defaults to 3.3, if not set. To override the default, uncomment
-# the following line:
-# set ESP32_FLASH_VOLTAGE 1.8
-
-# Set semihosting I/O base dir
-# set ESP_SEMIHOST_BASEDIR ""
-
-# Source the ESP32 configuration file
-source [find target/esp32.cfg]

bin/native-gdbserver.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -e
+pio run --environment native
+gdbserver --once localhost:2345 .pio/build/native/program "$@"

bin/native-run.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -e
+pio run --environment native
+.pio/build/native/program "$@"

bin/platformio-custom.py

@@ -0,0 +1,73 @@
+import subprocess
+import configparser
+import traceback
+import sys
+from os.path import join
+from readprops import readProps
+
+Import("env")
+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, firmware version " + verObj['long'])
+
+# General options that are passed to the C and C++ compilers
+projenv.Append(CCFLAGS=[
+    "-DAPP_VERSION=" + verObj['long'],
+    "-DAPP_VERSION_SHORT=" + verObj['short']    
+])

bin/program-release-heltec.sh

@@ -1,6 +0,0 @@
-
-set -e
-
-source bin/version.sh
-
-esptool.py --baud 921600 write_flash 0x10000 release/latest/firmware-HELTEC-US-$VERSION.bin

bin/promote-release.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+set -e 
+
+echo "This script is only for developers who are publishing new builds on github.  Most users don't need it"
+
+VERSION=`bin/buildinfo.py long`
+
+# Must have a V prefix to trigger github
+git tag "v${VERSION}"
+
+git push origin "v${VERSION}" # push the tag
+
+echo "Tag ${VERSION} pushed to github, github actions should now be building the draft release.  If it seems good, click to publish it"

bin/read-system-info.sh

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

bin/readprops.py

@@ -0,0 +1,37 @@
+
+
+import subprocess
+import configparser
+import traceback
+import sys
+
+
+def readProps(prefsLoc):
+    """Read the version of our project as a string"""
+
+    config = configparser.RawConfigParser()
+    config.read(prefsLoc)
+    version = dict(config.items('VERSION'))
+    verObj = dict(short = "{}.{}.{}".format(version["major"], version["minor"], version["build"]),
+        long = "unset")
+
+    # Try to find current build SHA if if the workspace is clean.  This could fail if git is not installed
+    try:
+        sha = subprocess.check_output(
+            ['git', 'rev-parse', '--short', 'HEAD']).decode("utf-8").strip()
+        isDirty = subprocess.check_output(
+            ['git', 'diff', 'HEAD']).decode("utf-8").strip()
+        suffix = sha
+        if isDirty:
+            # short for 'dirty', we want to keep our verstrings source for protobuf reasons
+            suffix = sha + "-d"
+        verObj['long'] = "{}.{}.{}.{}".format(
+            version["major"], version["minor"], version["build"], suffix)
+    except:
+        # print("Unexpected error:", sys.exc_info()[0])
+        # traceback.print_exc()
+        verObj['long'] = verObj['short']
+
+    # print("firmware version " + verStr)
+    return verObj
+# print("path is" + ','.join(sys.path))

bin/regen-protos.bat

@@ -0,0 +1 @@
+cd protobufs && ..\nanopb-0.4.6\generator-bin\protoc.exe --nanopb_out=-v:..\src\mesh\generated -I=..\protobufs *.proto

bin/regen-protos.sh

@@ -1,6 +1,15 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+set -e
+
+echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.6 to be located in the"
+echo "firmware root directory if the following step fails, you should download the correct"
+echo "prebuilt binaries for your computer into nanopb-0.4.6"
 
-echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.1"
 # the nanopb tool seems to require that the .options file be in the current directory!
-cd proto
-../../nanopb-0.4.1-linux-x86/generator-bin/protoc --nanopb_out=-v:../src -I=../proto mesh.proto
+cd protobufs
+../nanopb-0.4.6/generator-bin/protoc --nanopb_out=-v:../src/mesh/generated -I=../protobufs *.proto
+
+#echo "Regenerating protobuf documentation - if you see an error message"
+#echo "you can ignore it unless doing a new protobuf release to github."
+#bin/regen-docs.sh

bin/run-0-monitor.sh

@@ -1 +0,0 @@
-pio run --upload-port /dev/ttyUSB0 -t upload -t monitor

bin/run-both-monitor.sh

@@ -1,7 +0,0 @@
-set -e 
-
-echo uploading to usb1
-pio run --upload-port /dev/ttyUSB1 -t upload
-
-echo uploading to usb0
-pio run --upload-port /dev/ttyUSB0 -t upload -t monitor

bin/run-openocd.sh

@@ -1,5 +0,0 @@
-
-
-# /home/kevinh/.platformio/packages/tool-openocd-esp32/bin/openocd -s /home/kevinh/.platformio/packages/tool-openocd-esp32 -c gdb_port pipe; tcl_port disabled; telnet_port disabled -s /home/kevinh/.platformio/packages/tool-openocd-esp32/share/openocd/scripts -f interface/jlink.cfg -f board/esp-wroom-32.cfg
-/home/kevinh/.platformio/packages/tool-openocd-esp32/bin/openocd -s /home/kevinh/.platformio/packages/tool-openocd-esp32 -s /home/kevinh/.platformio/packages/tool-openocd-esp32/share/openocd/scripts -f interface/jlink.cfg -f ./lora32-openocd.cfg
-

bin/start-terminal.sh

@@ -1 +0,0 @@
-pio device monitor -b 115200

bin/test-simulator.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+
+echo "Starting simulator"
+.pio/build/native/program &
+sleep 20 # 5 seconds was not enough
+
+echo "Simulator started, launching python test..."
+python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
+

bin/uf2-convert.bat

@@ -0,0 +1,2 @@
+@echo off
+if [%1]==[] (echo "Please specify a platformio NRF target (i.e. rak4631) as the first argument.") else (python3 .\bin\uf2conv.py .\.pio\build\%1\firmware.hex -c -o .\.pio\build\%1\firmware.uf2 -f 0xADA52840)

bin/uf2conv.py

@@ -0,0 +1,314 @@
+#!/usr/bin/env python3
+import sys
+import struct
+import subprocess
+import re
+import os
+import os.path
+import argparse
+
+
+UF2_MAGIC_START0 = 0x0A324655 # "UF2\n"
+UF2_MAGIC_START1 = 0x9E5D5157 # Randomly selected
+UF2_MAGIC_END    = 0x0AB16F30 # Ditto
+
+families = {
+    'SAMD21': 0x68ed2b88,
+    'SAML21': 0x1851780a,
+    'SAMD51': 0x55114460,
+    'NRF52': 0x1b57745f,
+    'STM32F0': 0x647824b6,
+    'STM32F1': 0x5ee21072,
+    'STM32F2': 0x5d1a0a2e,
+    'STM32F3': 0x6b846188,
+    'STM32F4': 0x57755a57,
+    'STM32F7': 0x53b80f00,
+    'STM32G0': 0x300f5633,
+    'STM32G4': 0x4c71240a,
+    'STM32H7': 0x6db66082,
+    'STM32L0': 0x202e3a91,
+    'STM32L1': 0x1e1f432d,
+    'STM32L4': 0x00ff6919,
+    'STM32L5': 0x04240bdf,
+    'STM32WB': 0x70d16653,
+    'STM32WL': 0x21460ff0,
+    'ATMEGA32': 0x16573617,
+    'MIMXRT10XX': 0x4FB2D5BD
+}
+
+INFO_FILE = "/INFO_UF2.TXT"
+
+appstartaddr = 0x2000
+familyid = 0x0
+
+
+def is_uf2(buf):
+    w = struct.unpack("<II", buf[0:8])
+    return w[0] == UF2_MAGIC_START0 and w[1] == UF2_MAGIC_START1
+
+def is_hex(buf):
+    try:
+        w = buf[0:30].decode("utf-8")
+    except UnicodeDecodeError:
+        return False
+    if w[0] == ':' and re.match(b"^[:0-9a-fA-F\r\n]+$", buf):
+        return True
+    return False
+
+def convert_from_uf2(buf):
+    global appstartaddr
+    numblocks = len(buf) // 512
+    curraddr = None
+    outp = b""
+    for blockno in range(numblocks):
+        ptr = blockno * 512
+        block = buf[ptr:ptr + 512]
+        hd = struct.unpack(b"<IIIIIIII", block[0:32])
+        if hd[0] != UF2_MAGIC_START0 or hd[1] != UF2_MAGIC_START1:
+            print("Skipping block at " + ptr + "; bad magic")
+            continue
+        if hd[2] & 1:
+            # NO-flash flag set; skip block
+            continue
+        datalen = hd[4]
+        if datalen > 476:
+            assert False, "Invalid UF2 data size at " + ptr
+        newaddr = hd[3]
+        if curraddr == None:
+            appstartaddr = newaddr
+            curraddr = newaddr
+        padding = newaddr - curraddr
+        if padding < 0:
+            assert False, "Block out of order at " + ptr
+        if padding > 10*1024*1024:
+            assert False, "More than 10M of padding needed at " + ptr
+        if padding % 4 != 0:
+            assert False, "Non-word padding size at " + ptr
+        while padding > 0:
+            padding -= 4
+            outp += b"\x00\x00\x00\x00"
+        outp += block[32 : 32 + datalen]
+        curraddr = newaddr + datalen
+    return outp
+
+def convert_to_carray(file_content):
+    outp = "const unsigned char bindata[] __attribute__((aligned(16))) = {"
+    for i in range(len(file_content)):
+        if i % 16 == 0:
+            outp += "\n"
+        outp += "0x%02x, " % ord(file_content[i])
+    outp += "\n};\n"
+    return outp
+
+def convert_to_uf2(file_content):
+    global familyid
+    datapadding = b""
+    while len(datapadding) < 512 - 256 - 32 - 4:
+        datapadding += b"\x00\x00\x00\x00"
+    numblocks = (len(file_content) + 255) // 256
+    outp = b""
+    for blockno in range(numblocks):
+        ptr = 256 * blockno
+        chunk = file_content[ptr:ptr + 256]
+        flags = 0x0
+        if familyid:
+            flags |= 0x2000
+        hd = struct.pack(b"<IIIIIIII",
+            UF2_MAGIC_START0, UF2_MAGIC_START1,
+            flags, ptr + appstartaddr, 256, blockno, numblocks, familyid)
+        while len(chunk) < 256:
+            chunk += b"\x00"
+        block = hd + chunk + datapadding + struct.pack(b"<I", UF2_MAGIC_END)
+        assert len(block) == 512
+        outp += block
+    return outp
+
+class Block:
+    def __init__(self, addr):
+        self.addr = addr
+        self.bytes = bytearray(256)
+
+    def encode(self, blockno, numblocks):
+        global familyid
+        flags = 0x0
+        if familyid:
+            flags |= 0x2000
+        hd = struct.pack("<IIIIIIII",
+            UF2_MAGIC_START0, UF2_MAGIC_START1,
+            flags, self.addr, 256, blockno, numblocks, familyid)
+        hd += self.bytes[0:256]
+        while len(hd) < 512 - 4:
+            hd += b"\x00"
+        hd += struct.pack("<I", UF2_MAGIC_END)
+        return hd
+
+def convert_from_hex_to_uf2(buf):
+    global appstartaddr
+    appstartaddr = None
+    upper = 0
+    currblock = None
+    blocks = []
+    for line in buf.split('\n'):
+        if line[0] != ":":
+            continue
+        i = 1
+        rec = []
+        while i < len(line) - 1:
+            rec.append(int(line[i:i+2], 16))
+            i += 2
+        tp = rec[3]
+        if tp == 4:
+            upper = ((rec[4] << 8) | rec[5]) << 16
+        elif tp == 2:
+            upper = ((rec[4] << 8) | rec[5]) << 4
+            assert (upper & 0xffff) == 0
+        elif tp == 1:
+            break
+        elif tp == 0:
+            addr = upper | (rec[1] << 8) | rec[2]
+            if appstartaddr == None:
+                appstartaddr = addr
+            i = 4
+            while i < len(rec) - 1:
+                if not currblock or currblock.addr & ~0xff != addr & ~0xff:
+                    currblock = Block(addr & ~0xff)
+                    blocks.append(currblock)
+                currblock.bytes[addr & 0xff] = rec[i]
+                addr += 1
+                i += 1
+    numblocks = len(blocks)
+    resfile = b""
+    for i in range(0, numblocks):
+        resfile += blocks[i].encode(i, numblocks)
+    return resfile
+
+def to_str(b):
+    return b.decode("utf-8")
+
+def get_drives():
+    drives = []
+    if sys.platform == "win32":
+        r = subprocess.check_output(["wmic", "PATH", "Win32_LogicalDisk",
+                                     "get", "DeviceID,", "VolumeName,",
+                                     "FileSystem,", "DriveType"])
+        for line in to_str(r).split('\n'):
+            words = re.split('\s+', line)
+            if len(words) >= 3 and words[1] == "2" and words[2] == "FAT":
+                drives.append(words[0])
+    else:
+        rootpath = "/media"
+        if sys.platform == "darwin":
+            rootpath = "/Volumes"
+        elif sys.platform == "linux":
+            tmp = rootpath + "/" + os.environ["USER"]
+            if os.path.isdir(tmp):
+                rootpath = tmp
+        for d in os.listdir(rootpath):
+            drives.append(os.path.join(rootpath, d))
+
+
+    def has_info(d):
+        try:
+            return os.path.isfile(d + INFO_FILE)
+        except:
+            return False
+
+    return list(filter(has_info, drives))
+
+
+def board_id(path):
+    with open(path + INFO_FILE, mode='r') as file:
+        file_content = file.read()
+    return re.search("Board-ID: ([^\r\n]*)", file_content).group(1)
+
+
+def list_drives():
+    for d in get_drives():
+        print(d, board_id(d))
+
+
+def write_file(name, buf):
+    with open(name, "wb") as f:
+        f.write(buf)
+    print("Wrote %d bytes to %s" % (len(buf), name))
+
+
+def main():
+    global appstartaddr, familyid
+    def error(msg):
+        print(msg)
+        sys.exit(1)
+    parser = argparse.ArgumentParser(description='Convert to UF2 or flash directly.')
+    parser.add_argument('input', metavar='INPUT', type=str, nargs='?',
+                        help='input file (HEX, BIN or UF2)')
+    parser.add_argument('-b' , '--base', dest='base', type=str,
+                        default="0x2000",
+                        help='set base address of application for BIN format (default: 0x2000)')
+    parser.add_argument('-o' , '--output', metavar="FILE", dest='output', type=str,
+                        help='write output to named file; defaults to "flash.uf2" or "flash.bin" where sensible')
+    parser.add_argument('-d' , '--device', dest="device_path",
+                        help='select a device path to flash')
+    parser.add_argument('-l' , '--list', action='store_true',
+                        help='list connected devices')
+    parser.add_argument('-c' , '--convert', action='store_true',
+                        help='do not flash, just convert')
+    parser.add_argument('-D' , '--deploy', action='store_true',
+                        help='just flash, do not convert')
+    parser.add_argument('-f' , '--family', dest='family', type=str,
+                        default="0x0",
+                        help='specify familyID - number or name (default: 0x0)')
+    parser.add_argument('-C' , '--carray', action='store_true',
+                        help='convert binary file to a C array, not UF2')
+    args = parser.parse_args()
+    appstartaddr = int(args.base, 0)
+
+    if args.family.upper() in families:
+        familyid = families[args.family.upper()]
+    else:
+        try:
+            familyid = int(args.family, 0)
+        except ValueError:
+            error("Family ID needs to be a number or one of: " + ", ".join(families.keys()))
+
+    if args.list:
+        list_drives()
+    else:
+        if not args.input:
+            error("Need input file")
+        with open(args.input, mode='rb') as f:
+            inpbuf = f.read()
+        from_uf2 = is_uf2(inpbuf)
+        ext = "uf2"
+        if args.deploy:
+            outbuf = inpbuf
+        elif from_uf2:
+            outbuf = convert_from_uf2(inpbuf)
+            ext = "bin"
+        elif is_hex(inpbuf):
+            outbuf = convert_from_hex_to_uf2(inpbuf.decode("utf-8"))
+        elif args.carray:
+            outbuf = convert_to_carray(inpbuf)
+            ext = "h"
+        else:
+            outbuf = convert_to_uf2(inpbuf)
+        print("Converting to %s, output size: %d, start address: 0x%x" %
+              (ext, len(outbuf), appstartaddr))
+        if args.convert or ext != "uf2":
+            drives = []
+            if args.output == None:
+                args.output = "flash." + ext
+        else:
+            drives = get_drives()
+
+        if args.output:
+            write_file(args.output, outbuf)
+        else:
+            if len(drives) == 0:
+                error("No drive to deploy.")
+        for d in drives:
+            print("Flashing %s (%s)" % (d, board_id(d)))
+            write_file(d + "/NEW.UF2", outbuf)
+
+
+if __name__ == "__main__":
+    main()

bin/upload-usb1.sh

@@ -1 +0,0 @@
-pio run --upload-port /dev/ttyUSB1 -t upload

bin/version.sh

@@ -1,3 +0,0 @@
-
-
-export VERSION=0.1.0

bin/view-map.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+echo using amap tool to display memory map
+amap .pio/build/output.map

boards/eink0.1.json

@@ -0,0 +1,61 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_TTGO_EINK -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      [
+        "0x239A",
+        "0x4405"
+      ]
+    ],
+    "usb_product": "TTGO_eink",
+    "mcu": "nrf52840",
+    "variant": "eink0.1",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": [
+    "bluetooth"
+  ],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": [
+      "jlink"
+    ],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "TTGO eink (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "stlink"
+    ]
+  },
+  "url": "FIXME",
+  "vendor": "TTGO"
+}

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/lora-relay-v1.json

@@ -0,0 +1,46 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_LORA_RELAY_V1 -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x4404"]],
+    "usb_product": "LORA_RELAY",
+    "mcu": "nrf52840",
+    "variant": "lora_relay_v1",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Meshtastic Lora Relay V1 (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": ["jlink", "nrfjprog", "stlink"]
+  },
+  "url": "https://github.com/BigCorvus/SX1262-LoRa-BLE-Relay",
+  "vendor": "BigCorvus"
+}

boards/lora-relay-v2.json

@@ -0,0 +1,46 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_LORA_RELAY_V2 -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x4406"]],
+    "usb_product": "LORA_RELAY",
+    "mcu": "nrf52840",
+    "variant": "lora_relay_v2",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Meshtastic Lora Relay V1 (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": ["jlink", "nrfjprog", "stlink"]
+  },
+  "url": "https://github.com/BigCorvus/SX1262-LoRa-BLE-Relay",
+  "vendor": "BigCorvus"
+}

boards/lora_isp4520.json

@@ -0,0 +1,48 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52832_s132_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DNRF52832_XXAA -DNRF52",
+    "f_cpu": "64000000L",
+    "mcu": "nrf52832",
+    "variant": "lora_isp4520",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS132",
+      "sd_name": "s132",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B7"
+    }
+  },
+  "connectivity": [
+    "bluetooth"
+  ],
+  "debug": {
+    "jlink_device": "nRF52832_xxAA",
+    "svd_path": "nrf52.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "lora ISP4520",
+  "upload": {
+    "maximum_ram_size": 65536,
+    "maximum_size": 524288,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "nrfutil",
+      "stlink"
+    ]
+  },
+  "url": "",
+  "vendor": "PsiSoft"
+}

boards/nordic_pca10059.json

@@ -0,0 +1,72 @@
+{
+    "build": {
+        "arduino": {
+            "ldscript": "nrf52840_s140_v6.ld"
+        },
+        "core": "nRF5",
+        "cpu": "cortex-m4",
+        "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
+        "f_cpu": "64000000L",
+        "hwids": [
+            [
+                "0x239A",
+                "0x8029"
+            ],
+            [
+                "0x239A",
+                "0x0029"
+            ],
+            [
+                "0x239A",
+                "0x002A"
+            ],
+            [
+                "0x239A",
+                "0x802A"
+            ]
+        ],
+        "usb_product": "PCA10059",
+        "mcu": "nrf52840",
+        "variant": "nRF52840 Dongle",
+        "bsp": {
+            "name": "adafruit"
+        },
+        "softdevice": {
+            "sd_flags": "-DS140",
+            "sd_name": "s140",
+            "sd_version": "6.1.1",
+            "sd_fwid": "0x00B6"
+        },
+        "bootloader": {
+            "settings_addr": "0xFF000"
+        }
+    },
+    "connectivity": [
+        "bluetooth"
+    ],
+    "debug": {
+        "jlink_device": "nRF52840_xxAA",
+        "svd_path": "nrf52840.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "nRF52840 Dongle",
+    "upload": {
+        "maximum_ram_size": 248832,
+        "maximum_size": 815104,
+        "speed": 115200,
+        "protocol": "nrfutil",
+        "protocols": [
+            "jlink",
+            "nrfjprog",
+            "nrfutil",
+            "stlink"
+        ],
+        "use_1200bps_touch": true,
+        "require_upload_port": true,
+        "wait_for_upload_port": true
+    },
+    "url": "https://www.nordicsemi.com/Products/Development-hardware/nrf52840-dongle",
+    "vendor": "Nordic Semiconductor"
+}

boards/nrf52840_dk.json

@@ -0,0 +1,47 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "nrf52840_s140_v6.ld"
+      },
+      "core": "nRF5",
+      "cpu": "cortex-m4",
+      "extra_flags": "-DARDUINO_NRF52840_PCA10056 -DNRF52840_XXAA",
+      "f_cpu": "64000000L",
+      "hwids": [["0x239A", "0x4404"]],
+      "usb_product": "nrf52840dk",
+      "mcu": "nrf52840",
+      "variant": "pca10056",
+      "variants_dir": "variants",
+      "bsp": {
+        "name": "adafruit"
+      },
+      "softdevice": {
+        "sd_flags": "-DS140",
+        "sd_name": "s140",
+        "sd_version": "6.1.1",
+        "sd_fwid": "0x00B6"
+      },
+      "bootloader": {
+        "settings_addr": "0xFF000"
+      }
+    },
+    "connectivity": ["bluetooth"],
+    "debug": {
+      "jlink_device": "nRF52840_xxAA",
+      "onboard_tools": ["jlink"],
+      "svd_path": "nrf52840.svd"
+    },
+    "frameworks": ["arduino"],
+    "name": "A modified NRF52840-DK devboard (Adafruit BSP)",
+    "upload": {
+      "maximum_ram_size": 248832,
+      "maximum_size": 815104,
+      "require_upload_port": true,
+      "speed": 115200,
+      "protocol": "jlink",
+      "protocols": ["jlink", "nrfjprog", "stlink"]
+    },
+    "url": "https://meshtastic.org/",
+    "vendor": "Nordic Semi"
+  }
+  

boards/nrf52840_dk_modified.json

@@ -0,0 +1,46 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s113_v7.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_PCA10056 -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x4404"]],
+    "usb_product": "nrf52840dk",
+    "mcu": "nrf52840",
+    "variant": "pca10056-rc-clock",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "A modified NRF52840-DK devboard (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": ["jlink", "nrfjprog", "stlink"]
+  },
+  "url": "https://meshtastic.org/",
+  "vendor": "Nordic Semi"
+}

boards/ppr.json

@@ -0,0 +1,46 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_PPR -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x4403"]],
+    "usb_product": "PPR",
+    "mcu": "nrf52840",
+    "variant": "ppr",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Meshtastic PPR (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": ["jlink", "nrfjprog", "stlink"]
+  },
+  "url": "https://meshtastic.org/",
+  "vendor": "Othernet"
+}

boards/ppr1.json

@@ -0,0 +1,46 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52833_s113_v7.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52833_PPR -DNRF52833_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x4406"]],
+    "usb_product": "PPR",
+    "mcu": "nrf52833",
+    "variant": "ppr",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS113",
+      "sd_name": "s113",
+      "sd_version": "7.2.0",
+      "sd_fwid": "0x00b6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52833_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52833.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Meshtastic PPR1 (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": ["jlink", "nrfjprog", "stlink"]
+  },
+  "url": "https://meshtastic.org/",
+  "vendor": "Othernet"
+}

boards/t-echo.json

@@ -0,0 +1,64 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_TTGO_EINK -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      [
+        "0x239A",
+        "0x4405"
+      ]
+    ],
+    "usb_product": "TTGO_eink",
+    "mcu": "nrf52840",
+    "variant": "t-echo",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": [
+    "bluetooth"
+  ],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": [
+      "jlink"
+    ],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "TTGO eink (Adafruit BSP)",
+    "upload": {
+      "maximum_ram_size": 248832,
+      "maximum_size": 815104,
+      "speed": 115200,
+      "protocol": "nrfutil",
+      "protocols": [
+          "jlink",
+          "nrfjprog",
+          "nrfutil",
+          "stlink"
+      ],
+      "use_1200bps_touch": true,
+      "require_upload_port": true,
+      "wait_for_upload_port": true
+  },
+  "url": "FIXME",
+  "vendor": "TTGO"
+}

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"
+}

boards/wiscore_rak11200.json

@@ -0,0 +1,39 @@
+{
+  "build": {
+    "arduino":{
+      "ldscript": "esp32_out.ld"
+    },
+    "core": "esp32",
+    "extra_flags": "-DARDUINO_ESP32_DEV",
+    "f_cpu": "240000000L",
+    "f_flash": "40000000L",
+    "flash_mode": "dio",
+    "mcu": "esp32",
+    "variant": "WisCore_RAK11200_Board"
+  },
+  "connectivity": [
+    "wifi",
+    "bluetooth",
+    "ethernet",
+    "can"
+  ],
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "WisCore RAK11200 Board",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "protocols": [
+      "esptool",
+      "espota",
+      "ftdi"
+    ],
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://www.rakwireless.com",
+  "vendor": "RAKwireless"
+}

boards/wiscore_rak4600.json

@@ -0,0 +1,71 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52832_s132_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DNRF52832_XXAA -DNRF52",
+    "f_cpu": "64000000L",
+    "hwids": [
+      [
+        "0x239A",
+        "0x8029"
+      ],
+      [
+        "0x239A",
+        "0x0029"
+      ],
+      [
+        "0x239A",
+        "0x002A"
+      ],
+      [
+        "0x239A",
+        "0x802A"
+      ]
+    ],
+    "usb_product": "Feather nRF52832 Express",
+    "mcu": "nrf52832",
+    "variant": "WisCore_RAK4600_Board",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS132",
+      "sd_name": "s132",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B7"
+    },
+    "zephyr": {
+      "variant": "nrf52_adafruit_feather"
+    }
+  },
+  "connectivity": [
+    "bluetooth"
+  ],
+  "debug": {
+    "jlink_device": "nRF52832_xxAA",
+    "svd_path": "nrf52.svd"
+  },
+  "frameworks": [
+    "arduino",
+    "zephyr"
+  ],
+  "name": "Adafruit Bluefruit nRF52832 Feather",
+  "upload": {
+    "maximum_ram_size": 65536,
+    "maximum_size": 524288,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "nrfutil",
+      "stlink"
+    ]
+  },
+  "url": "https://www.adafruit.com/product/3406",
+  "vendor": "Adafruit"
+}

boards/wiscore_rak4631.json

@@ -0,0 +1,72 @@
+{
+    "build": {
+        "arduino": {
+            "ldscript": "nrf52840_s140_v6.ld"
+        },
+        "core": "nRF5",
+        "cpu": "cortex-m4",
+        "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
+        "f_cpu": "64000000L",
+        "hwids": [
+            [
+                "0x239A",
+                "0x8029"
+            ],
+            [
+                "0x239A",
+                "0x0029"
+            ],
+            [
+                "0x239A",
+                "0x002A"
+            ],
+            [
+                "0x239A",
+                "0x802A"
+            ]
+        ],
+        "usb_product": "WisCore RAK4631 Board",
+        "mcu": "nrf52840",
+        "variant": "WisCore_RAK4631_Board",
+        "bsp": {
+            "name": "adafruit"
+        },
+        "softdevice": {
+            "sd_flags": "-DS140",
+            "sd_name": "s140",
+            "sd_version": "6.1.1",
+            "sd_fwid": "0x00B6"
+        },
+        "bootloader": {
+            "settings_addr": "0xFF000"
+        }
+    },
+    "connectivity": [
+        "bluetooth"
+    ],
+    "debug": {
+        "jlink_device": "nRF52840_xxAA",
+        "svd_path": "nrf52840.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "WisCore RAK4631 Board",
+    "upload": {
+        "maximum_ram_size": 248832,
+        "maximum_size": 815104,
+        "speed": 115200,
+        "protocol": "nrfutil",
+        "protocols": [
+            "jlink",
+            "nrfjprog",
+            "nrfutil",
+            "stlink"
+        ],
+        "use_1200bps_touch": true,
+        "require_upload_port": true,
+        "wait_for_upload_port": true
+    },
+    "url": "https://www.rakwireless.com",
+    "vendor": "RAKwireless"
+}

docs/.well-known/assetlinks.json

@@ -1,9 +0,0 @@
-[{
-  "relation": ["delegate_permission/common.handle_all_urls"],
-  "target": {
-    "namespace": "android_app",
-    "package_name": "com.geeksville.mesh",
-    "sha256_cert_fingerprints":
-    ["D0:05:E7:8B:D2:1B:FA:94:56:1D:6B:90:EB:53:07:1A:74:4F:D9:C2:6F:13:87:6A:D9:17:4F:C2:59:48:02:9D"]
-  }
-}]

docs/CNAME

@@ -1 +0,0 @@
-www.meshtastic.org

docs/README.md

@@ -1,82 +0,0 @@
-# What is Meshtastic?
-
-Meshtastic is a project that lets you use
-inexpensive ($30 ish) GPS radios as an extensible, super long battery life mesh GPS communicator.  These radios are great for hiking, skiing, paragliding - 
-essentially any hobby where you don't have reliable internet access.  Each member of your private mesh can always see the location and distance of all other
-members and any text messages sent to your group chat.
-
-The radios automatically create a mesh to forward packets as needed, so everyone in the group can receive messages from even the furthest member.  The radios
-will optionally work with your phone, but no phone is required.
-
-### Uses
-
-* Outdoor sports where cellular coverage is limited. (Hiking, Skiing, Boating, Paragliding, Gliders etc..)
-* Applications where closed source GPS communicators just won't cut it (it is easy to add features for glider pilots etc...)
-* Secure long-range communication within groups without depending on cellular providers
-* Finding your lost kids ;-)
-
-[![Youtube video demo](desk-video-screenshot.png)](https://www.youtube.com/watch?v=WlNbMbVZlHI "Meshtastic early demo")
-
-### Features
-Not all of these features are fully implemented yet - see **important** disclaimers below.  But they should be in by the time we decide to call this project beta (three months?)
-
-* Very long battery life (should be about eight days with the beta software)
-* Built in GPS and [LoRa](https://en.wikipedia.org/wiki/LoRa) radio, but we manage the radio automatically for you
-* Long range - a few miles per node but each node will forward packets as needed
-* Shows direction and distance to all members of your channel
-* Directed or broadcast text messages for channel members
-* Open and extensible codebase supporting multiple hardware vendors - no lock in to one vendor
-* Communication API for bluetooth devices (such as our Android app) to use the mesh.  So if you have some application that needs long range low power networking, this might work for you.
-* Eventually (within a couple of months) we should have a modified version of Signal that works with this project.
-* Very easy sharing of private secured channels.  Just share a special link or QR code with friends and they can join your encrypted mesh
- 
-This project is currently in early alpha - if you have questions please join our chat [![Join the chat at https://gitter.im/Meshtastic/community](https://badges.gitter.im/Meshtastic/community.svg)](https://gitter.im/Meshtastic/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge).
-
-This software is 100% open source and developed by a group of hobbyist experimenters.  No warranty is provided, if you'd like to improve it - we'd love your help.  Please post in the [chat](https://gitter.im/Meshtastic/community).  
-
-# Updates
-
-Note: Updates are happening almost daily, only major updates are listed below.  For more details see our chat, github releases or the Android alpha tester emails.
-
-* 03/03/2020 - 0.0.9 of the Android app and device code is released.  Still an alpha but fairly functional.
-* 02/25/2020 - 0.0.4 of the Android app is released.  This is a very early alpha, see below to join the alpha-testers group.
-* 02/23/2020 - 0.0.4 release.  Still very bleeding edge but much closer to the final power management, a charged T-BEAM should run for many days with this load.  If you'd like to try it, we'd love your feedback.  Click [here](https://github.com/meshtastic/Meshtastic-esp32/blob/master/README.md) for instructions.
-* 02/20/2020 - Our first alpha release (0.0.3) of the radio software is ready brave early people.  
-
-## Meshtastic Android app
-Once out of alpha the companion Android application will be released here:
-
-[![Download at https://play.google.com/store/apps/details?id=com.geeksville.mesh](https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png)](https://play.google.com/store/apps/details?id=com.geeksville.mesh&referrer=utm_source%3Dhomepage%26anid%3Dadmob)
-
-But if you want the bleeding edge app now, we'd love to have your help testing.  Three steps to opt-in to the alpha- test:
-
-1. Join [this Google group](https://groups.google.com/forum/#!forum/meshtastic-alpha-testers) with the account you use in Google Play.
-2. Go to this [URL](https://play.google.com/apps/testing/com.geeksville.mesh) to opt-in to the alpha test.
-3. If you encounter any problems or have questions, post in our gitter chat and we'll help.
-
-If you'd like to help with development, the source code is [on github](https://github.com/meshtastic/Meshtastic-Android).
-
-## Supported hardware
-We currently support two brands of radios.  The [TTGO T-Beam](https://www.aliexpress.com/item/4000119152086.html) and the [Heltec LoRa 32](https://heltec.org/project/wifi-lora-32/).  Most people should buy the T-Beam and a 18650 battery (total cost less than $35).  Make
-sure to buy the frequency range which is legal for your country.  For the USA, you should buy the 915MHz version.  Getting a version that include a screen is optional, but highly recommended.
-
-Instructions for installing prebuilt firmware can be found [here](https://github.com/meshtastic/Meshtastic-esp32/blob/master/README.md).
-
-For a nice TTGO 3D printable case see this [design](https://www.thingiverse.com/thing:3773717) by [bsiege](https://www.thingiverse.com/bsiege).
-For a nice Heltec 3D printable case see this [design](https://www.thingiverse.com/thing:3125854) by [ornotermes](https://www.thingiverse.com/ornotermes).
-
-# Disclaimers
-
-This project is still pretty young but moving at a pretty good pace.  Not all features are fully implemented in the current alpha builds.
-Most of these problems should be solved by the beta release:
-
-* We don't make these devices and they haven't been tested by UL or the FCC.  If you use them you are experimenting and we can't promise they won't burn your house down ;-)
-* Encryption is turned off for now
-* A number of (straightforward) software work items have to be completed before battery life matches our measurements, currently battery life is about three days.  Join us on chat if you want the spreadsheet of power measurements/calculations.
-* The current Android GUI is pretty ugly still
-* The Android API needs to be documented better
-* The Bluetooth API needs to be documented better 
-* The mesh protocol is turned off for now, currently we only send packets one hop distant
-* No one has written an iOS app yet ;-)
-
-For more details see the [device software TODO](https://github.com/meshtastic/Meshtastic-esp32/blob/master/TODO.md) or the [Android app TODO](https://github.com/meshtastic/Meshtastic-Android/blob/master/TODO.md).

docs/_config.yml

@@ -1,5 +0,0 @@
-theme: jekyll-theme-cayman
-
-title: Meshtastic
-description: An opensource hiking, pilot, skiing, Signal-App-extending GPS mesh communicator
-google_analytics: G-DRZ5H5EXHV

docs/editing-this-site.md

@@ -1,10 +0,0 @@
-If you'd like to edit this website and test it locally:
-
-Not yet implemented:
-Per https://help.github.com/en/github/working-with-github-pages/testing-your-github-pages-site-locally-with-jekyll
-
-* follow instructions here: https://jekyllrb.com/docs/installation/ubuntu/
-* run "run-locally.sh"
-* view webpages at localhost:4000
-
-The template seems to come from here: https://github.com/pages-themes/cayman

docs/privacy.md

@@ -1,11 +0,0 @@
-# Meshtastic privacy policy
-
-We don't collect any personal identifying information.  
-
-If you have opted-in to analytics (thank you - that helps us know what things we need to improve), we'll receive anonymized information about user behavior.  i.e. which screens you used in the app etc...  We never
-capture usernames, the contents of your texts or your location.
-
-This is an open-source project run by hobbyists and we try to be completely transparent.  If you have questions on this policy, please file [a github issue](https://github.com/meshtastic/meshtastic-esp32/issues) and we'll reply/clarify/correct.
-
-Keep being awesome!
-

docs/radio-settings.md

@@ -1,23 +0,0 @@
-# Radio settings
-
-We use the same channel maps as LoRaWAN (though this is not LoRaWAN).
-
-![freq table](images/LoRa-Frequency-Bands.jpg)
-
-See [this site](https://www.rfwireless-world.com/Tutorials/LoRa-channels-list.html) for more information.
-
-## LoRaWAN Europe Frequency Band
-
-The maximum power allowed is +14dBM.
-
-There are eight channels defined with a 0.3 MHz gap between them.
-Channel zero starts at 865.20 MHz
-
-## LoRaWAN for North America
-
-LoRaWAN defines 64, 125 kHz channels from 902.3 to 914.9 MHz increments.
-
-The maximum output power for North America is +30 dBM.
-
-The band is from 902 to 928 MHz. It mentions channel number and its respective channel frequency. All the 13 channels are separated by 2.16 MHz with respect to the adjacent channels.  
-Channel zero starts at 903.08 MHz center frequency.

docs/sw-design.md

@@ -1,126 +0,0 @@
-This is a mini design doc for various core behaviors...
-
-# Rules for sleep
-
-## States
-
-From lower to higher power consumption.
-
-* Super-deep-sleep (SDS) - everything is off, CPU, radio, bluetooth, GPS.  Only wakes due to timer or button press.  We enter this mode only after no radio comms for a few hours, used to put the device into what is effectively "off" mode.
-  onEntry: setBluetoothOn(false), call doDeepSleep
-  onExit: (standard bootup code, starts in DARK)
-
-* deep-sleep (DS) - CPU is off, radio is on, bluetooth and GPS is off.  Note: This mode is never used currently, because it only saves 1.5mA vs light-sleep
-  (Not currently used)
-
-* light-sleep (LS) - CPU is suspended (RAM stays alive), radio is on, bluetooth is off, GPS is off.  Note: currently GPS is not turned 
-off during light sleep, but there is a TODO item to fix this.
-  onEntry: setBluetoothOn(false), setGPSPower(false), doLightSleep()
-  onIdle: (if we wake because our led blink timer has expired) blink the led then go back to sleep until we sleep for ls_secs
-  onExit: setGPSPower(true), start trying to get gps lock: gps.startLock(), once lock arrives service.sendPosition(BROADCAST)
-
-* No bluetooth (NB) - CPU is running, radio is on, GPS is on but bluetooth is off, screen is off.
-  onEntry: setBluetoothOn(false)
-  onExit: 
-
-* running dark (DARK) - Everything is on except screen
-  onEntry: setBluetoothOn(true)
-  onExit: 
-
-* full on (ON) - Everything is on
-  onEntry: setBluetoothOn(true), screen.setOn(true)
-  onExit: screen.setOn(false)
-
-## Behavior
-
-### events that increase CPU activity
-
-* At cold boot: The initial state (after setup() has run) is DARK
-* While in DARK: if we receive EVENT_BOOT, transition to ON (and show the bootscreen).  This event will be sent if we detect we woke due to reset (as opposed to deep sleep)
-* While in LS: Once every position_broadcast_secs (default 15 mins) - the unit will wake into DARK mode and broadcast a "networkPing" (our position) and stay alive for wait_bluetooth_secs (default 30 seconds).  This allows other nodes to have a record of our last known position if we go away and allows a paired phone to hear from us and download messages.
-* While in LS: Every send_owner_interval (defaults to 4, i.e. one hour), when we wake to send our position we _also_ broadcast our owner.  This lets new nodes on the network find out about us or correct duplicate node number assignments.
-* While in LS/NB/DARK: If the user presses a button (EVENT_PRESS) we go to full ON mode for screen_on_secs (default 30 seconds).  Multiple presses keeps resetting this timeout
-* While in LS/NB/DARK: If we receive new text messages (EVENT_RECEIVED_TEXT_MSG), we go to full ON mode for screen_on_secs (same as if user pressed a button)
-* While in LS: while we receive packets on the radio (EVENT_RECEIVED_PACKET) we will wake and handle them and stay awake in NB mode for min_wake_secs (default 10 seconds) 
-* While in NB: If we do have packets the phone (EVENT_PACKETS_FOR_PHONE) would want we transition to DARK mode for wait_bluetooth secs.
-* While in DARK/ON: If we receive EVENT_BLUETOOTH_PAIR we transition to ON and start our screen_on_secs timeout
-* While in NB/DARK/ON: If we receive EVENT_NODEDB_UPDATED we transition to ON (so the new screen can be shown)
-* While in DARK: While the phone talks to us over BLE (EVENT_CONTACT_FROM_PHONE) reset any sleep timers and stay in DARK (needed for bluetooth sw update and nice user experience if the user is reading/replying to texts)
-
-### events that decrease cpu activity
-
-* While in ON: If PRESS event occurs, reset screen_on_secs timer and tell the screen to handle the pess
-* While in ON: If it has been more than screen_on_secs since a press, lower to DARK
-* While in DARK: If time since last contact by our phone exceeds phone_timeout_secs (15 minutes), we transition down into NB mode
-* While in DARK or NB: If nothing above is forcing us to stay in a higher mode (wait_bluetooth_secs, min_wake_secs) we will lower down to LS state
-* While in LS: If either phone_sds_timeout_secs (default 2 hr) or mesh_sds_timeout_secs (default 2 hr) are exceeded we will lower into SDS mode for sds_secs (default 1 yr) (or a button press).  
-* Any time we enter LS mode: We stay in that until an interrupt, button press or other state transition.  Every ls_secs (default 1 hr) and let the arduino loop() run one iteration (FIXME, not sure if we need this at all), and then immediately reenter lightsleep mode on the CPU.
-
-TODO: Eventually these scheduled intervals should be synchronized to the GPS clock, so that we can consider leaving the lora receiver off to save even more power.
-TODO: In NB mode we should put cpu into light sleep any time we really aren't that busy (without declaring LS state) - i.e. we should leave GPS on etc...
-
-# Low power consumption tasks
-
-General ideas to hit the power draws our spreadsheet predicts.  Do the easy ones before beta, the last 15% can be done after 1.0.
-
-* don't even power on the gps until someone else wants our position, just stay in lora deep sleep until press or rxpacket (except for once an hour updates)
-* (possibly bad idea - better to have lora radio always listen - check spreadsheet) have every node wake at the same tick and do their position syncs then go back to deep sleep
-* lower BT announce interval to save battery
-* change to use RXcontinuous mode and config to drop packets with bad CRC (see section 6.4 of datasheet) - I think this is already the case
-* have mesh service run in a thread that stays blocked until a packet arrives from the RF95
-* platformio sdkconfig CONFIG_PM and turn on modem sleep mode
-* keep cpu 100% in deepsleep until irq from radio wakes it.  Then stay awake for 30 secs to attempt delivery to phone.  
-* use https://lastminuteengineers.com/esp32-sleep-modes-power-consumption/ association sleep pattern to save power - but see https://github.com/espressif/esp-idf/issues/2070 and https://esp32.com/viewtopic.php?f=13&t=12182 it seems with BLE on the 'easy' draw people are getting is 80mA
-* stop using loop() instead use a job queue and let cpu sleep
-* measure power consumption and calculate battery life assuming no deep sleep
-* do lowest sleep level possible where BT still works during normal sleeping, make sure cpu stays in that mode unless lora rx packet happens, bt rx packet happens or button press happens
-* optionally do lora messaging only during special scheduled intervals (unless nodes are told to go to low latency mode), then deep sleep except during those intervals - before implementing calculate what battery life would be with  this feature
-* see section 7.3 of https://cdn.sparkfun.com/assets/learn_tutorials/8/0/4/RFM95_96_97_98W.pdf and have hope radio wake only when a valid packet is received.  Possibly even wake the ESP32 from deep sleep via GPIO.
-* never enter deep sleep while connected to USB power (but still go to other low power modes)
-* when main cpu is idle (in loop), turn cpu clock rate down and/or activate special sleep modes.  We want almost everything shutdown until it gets an interrupt.
-
-# Mesh broadcast algoritm
-
-FIXME - instead look for standard solutions.  this approach seems really suboptimal, because too many nodes will try to rebroast.  If
-all else fails could always use the stock radiohead solution - though super inefficent.
-
-## approach 1
-
-* send all broadcasts with a TTL
-* periodically(?) do a survey to find the max TTL that is needed to fully cover the current network.
-* to do a study first send a broadcast (maybe our current initial user announcement?) with TTL set to one (so therefore no one will rebroadcast our request)
-* survey replies are sent unicast back to us (and intervening nodes will need to keep the route table that they have built up based on past packets)
-* count the number of replies to this TTL 1 attempt.  That is the number of nodes we can reach without any rebroadcasts
-* repeat the study with a TTL of 2 and then 3.  stop once the # of replies stops going up.
-* it is important for any node to do listen before talk to prevent stomping on other rebroadcasters...
-* For these little networks I bet a max TTL would never be higher than 3?
-
-## approach 2
-
-* send a TTL1 broadcast, the replies let us build a list of the nodes (stored as a bitvector?) that we can see (and their rssis)
-* we then broadcast out that bitvector (also TTL1) asking "can any of ya'll (even indirectly) see anyone else?"
-* if a node can see someone I missed (and they are the best person to see that node), they reply (unidirectionally) with the missing nodes and their rssis (other nodes might sniff (and update their db) based on this reply but they don't have to)
-* given that the max number of nodes in this mesh will be like 20 (for normal cases), I bet globally updating this db of "nodenums and who has the best rssi for packets from that node" would be useful
-* once the global DB is shared, when a node wants to broadcast, it just sends out its broadcast . the first level receivers then make a decision "am I the best to rebroadcast to someone who likely missed this packet?" if so, rebroadcast
-
-## approach 3
-
-* when a node X wants to know other nodes positions, it broadcasts its position with want_replies=true.  Then each of the nodes that received that request broadcast their replies (possibly by using special timeslots?)
-* all nodes constantly update their local db based on replies they witnessed.
-* after 10s (or whatever) if node Y notices that it didn't hear a reply from node Z (that Y has heard from recently ) to that initial request, that means Z never heard the request from X.  Node Y will reply to X on Z's behalf.
-* could this work for more than one hop?  Is more than one hop needed?  Could it work for sending messages (i.e. for a msg sent to Z with want-reply set). 
-
-## approach 4
-
-look into the literature for this idea specifically.
-
-* don't view it as a mesh protocol as much as a "distributed db unification problem".  When nodes talk to nearby nodes they work together
-to update their nodedbs.  Each nodedb would have a last change date and any new changes that only one node has would get passed to the 
-other node.  This would nicely allow distant nodes to propogate their position to all other nodes (eventually).
-* handle group messages the same way, there would be a table of messages and time of creation.
-* when a node has a new position or message to send out, it does a broadcast.  All the adjacent nodes update their db instantly (this handles 90% of messages I'll bet).  
-* Occasionally a node might broadcast saying "anyone have anything newer than time X?"  If someone does, they send the diffs since that date.
-* essentially everything in this variant becomes broadcasts of "request db updates for >time X - for _all_ or for a particular nodenum" and nodes sending (either due to request or because they changed state) "here's a set of db updates".  Every node is constantly trying to
-build the most recent version of reality, and if some nodes are too far, then nodes closer in will eventually forward their changes to the distributed db.
-* construct non ambigious rules for who broadcasts to request db updates.  ideally the algorithm should nicely realize node X can see most other nodes, so they should just listen to all those nodes and minimize the # of broadcasts. the distributed picture of nodes rssi could be useful here?
-* possibly view the BLE protocol to the radio the same way - just a process of reconverging the node/msgdb database.

images/genfiles.sh

@@ -1,11 +0,0 @@
-# using height of 50 to have 14 pixels beneath icon for text
-inkscape -z -e icon.png -w 50 -h 50 icon-24px.svg
-convert icon.png -background white -alpha Background ../src/icon.xbm
-
-inkscape -z -e compass.png -w 48 -h 48 location_searching-24px.svg
-convert compass.png -background white -alpha Background ../src/compass.xbm
-
-inkscape -z -e face.png -w 13 -h 13 face-24px.svg
-
-inkscape -z -e pin.png -w 13 -h 13 room-24px.svg
-convert pin.png -background white -alpha Background ../src/pin.xbm