diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 1786759aa0..d8c5fed325 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -313,7 +313,7 @@ firmware/ │ └── native/ # Linux/Portduino variants ├── protobufs/ # Protocol buffer definitions ├── boards/ # Custom PlatformIO board definitions -├── test/ # Native unit-test suites (count: test/native-suite-count) +├── test/ # Native unit-test suites (count = the test_* dirs, detected on the fly) └── bin/ # Build and utility scripts ``` @@ -332,12 +332,24 @@ firmware/ - Follow existing code style - run `trunk fmt` before commits - Prefer `LOG_DEBUG`, `LOG_INFO`, `LOG_WARN`, `LOG_ERROR` for logging +- **Three logging tiers for diagnostics.** `LOG_TRACE` is the per-packet/per-poll firehose - compiled out by default (`MESHTASTIC_TRACE_LOGGING=1` enables; always on for portduino). Subsystem bring-up detail routes through a per-subsystem gate macro instead, e.g. `LOG_DEBUG_GPS(...)` in `src/gps/GPSLog.h` (`GPS_DEBUG=1` enables; costs no flash when off) - model new subsystem gates on it or on `LOG_MIGRATION` (`src/mesh/WarmNodeStore.h`): `#ifndef` value-default, `#if SYM` value test, `((void)0)` off-branch. Genuine anomalies stay unconditional `LOG_WARN`/`LOG_ERROR`. - **Format node IDs and packet IDs as `0x%08x` in logs.** This covers `NodeNum`/`PacketId` and the `uint32_t` packet fields `from`, `to`, `id`, `dest`, `source`, `request_id`, and `node_id`. They are 32-bit, so 8 hex digits is exact - `%08x` never truncates or leaves a value ragged. Do **not** use `%x` (variable width) or `%0x` (a no-op typo for `%08x` - the `0` flag does nothing without a width). User-facing display uses `!%08x` (the `!xxxxxxxx` convention), e.g. `Applet::hexifyNodeNum`. - **Do not zero-pad one-byte values to 8.** `next_hop`, `relay_node`, and the next-hop hint are `uint8_t` last-byte route hints, and `channel` is a one-byte hash/index - log these as `0x%x` (or `%d`). Padding a byte to `0x000000ab` falsely implies a full node number. The same goes for I2C addresses, register values, flags/bitmasks, and error/reason codes: they are not IDs, so leave them `0x%x`. - Use `assert()` for invariants that should never fail - C++17 features are available (`std::optional`, structured bindings, `if constexpr`, etc.) - **Keep code comments minimal - one or two lines, max.** Comment only when the _why_ isn't obvious from the code; never restate what the next line does. No multi-paragraph block comments explaining straightforward changes. The diff and commit message carry the rationale; the code carries the behavior. -- **Use `Throttle` for time-based rate limiting, not raw `millis()` math.** `src/mesh/Throttle.h` provides `Throttle::isWithinTimespanMs(lastMs, intervalMs)` (returns true while inside the cooldown) and `Throttle::execute(&lastMs, intervalMs, func)` (function-pointer form that updates the timestamp on fire). Use these for any "did N ms pass since X" check - raw `millis() > lastMs + N` is rollover-unsafe (breaks after ~49.7 days) and inconsistent with the rest of the codebase. The helpers compute `now - lastMs` with unsigned subtraction, which wraps correctly. +- **Never compare against `millis()` directly. Use `Throttle`.** `src/mesh/Throttle.h` is the sanctioned way to ask about time, and CI enforces this (`millis-deadline-check` in `.github/workflows/test_native.yml` fails the PR on a new `millis() >` / `< millis()` comparison). + - `Throttle::isWithinTimespanMs(lastMs, intervalMs)` - true while still inside the cooldown. + - `Throttle::hasElapsed(lastMs, intervalMs)` - its complement, true once the interval has passed (inclusive `>=`). Prefer this to spelling `!isWithinTimespanMs(...)`. + - `Throttle::execute(&lastMs, intervalMs, func)` - function-pointer form that updates the timestamp on fire. + - `Throttle::deadlinePassed(deadlineMs)` - for a stored absolute deadline that cannot be re-expressed as "interval since an event". Uses an unsigned half-range compare; reads deadlines more than ~24.8 days out as already passed, which no interval in this firmware approaches (the longest is 24 h). + - `Throttle::deadlinePassedAt(nowMs, deadlineMs)` - the same test against a caller-supplied `now`, for a loop that snapshots the clock once and then tests many deadlines (`NextHopRouter::doRetransmissions()`). Take the snapshot from `Time::getMillis()`, not `millis()`. + + Raw `millis() > deadline` or `deadline < millis()` is rollover-unsafe: the comparison inverts while the deadline sits on the far side of the 32-bit wrap, so the action fires immediately (losing its whole wait) or blocks for roughly the interval it should have waited - days, for the nRF52 flash-corruption backoff. All five helpers subtract first, so unsigned wraparound cancels out. `Throttle` reads the clock through `Time::getMillis()` (`src/UptimeClock.h`), which means every one of its ~94 call sites is time-injectable - a native test can drive `Time::setTestMillis(0xFFFFFF00)` across the wrap. For _timestamps_ (not deadlines) there is `Time::getMillisMonotonic()` / `Time::getUptimeSecs()` - a 64-bit monotonic uptime read. Readers are pure: they add their own wrap-immune elapsed time to a snapshot published by `Time::serviceMonotonic()`, which the main loop calls every iteration and which is **the only writer**. Never call `serviceMonotonic()` from anywhere else - two writers can count one wrap twice, putting every uptime and wall-clock reading ~49.7 days into the future for the rest of the boot. Not ISR-safe (the snapshot is read under a seqlock); see the contract in `UptimeClock.h`. Deadline and interval checks should still use `Throttle`, which needs no carry state at all. + + **Sentinel hazard.** If a deadline variable also encodes "inactive" - `0` for `rebootAtMsec`, `shutdownAtMsec`, `alertBannerUntil`, `fixHoldEnds`; `UINT32_MAX` for `nagCycleCutoff` - test that sentinel _before_ the elapsed comparison, and match the test to the sentinel actually in use. `if (deadline && Throttle::deadlinePassed(deadline))` covers the `0` family only; `nagCycleCutoff` needs `deadline != UINT32_MAX`, or a separate armed flag as `ExternalNotificationModule` does with `isNagging`. Every sentinel value is arithmetically far in the past, so a correct comparison reads it as "expired" and fires immediately: `rebootAtMsec = -1` meaning "never" is what would have become a reboot loop. Never fold the sentinel into the helper. + + **And decide which way the sentinel should fall.** "Inactive" does not always mean "suppress". At the GPS fix-hold site `fixHoldEnds == 0` means _no hold is in force_, which is exactly when a new hold must be armed - the naive comparison it replaced was `(fixHoldEnds + GPS_THREAD_INTERVAL) < millis()`, always true when nothing was armed. Guarding it with `fixHoldEnds != 0 &&` looks like this rule and inverts the site: nothing re-arms, nothing publishes, and the receiver stays powered until the search timeout. Read the surrounding logic before adding the guard. `fixHoldInForce()` in `src/gps/GPS.cpp` is the worked example - state the predicate positively, so the sentinel has an honest answer, and derive both decisions from it - with `test/test_gps_fix_hold/` pinning both directions. ### Naming Conventions @@ -663,7 +675,7 @@ Most workflows can be triggered manually via `workflow_dispatch` for testing. ### Native unit tests (C++) -Unit tests in `test/` directory. The canonical suite count is in `test/native-suite-count`, cross-checked against `test/test_*` on every full run and by the `suite-count-check` CI job. **Never state the count as a literal anywhere else** - point at that file. The list below is a partial description of what suites cover, not an inventory: +Unit tests in `test/` directory. The canonical suite count is detected on the fly: the `test_*` directories under `test/` are the register, and `bin/run-tests.sh` cross-checks the suites that actually ran against them on every full run. **Never state the count as a literal anywhere** - it is whatever `test/test_*` contains right now. In CI, the `suite-shrinkage-check` job (`test_native.yml`) fails a PR that loses a `test_*` directory relative to its merge base unless the suite is named in the PR title, body, or a commit message - deleting a suite therefore requires saying so. The list below is a partial description of what suites cover, not an inventory: - `test_admin_radio/` - LoRa region/config validation, AdminModule dispatch, node-DB metadata saves - `test_fscommon_getfiles/` - bounded file-manifest walk (cap, depth, truncation reporting) @@ -693,7 +705,7 @@ Unit tests in `test/` directory. The canonical suite count is in `test/native-su - `test_utf8/` - UTF-8 utilities - `test_warm_store/` - Warm-tier node store -**Preferred run command - `bin/run-tests.sh`** (defaults to the `coverage` env; emits a machine-readable verdict on the final line; update `test/native-suite-count` when adding or removing suites): +**Preferred run command - `bin/run-tests.sh`** (defaults to the `coverage` env; emits a machine-readable verdict on the final line; new `test_*` directories are picked up automatically): ```bash ./bin/run-tests.sh # all suites @@ -712,18 +724,18 @@ Unit tests in `test/` directory. The canonical suite count is in `test/native-su Exit codes and verdicts (exact counts will vary; examples below are illustrative): -| Exit | Verdict | Meaning | -| ---- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| 0 | `GREEN` | All canonical suites ran, all passed, no ignored test cases | -| 1 | `RED` | At least one failure, build error, or sanitizer fault | -| 2 | `AMBER` | All that ran passed, but something was lost or unexplained: a suite silently went missing on a full run, individual test cases were skipped (`TEST_IGNORE`), `test/native-suite-count` disagrees with the `test/` directory count, or a suite left behind shared state it does not declare | -| 3 | `FILTERED` | A `-f` run completed cleanly; suites outside the filter were intentionally not run | +| Exit | Verdict | Meaning | +| ---- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 0 | `GREEN` | All canonical suites ran, all passed, no ignored test cases | +| 1 | `RED` | At least one failure, build error, or sanitizer fault | +| 2 | `AMBER` | All that ran passed, but something was lost or unexplained: a suite silently went missing on a full run, individual test cases were skipped (`TEST_IGNORE`), or a suite left behind shared state it does not declare | +| 3 | `FILTERED` | A `-f` run completed cleanly; suites outside the filter were intentionally not run | Examples - exact counts will vary by suite count and env: ```text # GREEN: all suites ran and passed -RESULT: GREEN N/N suites passed [canonical: N/N] +RESULT: GREEN N/N suites passed, all CLEAN # RED: real test failure RESULT: RED 1 failed @@ -731,14 +743,11 @@ RESULT: RED 1 failed # RED: sanitizer exit-time abort (all tests passed but process aborted at exit) RESULT: RED exit-time abort (tests passed; likely sanitizer - see hint above) -# AMBER: native-suite-count disagrees with test/ directory count (too low) -RESULT: AMBER test/ has 24 suite directories but native-suite-count says 5 - update test/native-suite-count after registering new suites - -# AMBER: native-suite-count disagrees with test/ directory count (too high) -RESULT: AMBER test/ has 24 suite directories but native-suite-count says 99 - update test/native-suite-count after removing suites +# AMBER: a suite silently went missing on a full run +RESULT: AMBER 23/24 suites ran (missing: test_radio) - all that ran passed # FILTERED: single suite run completed cleanly -RESULT: FILTERED 1/24 suites ran (not run: test_admin_radio test_atak …) - filtered: test_serial [canonical: 1/24] +RESULT: FILTERED 1/24 suites ran (not run: test_admin_radio test_atak …) - filtered: test_serial ``` > **Copilot interface note:** When running tests via the Copilot chat interface, edits made through the chat may not be reflected in the on-disk files that the test binary reads. If tests pass in chat but fail locally (or vice versa), verify the files on disk match what you expect before trusting the result. Always confirm with a local terminal run. diff --git a/.github/millis-deadline-allowlist.txt b/.github/millis-deadline-allowlist.txt new file mode 100644 index 0000000000..1363acec00 --- /dev/null +++ b/.github/millis-deadline-allowlist.txt @@ -0,0 +1,22 @@ +# Allowlist for the millis-deadline-check guard in .github/workflows/test_native.yml. +# +# That guard rejects comparisons made directly against millis(), because they invert while the +# deadline sits on the far side of the 32-bit wrap. Use Throttle::deadlinePassed(deadline) or +# Throttle::hasElapsed(lastEvent, intervalMs) instead - see .github/copilot-instructions.md. +# +# Only add a line here when the comparison genuinely is not a deadline test. The usual valid case is +# an *uptime threshold*: "has the device been up for at least N ms", where there is no stored +# deadline and no event to measure from. Those still misbehave briefly after a wrap - the threshold +# is simply re-crossed - which is harmless for boot-holdoff logic and not worth new state. +# +# Format: +# Line numbers are deliberately absent so edits above an entry do not invalidate it. A `#` comment +# on the code line is stripped before matching, so do not include one here. + +# Boot holdoff, not a deadline: suppresses a phantom shutdown from floating pins during the first +# 30s of uptime. Pairs with the buttonPressStartTime > 30000 test on the same line. +src/input/ButtonThread.cpp if (millis() > 30000 && buttonPressStartTime > 30000 && _longLongPress != INPUT_BROKER_NONE && + +# Boot-window check, not a deadline: draws the custom OEM logo only during the first 10s of uptime, +# so the ordinary Meshtastic logo is used at shutdown. +src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.cpp if (millis() < 10 * 1000UL) { diff --git a/.github/workflows/test_native.yml b/.github/workflows/test_native.yml index 2688a07b93..04e6b3a237 100644 --- a/.github/workflows/test_native.yml +++ b/.github/workflows/test_native.yml @@ -23,13 +23,19 @@ env: LCOV_CAPTURE_FLAGS: --quiet --capture --include "${PWD}/src/*" --exclude '*/src/mesh/generated/*' --directory .pio/build/coverage/src --base-directory "${PWD}" jobs: - # Guard the registered native-suite total. `platformio test` discovers and runs whatever - # test_* directories exist, so it never notices when test/native-suite-count drifts from the - # actual directory count (a suite added without registering it, or the file left stale). That - # reconciliation only lives in bin/run-tests.sh, which CI does not invoke - so mirror the exact - # check here and fail the PR on a mismatch, keeping the manual count honest. - suite-count-check: - name: Native Suite Count + # Tripwire against the native suite set shrinking by accident. `platformio test` discovers and + # runs whatever test_* directories exist, and bin/run-tests.sh derives its expected count from + # the same walk - so a suite directory lost in a bad rebase or an overzealous cleanup just means + # fewer suites run, and every remaining check stays green. Compare the test_* directory list + # against the PR's merge base and fail when a suite vanished without the PR saying so: a removed + # suite's name must appear in the PR title, the PR body, or a commit message in the PR's range. + # A deliberate removal satisfies that by stating what it removes; an accidental loss cannot. + # Only pull_request runs have a base to compare against (and PRs are where accidents arrive); + # every other event skips. No job depends on this one: a skipped job would skip its dependents, + # and the expensive jobs should not wait on a full-history clone. + suite-shrinkage-check: + name: Native Suite Shrinkage + if: github.event_name == 'pull_request' runs-on: ubuntu-slim permissions: contents: read @@ -37,40 +43,111 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 with: persist-credentials: false + # Full history: the merge base must be computed, not guessed from a possibly stale + # event payload, and the acknowledgment scan reads every commit message in the range. + fetch-depth: 0 - - name: Reconcile native-suite-count with test/ directories + - name: Fail if a test_* suite vanished unacknowledged + shell: bash + # PR title/body are attacker-controlled text; they reach the script through env: only, + # never spliced into the shell source (same rule as the suite-order seed below). + env: + BASE_REF: ${{ github.base_ref }} + PR_TITLE: ${{ github.event.pull_request.title }} + PR_BODY: ${{ github.event.pull_request.body }} + run: | + set -euo pipefail + git fetch --quiet origin "$BASE_REF" + base=$(git merge-base FETCH_HEAD HEAD) + # Same canonical set every other consumer derives: directories named test_* directly + # under test/, read from the git trees so the comparison is exact at both endpoints. + list_suites() { git ls-tree -d --name-only "$1" test/ | sed 's#^test/##' | grep '^test_' | sort; } + removed=$(comm -23 <(list_suites "$base") <(list_suites HEAD)) + if [[ -z $removed ]]; then + echo "No suite removed: $(list_suites HEAD | wc -l) test_* directories, none lost since merge base ${base:0:8}." + exit 0 + fi + messages=$(git log --format=%B "$base..HEAD") + fail=0 + while IFS= read -r suite; do + if printf '%s\n%s\n%s\n' "$PR_TITLE" "$PR_BODY" "$messages" | grep -qF "$suite"; then + echo "Removed suite $suite is named in the PR title/body or a commit message - acknowledged." + else + echo "::error title=Native suite vanished::test/$suite exists on the merge base but is gone from this PR, and nothing in the PR title, body, or commit messages mentions it. If the removal is deliberate, name $suite in the PR description or a commit message; if not, restore the directory - platformio test would silently run without it." + fail=1 + fi + done <<<"$removed" + exit $fail + + # Reject naive deadline comparisons against the 32-bit uptime clocks. `millis() > deadline` and + # `deadline < millis()` invert while the deadline sits on the far side of the 32-bit wrap: the + # action fires immediately, or blocks for about the interval it should have waited. The correct + # forms are + # Throttle::isWithinTimespanMs / hasElapsed (elapsed since a stored event) and + # Throttle::deadlinePassed (an absolute deadline). See .github/copilot-instructions.md. + millis-deadline-check: + # Name is load-bearing: upstream branch protection matches the check by name. Widen the guard, + # not this string. + name: Naive millis() Deadline Compare + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + persist-credentials: false + + - name: Reject 32-bit uptime clocks used directly in a deadline comparison shell: bash run: | set -euo pipefail - count_file="test/native-suite-count" - if [[ ! -f $count_file ]]; then - echo "::error title=Missing native-suite-count::$count_file not found - it must record the number of test_* suite directories." - exit 1 + allowlist=".github/millis-deadline-allowlist.txt" + + # Flag millis() or its Time::getMillis() wrapper directly adjacent to a comparison + # operator, in either order. The correct idioms subtract first, so they are not matched. + # + # Line comments are stripped before matching, so prose may name the broken idiom (this + # guard's own documentation does). Block comments are not stripped; keep `millis() >` out + # of /* */ blocks. mawk-compatible - ubuntu-latest has no gawk. + find src -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.hpp' -o -name '*.ino' \) \ + ! -path 'src/mesh/generated/*' -print0 | + xargs -0 awk ' + { + line = $0 + sub(/\/\/.*/, "", line) + if (line ~ /((millis|getMillis)\(\)[ \t]*[<>]=?)|([<>]=?[ \t]*(millis|getMillis)\(\))/) { + code = line + sub(/^[ \t]+/, "", code); sub(/[ \t]+$/, "", code) + printf "%s\t%s\t%s\n", FILENAME, FNR, code + } + }' > /tmp/millis-hits.tsv + + # Allowlisted entries are keyed on file + exact source text, deliberately without a line + # number, so unrelated edits above them do not invalidate the entry. + : > /tmp/millis-allowed.tsv + if [[ -f $allowlist ]]; then + grep -vE '^[[:space:]]*(#|$)' "$allowlist" > /tmp/millis-allowed.tsv || true fi - # Same canonical set as bin/run-tests.sh: directories named test_* directly under test/. - expected_count=$(find test -maxdepth 1 -type d -name 'test_*' -printf '%f\n' | wc -l) - canonical_count=$(tr -d '[:space:]' <"$count_file") - if ! [[ $canonical_count =~ ^[0-9]+$ ]]; then - echo "::error title=Invalid native-suite-count::$count_file must contain a single integer, got '$canonical_count'." - exit 1 - fi - echo "test/ directories: $expected_count" - echo "native-suite-count: $canonical_count" - if [[ $expected_count -ne $canonical_count ]]; then - if [[ $expected_count -gt $canonical_count ]]; then - hint="a suite was added - bump $count_file to $expected_count" - else - hint="a suite was removed - lower $count_file to $expected_count" + + violations=0 + while IFS=$'\t' read -r file line code; do + [[ -n ${file:-} ]] || continue + if grep -qxF "$(printf '%s\t%s' "$file" "$code")" /tmp/millis-allowed.tsv; then + continue fi - echo "::error title=native-suite-count mismatch::test/ has $expected_count suite directories but $count_file says $canonical_count ($hint)." + echo "$file:$line: $code" + violations=$((violations + 1)) + done < /tmp/millis-hits.tsv + + if [[ $violations -gt 0 ]]; then + echo "::error title=Naive uptime deadline compare::$violations line(s) compare a 32-bit uptime clock directly, which inverts while the deadline is on the far side of the 32-bit wrap - the action fires immediately, or blocks for about the interval it should have waited. Use Throttle::deadlinePassed(deadline) for a stored absolute deadline, or Throttle::hasElapsed(lastEvent, intervalMs) for an interval. If a match genuinely is not a deadline test (an uptime threshold, say), add it to $allowlist with a reason." exit 1 fi - echo "native-suite-count matches the $expected_count suite directories." + echo "No naive 32-bit uptime deadline comparisons in src/ (allowlist: $(wc -l < /tmp/millis-allowed.tsv) entr(y/ies))." simulator-tests: name: Native Simulator Tests runs-on: ubuntu-24.04-arm - needs: suite-count-check steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 with: @@ -169,7 +246,6 @@ jobs: platformio-tests: name: Native PlatformIO Tests runs-on: ubuntu-24.04-arm - needs: suite-count-check steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 with: @@ -329,13 +405,16 @@ jobs: lcov ${{ env.LCOV_CAPTURE_FLAGS }} --test-name tests --output-file coverage_tests.info sed -i -e "s#${PWD}#.#" coverage_tests.info # Make paths relative. + - name: Event channel policy tests + run: platformio test -e coverage-event-policy -v --junit-output-path event-policy-testreport.xml + - name: Save test results if: always() # run this step even if previous step failed uses: actions/upload-artifact@v7 with: name: platformio-test-report-${{ steps.version.outputs.long }} overwrite: true - path: ./testreport.xml + path: ./*testreport.xml - name: Save coverage information uses: actions/upload-artifact@v7 diff --git a/.github/workflows/update_protobufs.yml b/.github/workflows/update_protobufs.yml index 657d9171c1..c30f4587e4 100644 --- a/.github/workflows/update_protobufs.yml +++ b/.github/workflows/update_protobufs.yml @@ -1,12 +1,23 @@ name: Update protobufs and regenerate classes -on: workflow_dispatch +on: + workflow_dispatch: + inputs: + protobufs_branch: + description: Branch of meshtastic/protobufs to generate from + required: true + type: choice + default: same-as-this-branch + options: + - same-as-this-branch + - master + - develop permissions: read-all jobs: update-protobufs: runs-on: ubuntu-latest - permissions: # Needed for peter-evans/create-pull-request. + permissions: contents: write pull-requests: write steps: @@ -14,22 +25,50 @@ jobs: uses: actions/checkout@v7 with: submodules: true + persist-credentials: false + + - name: Resolve protobufs branch + id: resolve + env: + INPUT_BRANCH: ${{ inputs.protobufs_branch }} + TRIGGER_BRANCH: ${{ github.ref_name }} + run: | + set -euo pipefail + if [ "$INPUT_BRANCH" = "same-as-this-branch" ]; then + BRANCH="$TRIGGER_BRANCH" + else + BRANCH="$INPUT_BRANCH" + fi + case "$BRANCH" in + master | develop) ;; + *) + echo "::error::Refusing to generate from branch '$BRANCH'" + exit 1 + ;; + esac + echo "branch=$BRANCH" >>"$GITHUB_OUTPUT" - name: Update submodule - if: ${{ github.ref_name == 'master' || github.ref_name == 'develop' }} working-directory: protobufs env: - # Use the branch that triggered the workflow as the protobuf branch. - GIT_BRANCH: ${{ github.ref_name }} + GIT_BRANCH: ${{ steps.resolve.outputs.branch }} run: | - git fetch --prune origin $GIT_BRANCH - git checkout FETCH_HEAD + set -euo pipefail + git fetch --prune origin "+refs/heads/${GIT_BRANCH}:refs/remotes/origin/${GIT_BRANCH}" + git checkout --detach "refs/remotes/origin/${GIT_BRANCH}" + git rev-parse HEAD - name: Download nanopb + env: + NANOPB_VERSION: 0.4.9.1 + NANOPB_SHA256: 951a9ab2385424a4cdf245d0c84f4c88c6ccbc65a0dade4b246d50c068f24128 run: | - wget https://github.com/nanopb/nanopb/releases/download/nanopb-0.4.9.1/nanopb-0.4.9.1-linux-x86.tar.gz - tar xvzf nanopb-0.4.9.1-linux-x86.tar.gz - mv nanopb-0.4.9.1-linux-x86 nanopb-0.4.9 + set -euo pipefail + TARBALL="nanopb-${NANOPB_VERSION}-linux-x86.tar.gz" + wget -q "https://github.com/nanopb/nanopb/releases/download/nanopb-${NANOPB_VERSION}/${TARBALL}" + echo "${NANOPB_SHA256} ${TARBALL}" | sha256sum -c - + tar xzf "${TARBALL}" + mv "nanopb-${NANOPB_VERSION}-linux-x86" nanopb-0.4.9 - name: Re-generate protocol buffers run: | @@ -38,10 +77,12 @@ jobs: - name: Create pull request uses: peter-evans/create-pull-request@v8 with: - branch: create-pull-request/update-protobufs-${{ github.ref_name }} + token: ${{ secrets.GITHUB_TOKEN }} + branch: create-pull-request/update-protobufs-${{ github.ref_name }}-from-${{ steps.resolve.outputs.branch }} labels: submodules title: Update protobufs and classes commit-message: Update protobufs add-paths: | protobufs src/mesh + diff --git a/.trunk/trunk.yaml b/.trunk/trunk.yaml index 7b45c5f830..099a6a4919 100644 --- a/.trunk/trunk.yaml +++ b/.trunk/trunk.yaml @@ -151,6 +151,15 @@ lint: - linters: [ascii-dash] paths: - src/graphics/fonts/** + # millis()-wraparound tests pin dense clusters of hex boundary constants + # (0xFFFFFF00u and neighbors). trufflehog's Lob detector stitches nearby + # hex literals into one candidate string and the result happens to match + # a Lob API key shape. Not secrets - deterministic test fixtures for the + # 32-bit rollover. + - linters: [trufflehog] + paths: + - test/test_throttle/test_main.cpp + - test/test_uptime_clock/test_main.cpp runtimes: enabled: - python@3.14.4 diff --git a/AGENTS.md b/AGENTS.md index 9dc3fa22e6..5c67d124d2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -81,7 +81,18 @@ Key rotation to never trigger casually: only the **full** factory reset (`factor - **Never edit or commit files under `src/mesh/generated/`.** They are regenerated from the [`meshtastic/protobufs`](https://github.com/meshtastic/protobufs) repo by the `update_protobufs.yml` workflow (entry point: `bin/regen-protos.sh`). Local edits will be overwritten and create merge conflicts. If a `.proto` change is needed, open a PR against the protobufs repo first, then let the workflow re-sync this repo. - **`confirm=True` on destructive MCP tools is a real gate, not a formality.** Don't bypass it via auto-approve settings. - **Keep code comments minimal - one or two lines, max.** Comment only when the _why_ isn't obvious from the code; never restate what the next line does. No multi-paragraph block comments explaining straightforward changes. The diff and commit message carry the rationale; the code carries the behavior. -- **Use `Throttle` for time-based rate limiting, not raw `millis()` math.** `src/mesh/Throttle.h` provides `Throttle::isWithinTimespanMs(lastMs, intervalMs)` (returns true while inside the cooldown) and `Throttle::execute(&lastMs, intervalMs, func)` (function-pointer form that updates the timestamp on fire). Use these for any "did N ms pass since X" check - raw `millis() > lastMs + N` is rollover-unsafe (breaks after ~49.7 days) and inconsistent with the rest of the codebase. The helpers compute `now - lastMs` with unsigned subtraction, which wraps correctly. +- **Never compare against `millis()` directly. Use `Throttle`.** `src/mesh/Throttle.h` is the sanctioned way to ask about time, and CI enforces this (`millis-deadline-check` in `.github/workflows/test_native.yml` fails the PR on a new `millis() >` / `< millis()` comparison). + - `Throttle::isWithinTimespanMs(lastMs, intervalMs)` - true while still inside the cooldown. + - `Throttle::hasElapsed(lastMs, intervalMs)` - its complement, true once the interval has passed (inclusive `>=`). Prefer this to spelling `!isWithinTimespanMs(...)`. + - `Throttle::execute(&lastMs, intervalMs, func)` - function-pointer form that updates the timestamp on fire. + - `Throttle::deadlinePassed(deadlineMs)` - for a stored absolute deadline that cannot be re-expressed as "interval since an event". + - `Throttle::deadlinePassedAt(nowMs, deadlineMs)` - the same test against a caller-supplied `now`, for a loop that snapshots the clock once and tests many deadlines. Snapshot from `Time::getMillis()`. + + Raw `millis() > deadline` or `deadline < millis()` is rollover-unsafe: the comparison inverts while the deadline sits on the far side of the 32-bit wrap, so the action fires immediately or blocks for roughly the interval it should have waited. All five helpers subtract first, so unsigned wraparound cancels out. `Throttle` reads the clock through `Time::getMillis()` (`src/UptimeClock.h`), so all ~94 of its call sites are time-injectable and a native test can drive the wrap with `Time::setTestMillis()`. + + **Sentinel hazard.** If a deadline variable also encodes "inactive" (`0` for `rebootAtMsec`, `shutdownAtMsec`, `alertBannerUntil`, `fixHoldEnds`; `UINT32_MAX` for `nagCycleCutoff`), test that sentinel _before_ the elapsed comparison - every such value is arithmetically far in the past, so a correct comparison fires on it immediately. Match the test to the sentinel in use: `if (deadline && Throttle::deadlinePassed(deadline))` covers the `0` family, `nagCycleCutoff` needs `deadline != UINT32_MAX` or a separate armed flag (`isNagging`). + + Then decide which way the sentinel should fall - "inactive" does not always mean "suppress". At the GPS fix-hold site `fixHoldEnds == 0` means _no hold is in force_, which is exactly when one must be armed; guarding it with `fixHoldEnds != 0 &&` looks like this rule and inverts the site. See `fixHoldInForce()` in `src/gps/GPS.cpp` and `test/test_gps_fix_hold/`. ## Typical agent workflows @@ -131,7 +142,7 @@ Sequence these; don't parallelize on the same port. | `src/modules/` | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers | | `variants/` | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board) | | `protobufs/` | `.proto` definitions; regenerate with `bin/regen-protos.sh` | -| `test/` | Firmware unit tests (count: `test/native-suite-count`; `./bin/run-tests.sh` preferred, falls back to `pio test -e native`) | +| `test/` | Firmware unit tests (count = the `test_*` dirs, detected on the fly; `./bin/run-tests.sh` preferred, falls back to `pio test -e native`) | | [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) | Standalone MCP server + tiered pytest hardware harness (`unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/`) - registered here via `.mcp.json` | | `.github/prompts/` | Copilot prompt bodies (firmware scaffolding: new module / sensor / variant) | | `.github/copilot-instructions.md` | **Primary agent instructions - read this** | diff --git a/CLAUDE.md b/CLAUDE.md index c7150cd2d0..325fb7100e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -11,12 +11,13 @@ > > **Need this? It's here.** > -> | | | -> | ------------------------------------------- | ---------------------------------------------------------- | -> | General helpers (clamp, UTF-8, string fmt…) | `src/meshUtils.h` | -> | Logging macros (LOG_DEBUG / INFO / WARN…) | `src/DebugConfiguration.h` | -> | New module skeleton | inherit `ProtobufModule` in `src/mesh/ProtobufModule.h` | -> | Observer / event wiring | `src/Observer.h` | +> | | | +> | --------------------------------------------------------- | ---------------------------------------------------------- | +> | General helpers (clamp, UTF-8, string fmt…) | `src/meshUtils.h` | +> | Logging macros (LOG_DEBUG / INFO / WARN…) | `src/DebugConfiguration.h` | +> | Elapsed time / deadlines (never bare `millis()` compares) | `src/mesh/Throttle.h` | +> | New module skeleton | inherit `ProtobufModule` in `src/mesh/ProtobufModule.h` | +> | Observer / event wiring | `src/Observer.h` | **Read `.github/copilot-instructions.md` first.** That file is the canonical agent-facing document for this repo. It covers project layout, coding conventions, the build system, CI/CD, the native C++ test suite, and the MCP Server & Hardware Test Harness. Read it top-to-bottom before starting any non-trivial change. diff --git a/bin/device-install.bat b/bin/device-install.bat index 69469d5810..a4e5953119 100755 --- a/bin/device-install.bat +++ b/bin/device-install.bat @@ -70,7 +70,7 @@ IF "__!FILENAME!__"=="____" ( CALL :LOG_MESSAGE ERROR "Filename containing spaces are not supported." GOTO help ) - IF NOT "__!FILENAME:.factory.bin=!__"=="__!FILENAME!__" ( + IF /I NOT "!FILENAME:~-12!"==".factory.bin" ( CALL :LOG_MESSAGE ERROR "Filename must be a firmware-*.factory.bin file." GOTO help ) @@ -111,7 +111,7 @@ IF EXIST !METAFILE! ( CALL :LOG_MESSAGE DEBUG "Determine the correct esptool command to use..." IF NOT "__%PYTHON%__"=="____" ( - SET "ESPTOOL_CMD=!PYTHON! -m esptool" + SET "ESPTOOL_CMD="!PYTHON!" -m esptool" CALL :LOG_MESSAGE DEBUG "Python interpreter supplied." ) ELSE ( CALL :LOG_MESSAGE DEBUG "Python interpreter NOT supplied. Looking for esptool..." @@ -126,12 +126,31 @@ IF NOT "__%PYTHON%__"=="____" ( ) CALL :LOG_MESSAGE DEBUG "Checking esptool command !ESPTOOL_CMD!..." -!ESPTOOL_CMD! >nul 2>&1 -IF %ERRORLEVEL% EQU 9009 ( - @REM 9009 = command not found on Windows +@REM %VAR% not !VAR!: cmd will not split a delayed-expanded command token that +@REM carries a path, so the "python -m esptool" form never starts. +%ESPTOOL_CMD% >nul 2>&1 +SET "ESPTOOL_EXIT=!ERRORLEVEL!" +@REM 9009 = command not found, 3 = bad path from -P. Both mean unusable. +IF !ESPTOOL_EXIT! EQU 3 SET "ESPTOOL_EXIT=9009" +IF !ESPTOOL_EXIT! EQU 9009 ( CALL :LOG_MESSAGE ERROR "esptool not found: !ESPTOOL_CMD!" EXIT /B 1 ) + +@REM esptool v5 renamed subcommands to dashes; older versions only take underscores. +@REM Probe here: the --debug and --port rewrites below leave ESPTOOL_CMD unusable. +SET "ESPTOOL_WRITE_FLASH=write_flash" +SET "ESPTOOL_ERASE_FLASH=erase_flash" +SET "ESPTOOL_READ_FLASH_STATUS=read_flash_status" +%ESPTOOL_CMD% 2>&1 | findstr /C:"write-flash" >nul +IF !ERRORLEVEL! EQU 0 ( + SET "ESPTOOL_WRITE_FLASH=write-flash" + SET "ESPTOOL_ERASE_FLASH=erase-flash" + SET "ESPTOOL_READ_FLASH_STATUS=read-flash-status" +) +CALL :RESET_ERROR +CALL :LOG_MESSAGE DEBUG "Using esptool write command: !ESPTOOL_WRITE_FLASH!" + IF %DEBUG% EQU 1 ( CALL :LOG_MESSAGE DEBUG "Skipping ESPTOOL_CMD steps." SET "ESPTOOL_CMD=REM !ESPTOOL_CMD!" @@ -148,7 +167,7 @@ CALL :LOG_MESSAGE INFO "Using esptool baud: !ESPTOOL_BAUD!." IF %BPS_RESET% EQU 1 ( @REM Attempt to change mode via 1200bps Reset. - CALL :RUN_ESPTOOL 1200 --after no_reset read_flash_status + CALL :RUN_ESPTOOL 1200 --after no_reset !ESPTOOL_READ_FLASH_STATUS! GOTO eof ) @@ -174,14 +193,14 @@ IF NOT EXIST !SPIFFS_FILENAME! CALL :LOG_MESSAGE ERROR "File does not exist: "!S @REM Flashing operations. CALL :LOG_MESSAGE INFO "Trying to flash "!FILENAME!", but first erasing and writing system information..." -CALL :RUN_ESPTOOL !ESPTOOL_BAUD! erase_flash || GOTO eof -CALL :RUN_ESPTOOL !ESPTOOL_BAUD! write_flash 0x00 "!FILENAME!" || GOTO eof +CALL :RUN_ESPTOOL !ESPTOOL_BAUD! !ESPTOOL_ERASE_FLASH! || GOTO eof +CALL :RUN_ESPTOOL !ESPTOOL_BAUD! !ESPTOOL_WRITE_FLASH! 0x00 "!FILENAME!" || GOTO eof CALL :LOG_MESSAGE INFO "Trying to flash BLEOTA "!OTA_FILENAME!" at OTA_OFFSET !OTA_OFFSET!..." -CALL :RUN_ESPTOOL !ESPTOOL_BAUD! write_flash !OTA_OFFSET! "!OTA_FILENAME!" || GOTO eof +CALL :RUN_ESPTOOL !ESPTOOL_BAUD! !ESPTOOL_WRITE_FLASH! !OTA_OFFSET! "!OTA_FILENAME!" || GOTO eof CALL :LOG_MESSAGE INFO "Trying to flash SPIFFS "!SPIFFS_FILENAME!" at SPIFFS_OFFSET !SPIFFS_OFFSET!..." -CALL :RUN_ESPTOOL !ESPTOOL_BAUD! write_flash !SPIFFS_OFFSET! "!SPIFFS_FILENAME!" || GOTO eof +CALL :RUN_ESPTOOL !ESPTOOL_BAUD! !ESPTOOL_WRITE_FLASH! !SPIFFS_OFFSET! "!SPIFFS_FILENAME!" || GOTO eof CALL :LOG_MESSAGE INFO "Script complete!." @@ -198,7 +217,7 @@ EXIT /B %ERRORLEVEL% @REM Example:: CALL :RUN_ESPTOOL 115200 write_flash 0x10000 "firmwarefile.bin" IF %DEBUG% EQU 1 CALL :LOG_MESSAGE DEBUG "About to run command: !ESPTOOL_CMD! --baud %~1 %~2 %~3 %~4" CALL :RESET_ERROR -!ESPTOOL_CMD! --baud %~1 %~2 %~3 %~4 +%ESPTOOL_CMD% --baud %~1 %~2 %~3 %~4 IF %BPS_RESET% EQU 1 GOTO :eof IF %ERRORLEVEL% NEQ 0 ( CALL :LOG_MESSAGE ERROR "Error running command: !ESPTOOL_CMD! --baud %~1 %~2 %~3 %~4" diff --git a/bin/device-update.bat b/bin/device-update.bat index a9f7a9e1ea..e76ae946a8 100755 --- a/bin/device-update.bat +++ b/bin/device-update.bat @@ -90,7 +90,7 @@ IF NOT "__!FILENAME:.factory.bin=!__"=="__!FILENAME!__" ( CALL :LOG_MESSAGE DEBUG "Determine the correct esptool command to use..." IF NOT "__%PYTHON%__"=="____" ( - SET "ESPTOOL_CMD=""!PYTHON!"" -m esptool" + SET "ESPTOOL_CMD="!PYTHON!" -m esptool" CALL :LOG_MESSAGE DEBUG "Python interpreter supplied." ) ELSE ( CALL :LOG_MESSAGE DEBUG "Python interpreter NOT supplied. Looking for esptool..." @@ -105,13 +105,32 @@ IF NOT "__%PYTHON%__"=="____" ( ) CALL :LOG_MESSAGE DEBUG "Checking esptool command !ESPTOOL_CMD!..." -!ESPTOOL_CMD! >nul 2>&1 -CALL :LOG_MESSAGE DEBUG "esptool exit code: %ERRORLEVEL%" -IF %ERRORLEVEL% EQU 9009 ( - @REM 9009 = command not found on Windows +@REM %VAR% not !VAR!: cmd will not split a delayed-expanded command token that +@REM carries a path, so the "python -m esptool" form never starts. +%ESPTOOL_CMD% >nul 2>&1 +SET "ESPTOOL_EXIT=!ERRORLEVEL!" +CALL :LOG_MESSAGE DEBUG "esptool exit code: !ESPTOOL_EXIT!" +@REM 9009 = command not found, 3 = bad path from -P. Both mean unusable. +IF !ESPTOOL_EXIT! EQU 3 SET "ESPTOOL_EXIT=9009" +IF !ESPTOOL_EXIT! EQU 9009 ( CALL :LOG_MESSAGE ERROR "esptool not found: !ESPTOOL_CMD!" EXIT /B 1 ) + +@REM esptool v5 renamed subcommands to dashes; older versions only take underscores. +@REM Probe here: the --debug and --port rewrites below leave ESPTOOL_CMD unusable. +SET "ESPTOOL_WRITE_FLASH=write_flash" +SET "ESPTOOL_ERASE_FLASH=erase_flash" +SET "ESPTOOL_READ_FLASH_STATUS=read_flash_status" +%ESPTOOL_CMD% 2>&1 | findstr /C:"write-flash" >nul +IF !ERRORLEVEL! EQU 0 ( + SET "ESPTOOL_WRITE_FLASH=write-flash" + SET "ESPTOOL_ERASE_FLASH=erase-flash" + SET "ESPTOOL_READ_FLASH_STATUS=read-flash-status" +) +CALL :RESET_ERROR +CALL :LOG_MESSAGE DEBUG "Using esptool write command: !ESPTOOL_WRITE_FLASH!" + IF %DEBUG% EQU 1 ( CALL :LOG_MESSAGE DEBUG "Skipping ESPTOOL_CMD steps." SET "ESPTOOL_CMD=REM !ESPTOOL_CMD!" @@ -128,13 +147,13 @@ CALL :LOG_MESSAGE INFO "Using esptool baud: !ESPTOOL_BAUD!." IF %CHANGE_MODE% EQU 1 ( @REM Attempt to change mode via 1200bps Reset. - CALL :RUN_ESPTOOL !RESET_BAUD! --after no_reset read_flash_status + CALL :RUN_ESPTOOL !RESET_BAUD! --after no_reset !ESPTOOL_READ_FLASH_STATUS! GOTO eof ) @REM Flashing operations. CALL :LOG_MESSAGE INFO "Trying to flash update "!FILENAME!" at OFFSET !UPDATE_OFFSET!..." -CALL :RUN_ESPTOOL !ESPTOOL_BAUD! write-flash !UPDATE_OFFSET! "!FILENAME!" || GOTO eof +CALL :RUN_ESPTOOL !ESPTOOL_BAUD! !ESPTOOL_WRITE_FLASH! !UPDATE_OFFSET! "!FILENAME!" || GOTO eof CALL :LOG_MESSAGE INFO "Script complete!." @@ -151,7 +170,7 @@ EXIT /B %ERRORLEVEL% @REM Example:: CALL :RUN_ESPTOOL 115200 write-flash 0x10000 "firmwarefile.bin" IF %DEBUG% EQU 1 CALL :LOG_MESSAGE DEBUG "About to run command: !ESPTOOL_CMD! --baud %~1 %~2 %~3 %~4" CALL :RESET_ERROR -!ESPTOOL_CMD! --baud %~1 %~2 %~3 %~4 +%ESPTOOL_CMD% --baud %~1 %~2 %~3 %~4 IF %CHANGE_MODE% EQU 1 GOTO :eof IF %ERRORLEVEL% NEQ 0 ( CALL :LOG_MESSAGE ERROR "Error running command: !ESPTOOL_CMD! --baud %~1 %~2 %~3 %~4" diff --git a/bin/run-tests.sh b/bin/run-tests.sh index 1c5109282b..dcc3a705f4 100755 --- a/bin/run-tests.sh +++ b/bin/run-tests.sh @@ -163,20 +163,11 @@ export MESHTASTIC_TEST_STATE_SUMMARY="$STATE_SUMMARY" $KEEP_STATE && export MESHTASTIC_TEST_KEEP_STATE=1 $WRITE_MANIFEST && export MESHTASTIC_TEST_KEEP_STATE=1 -# Canonical suite set = the directories in test/. This is the source of truth for -# "what should run"; a filtered run only expects its filtered suite. +# Canonical suite set = the directories in test/, detected on the fly. This is the sole source +# of truth for "what should run"; a filtered run only expects its filtered suite. mapfile -t ALL_SUITES < <(find test -maxdepth 1 -type d -name 'test_*' -printf '%f\n' | sort) EXPECTED_COUNT=${#ALL_SUITES[@]} -# Canonical suite count - the registered total, maintained in test/native-suite-count. -# Update that file whenever a test suite is added or removed. -CANONICAL_COUNT_FILE="test/native-suite-count" -if [[ -f $CANONICAL_COUNT_FILE ]]; then - CANONICAL_COUNT=$(tr -d '[:space:]' <"$CANONICAL_COUNT_FILE") -else - CANONICAL_COUNT="" -fi - # Cached object-count for this env, written after each completed build (in the gitignored build # dir). Used as the progress denominator: accurate for a full rebuild (every object recompiles), # only a rough upper bound for an incremental run. @@ -462,31 +453,15 @@ if ! grep -qE "$PASS_RE" "$LOG"; then exit 1 fi -# Canonical-count rating suffix - appended to every verdict line so the result is always -# rated against the registered total, not just the directory count. -# If the two counts diverge (suite added/removed without updating native-suite-count), that -# is itself surfaced as AMBER before we reach any verdict. -canonical_rating() { +# Verdict-line suffix. The suite count itself is derived from the test_* directories on the fly +# (EXPECTED_COUNT above), so the only extra context a verdict needs is the shuffle seed - carried +# into the machine-readable line so a verdict is always replayable from it alone. +verdict_suffix() { local rating="" - if [[ -n $CANONICAL_COUNT ]]; then - rating="[canonical: ${RAN_COUNT}/${CANONICAL_COUNT}]" - fi - # Carry the seed into the machine-readable line so a verdict is always replayable from it alone. - $SHUFFLE && rating="$rating [seed: $SEED]" + $SHUFFLE && rating="[seed: $SEED]" echo "$rating" } -# AMBER: directory count disagrees with native-suite-count - file needs updating. -if [[ -n $CANONICAL_COUNT && $EXPECTED_COUNT -ne $CANONICAL_COUNT ]]; then - echo "" - if [[ $EXPECTED_COUNT -gt $CANONICAL_COUNT ]]; then - echo "RESULT: AMBER test/ has $EXPECTED_COUNT suite directories but native-suite-count says $CANONICAL_COUNT - update test/native-suite-count after registering new suites" - else - echo "RESULT: AMBER test/ has $EXPECTED_COUNT suite directories but native-suite-count says $CANONICAL_COUNT - update test/native-suite-count after removing suites" - fi - exit 2 -fi - # --- Shared-state axis -------------------------------------------------------- # Read what the per-suite wrapper recorded. Reported after the count checks so a structural problem # still wins, and before the pass/fail verdict lines so the state summary always prints. @@ -546,7 +521,7 @@ if [[ $IGNORED_COUNT -gt 0 ]]; then echo "" echo "$IGNORE_DETAIL" echo "" - echo "RESULT: AMBER ${IGNORED_COUNT} test case(s) ignored $(canonical_rating)" + echo "RESULT: AMBER ${IGNORED_COUNT} test case(s) ignored $(verdict_suffix)" exit 2 fi @@ -558,7 +533,7 @@ if [[ -z $FILTER && $ACCOUNTED_COUNT -lt $EXPECTED_COUNT ]]; then printf '%s\n' "${RAN_SUITES[@]}" "${SKIPPED_SUITES[@]}" | grep -qx "$s" || missing+=("$s") done echo "" - echo "RESULT: AMBER ${RAN_COUNT}/${EXPECTED_COUNT} suites ran (missing: ${missing[*]}) - all that ran passed $(canonical_rating)" + echo "RESULT: AMBER ${RAN_COUNT}/${EXPECTED_COUNT} suites ran (missing: ${missing[*]}) - all that ran passed $(verdict_suffix)" exit 2 fi @@ -572,7 +547,7 @@ if ((${#DIRTY_SUITES[@]} > 0)); then echo "" echo " -> declare these in test/state-manifest.tsv with a reason, or stop the write." echo " -> ./bin/run-tests.sh --write-manifest prints the entries to paste." - echo "RESULT: AMBER ${#DIRTY_SUITES[@]} suite(s) left undeclared shared state $(canonical_rating)" + echo "RESULT: AMBER ${#DIRTY_SUITES[@]} suite(s) left undeclared shared state $(verdict_suffix)" exit 2 fi @@ -588,7 +563,7 @@ if ((${#SURVIVOR_SUITES[@]} > 0)); then echo "" echo " -> end every setup() branch with exit(UNITY_END()), not a bare UNITY_END()." echo " -> ./bin/lint-unity-exit.sh test/**/*.cpp finds the sites; see test/README.md." - echo "RESULT: AMBER ${#SURVIVOR_SUITES[@]} suite(s) still running after the suite finished $(canonical_rating)" + echo "RESULT: AMBER ${#SURVIVOR_SUITES[@]} suite(s) still running after the suite finished $(verdict_suffix)" exit 2 fi @@ -599,10 +574,10 @@ if [[ -n $FILTER ]]; then for s in "${ALL_SUITES[@]}"; do printf '%s\n' "${RAN_SUITES[@]}" "${SKIPPED_SUITES[@]}" | grep -qx "$s" || not_run+=("$s") done - echo "RESULT: FILTERED ${RAN_COUNT}/${EXPECTED_COUNT} suites ran (not run: ${not_run[*]}) - filtered: $FILTER $(canonical_rating)" + echo "RESULT: FILTERED ${RAN_COUNT}/${EXPECTED_COUNT} suites ran (not run: ${not_run[*]}) - filtered: $FILTER $(verdict_suffix)" exit 3 fi # GREEN: all canonical suites ran, all passed, no ignored test cases, nothing undeclared left behind. -echo "RESULT: GREEN ${RAN_COUNT}/${EXPECTED_COUNT} suites passed, all CLEAN $(canonical_rating)" +echo "RESULT: GREEN ${RAN_COUNT}/${EXPECTED_COUNT} suites passed, all CLEAN $(verdict_suffix)" exit 0 diff --git a/bin/test-lint-unity-exit.sh b/bin/test-lint-unity-exit.sh index 7c1dac30d7..b88f7d2df1 100755 --- a/bin/test-lint-unity-exit.sh +++ b/bin/test-lint-unity-exit.sh @@ -12,8 +12,9 @@ # anything" is what catches a rule that reports the right number of findings in the wrong places, or # that collapses two findings on one line into one. # -# Not a Unity suite and not counted in test/native-suite-count - same arrangement as -# bin/test-state-check.sh, and for the same reason: it asserts the behaviour of a process. +# Not a Unity suite and not a test_* directory, so outside the suite count run-tests.sh derives +# from test/ - same arrangement as bin/test-state-check.sh, and for the same reason: it asserts +# the behaviour of a process. # # Usage: ./bin/test-lint-unity-exit.sh (exit 0 = all fixtures behaved) diff --git a/bin/test-state-check.sh b/bin/test-state-check.sh index 96fa8803d0..14dad9d447 100755 --- a/bin/test-state-check.sh +++ b/bin/test-state-check.sh @@ -8,9 +8,9 @@ # before-empty assertion fires, because an after-diff measured against a dirty baseline reports # green while meaning nothing. # -# Not a Unity suite and not counted in test/native-suite-count - the same arrangement as -# bin/test-config-check.sh, and for the same reason: what it asserts is the behaviour of a process, -# not of a linkable function. +# Not a Unity suite and not a test_* directory, so outside the suite count run-tests.sh derives +# from test/ - the same arrangement as bin/test-config-check.sh, and for the same reason: what it +# asserts is the behaviour of a process, not of a linkable function. # # Usage: ./bin/test-state-check.sh (exit 0 = all fixtures behaved) diff --git a/extra_scripts/nrf52_lto.py b/extra_scripts/nrf52_lto.py index 22b236f58d..f62194a053 100644 --- a/extra_scripts/nrf52_lto.py +++ b/extra_scripts/nrf52_lto.py @@ -233,9 +233,26 @@ def _assert_isr_handlers_survived(source, target, env): # and the build stays green. Turn that into a red build: # 1. the linked variant.cpp.o must not be an LTO object (proves the -fno-lto recompile fired); # 2. any override the object defines strong must resolve strong in the ELF. +# +# The list must also cover Meshtastic's OWN weak variant hooks, not just the core's. Those have +# a second, independent way to vanish: their weak default AND their call site sit in the same +# LTO'd translation unit (src/main.cpp, src/platform/nrf52/main-nrf52.cpp), so GCC inlines the +# empty body at the call site and never reaches for the variant's strong override -- the +# -fno-lto middleware above cannot help, the caller is the problem. The definitions carry +# __attribute__((noinline)) to prevent it; this guard is what catches a future one that forgets. +# Regression that motivated the extension: 2.8 dropped earlyInitVariant() on the muzi R1 Neo, so +# DCDC_EN_HOLD/NRF_ON were never driven and the IO controller read the nRF as stuck in DFU +# (purple LED). The build stayed green because only _Z11initVariantv was listed here. _VARIANT_OVERRIDES = ( - "_Z11initVariantv", -) # extend if the core grows more weak variant hooks + "_Z11initVariantv", # core hook (cores/nRF5/main.cpp) + "_Z16earlyInitVariantv", # src/main.cpp -- pre-peripheral board bring-up + "_Z15lateInitVariantv", # src/main.cpp -- post-radio board bring-up + "_Z16variant_shutdownv", # main-nrf52.cpp -- pin parking before System OFF + "_Z21variant_nrf52LoopHookv", # main-nrf52.cpp -- per-loop variant hook + "_Z31variant_enableBatteryLpcompWakev", # main-nrf52.cpp -- LPCOMP wake opt-out + "_Z20variantDefaultConfigv", # NodeDB.cpp -- per-board config defaults + "_Z26variantDefaultModuleConfigv", # NodeDB.cpp -- per-board module defaults +) # extend if the core (or Meshtastic) grows more weak variant hooks def _assert_variant_survived(source, target, env): @@ -289,15 +306,19 @@ def _assert_variant_survived(source, target, env): ): problems.append( "%s is strong in variant.cpp.o but weak/absent in the ELF " - "(LTO resolved the core's call to the empty weak stub)" % sym + "(LTO resolved the call to the empty weak stub)" % sym ) if problems: sys.stderr.write( - "\n*** nrf52 LTO guard: board variant DROPPED from the image ***\n%s\n" - "The variant's early hardware setup (initVariant) will never run on this board.\n" - "Check _is_board_variant() in extra_scripts/nrf52_lto.py -- middleware nodes are\n" - "$BUILD_DIR-mirrored; match srcnode() paths, not node.get_abspath().\n\n" - % "\n".join(" - " + p for p in problems) + "\n*** nrf52 LTO guard: board variant override DROPPED from the image ***\n%s\n" + "That board hardware setup silently will not run. Two possible causes:\n" + " 1. The weak default and its CALL SITE share one LTO'd translation unit\n" + " (src/main.cpp, src/platform/nrf52/main-nrf52.cpp, src/mesh/NodeDB.cpp), so GCC\n" + " inlined the empty body and never reached the override. Fix: mark BOTH the weak\n" + " declaration and definition __attribute__((noinline)) -- see earlyInitVariant().\n" + " 2. The -fno-lto middleware stopped matching the variant. Check _is_board_variant()\n" + " below -- middleware nodes are $BUILD_DIR-mirrored, so match srcnode() paths,\n" + " not node.get_abspath().\n\n" % "\n".join(" - " + p for p in problems) ) from SCons.Script import Exit diff --git a/platformio.ini b/platformio.ini index 77955632f3..a5ce89383a 100644 --- a/platformio.ini +++ b/platformio.ini @@ -137,7 +137,7 @@ lib_deps = [device-ui_base] lib_deps = # renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master - https://github.com/meshtastic/device-ui/archive/d1edf7144e902367e57aa7adbfaf2fa12b4d2034.zip + https://github.com/meshtastic/device-ui/archive/6a52e33ad81e9b1d060a6db52b36c9535c742b45.zip custom_sdkconfig = # CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC is not set CONFIG_MBEDTLS_EXTERNAL_MEM_ALLOC=y @@ -247,8 +247,18 @@ lib_deps = closedcube/ClosedCube OPT3001@1.1.2 # renovate: datasource=git-refs depName=meshtastic-DFRobot_LarkWeatherStation packageName=https://github.com/meshtastic/DFRobot_LarkWeatherStation gitBranch=master https://github.com/meshtastic/DFRobot_LarkWeatherStation/archive/4de3a9cadef0f6a5220a8a906cf9775b02b0040d.zip + # renovate: datasource=github-tags depName=Sensirion Core packageName=sensirion/arduino-core + https://github.com/Sensirion/arduino-core/archive/refs/tags/0.7.3.zip + # renovate: datasource=github-tags depName=Sensirion I2C SCD4x packageName=sensirion/arduino-i2c-scd4x + https://github.com/Sensirion/arduino-i2c-scd4x/archive/refs/tags/1.1.0.zip + # renovate: datasource=github-tags depName=Sensirion I2C SFA3x packageName=sensirion/arduino-i2c-sfa3x + https://github.com/Sensirion/arduino-i2c-sfa3x/archive/refs/tags/1.0.0.zip + # renovate: datasource=github-tags depName=Sensirion I2C SCD30 packageName=sensirion/arduino-i2c-scd30 + https://github.com/Sensirion/arduino-i2c-scd30/archive/1.1.1.zip + # renovate: datasource=github-tags depName=arduino-sht packageName=sensirion/arduino-sht + https://github.com/Sensirion/arduino-sht/archive/refs/tags/v1.2.6.zip # renovate: datasource=github-tags depName=Adafruit DS248x packageName=adafruit/Adafruit_DS248x - https://github.com/adafruit/Adafruit_DS248x/archive/refs/tags/1.2.0.zip + https://github.com/adafruit/Adafruit_DS248x/archive/refs/tags/1.2.0.zip ; Environmental sensors with BSEC2 (Bosch proprietary IAQ) [environmental_extra] diff --git a/protobufs b/protobufs index cd290ba246..84bfb0fdb3 160000 --- a/protobufs +++ b/protobufs @@ -1 +1 @@ -Subproject commit cd290ba246fb5130cb449055248f7e22c15bcafb +Subproject commit 84bfb0fdb3b853ea18abc4535497fa41a1b09546 diff --git a/src/AmbientLightingThread.h b/src/AmbientLightingThread.h index d52b10a53f..873e25e66b 100644 --- a/src/AmbientLightingThread.h +++ b/src/AmbientLightingThread.h @@ -66,7 +66,7 @@ class AmbientLightingThread : public concurrency::OSThread #if defined(HAS_NCP5623) || defined(HAS_LP5562) _type = type; if (_type == ScanI2C::DeviceType::NONE) { - LOG_DEBUG("AmbientLighting Disable due to no RGB leds found on I2C bus"); + LOG_DEBUG("AmbientLighting disabled: no RGB leds on I2C"); disable(); return; } @@ -92,7 +92,7 @@ class AmbientLightingThread : public concurrency::OSThread pixels.setBrightness(moduleConfig.ambient_lighting.current); #endif if (!moduleConfig.ambient_lighting.led_state) { - LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF"); + LOG_DEBUG("AmbientLighting disabled: led_state OFF"); disable(); return; } diff --git a/src/DebugConfiguration.h b/src/DebugConfiguration.h index 65b258fc1b..247776a897 100644 --- a/src/DebugConfiguration.h +++ b/src/DebugConfiguration.h @@ -48,6 +48,16 @@ extern MemGet memGet; #define DEBUG_PORT (*console) // Serial debug port +// LOG_TRACE costs no flash unless enabled: -DMESHTASTIC_TRACE_LOGGING(=1) turns it on, =0 forces it off. +// Default is on only for portduino (traceFilename packet traces, logoutputlevel=trace), off elsewhere. +#ifndef MESHTASTIC_TRACE_LOGGING +#ifdef ARCH_PORTDUINO +#define MESHTASTIC_TRACE_LOGGING 1 +#else +#define MESHTASTIC_TRACE_LOGGING 0 +#endif +#endif + #ifdef USE_SEGGER // #undef DEBUG_PORT #define LOG_DEBUG(...) SEGGER_RTT_printf(0, __VA_ARGS__) @@ -55,16 +65,24 @@ extern MemGet memGet; #define LOG_WARN(...) SEGGER_RTT_printf(0, __VA_ARGS__) #define LOG_ERROR(...) SEGGER_RTT_printf(0, __VA_ARGS__) #define LOG_CRIT(...) SEGGER_RTT_printf(0, __VA_ARGS__) +#if MESHTASTIC_TRACE_LOGGING #define LOG_TRACE(...) SEGGER_RTT_printf(0, __VA_ARGS__) #else +#define LOG_TRACE(...) +#endif +#else #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE) #define LOG_DEBUG(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_DEBUG, __VA_ARGS__) #define LOG_INFO(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_INFO, __VA_ARGS__) #define LOG_WARN(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_WARN, __VA_ARGS__) #define LOG_ERROR(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_ERROR, __VA_ARGS__) #define LOG_CRIT(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_CRIT, __VA_ARGS__) +#if MESHTASTIC_TRACE_LOGGING #define LOG_TRACE(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_TRACE, __VA_ARGS__) #else +#define LOG_TRACE(...) +#endif +#else #define LOG_DEBUG(...) #define LOG_INFO(...) #define LOG_WARN(...) diff --git a/src/FSCommon.cpp b/src/FSCommon.cpp index 38b704e738..c00b07684b 100644 --- a/src/FSCommon.cpp +++ b/src/FSCommon.cpp @@ -340,7 +340,7 @@ void listDir(const char *dirname, uint8_t levels, bool del) file.close(); FSCom.remove(buffer); } else { - LOG_DEBUG(" %s (%i Bytes)", filepath, file.size()); + LOG_TRACE(" %s (%i Bytes)", filepath, file.size()); file.close(); } } @@ -394,7 +394,7 @@ void fsInit() #if defined(ARCH_ESP32) LOG_DEBUG("Filesystem files (%d/%d Bytes):", FSCom.usedBytes(), FSCom.totalBytes()); #else - LOG_DEBUG("Filesystem files:"); + LOG_TRACE("Filesystem files:"); #endif listDir("/", 10); #endif diff --git a/src/GPSStatus.h b/src/GPSStatus.h index 25c7b10394..e9f7325c87 100644 --- a/src/GPSStatus.h +++ b/src/GPSStatus.h @@ -2,6 +2,7 @@ #include "NodeDB.h" #include "Status.h" #include "configuration.h" +#include "gps/GPSLog.h" #include namespace meshtastic @@ -17,6 +18,7 @@ class GPSStatus : public Status bool hasLock = false; // default to false, until we complete our first read bool isConnected = false; // Do we have a GPS we are talking to + bool hasTime = false; // GPS has decoded a valid time this acquisition, even without a position fix bool isPowerSaving = false; // Are we in power saving state @@ -29,11 +31,12 @@ class GPSStatus : public Status GPSStatus() { statusType = STATUS_TYPE_GPS; } // preferred method - GPSStatus(bool hasLock, bool isConnected, bool isPowerSaving, const meshtastic_Position &pos) : Status() + GPSStatus(bool hasLock, bool isConnected, bool isPowerSaving, const meshtastic_Position &pos, bool hasTime = false) : Status() { this->hasLock = hasLock; this->isConnected = isConnected; this->isPowerSaving = isPowerSaving; + this->hasTime = hasTime; // all-in-one struct copy this->p = pos; @@ -50,6 +53,8 @@ class GPSStatus : public Status bool getIsPowerSaving() const { return isPowerSaving; } + bool getHasTime() const { return hasTime; } + int32_t getLatitude() const { if (config.position.fixed_position) { @@ -88,10 +93,8 @@ class GPSStatus : public Status bool matches(const GPSStatus *newStatus) const { -#ifdef GPS_DEBUG - LOG_DEBUG("GPSStatus.match() new pos@%x to old pos@%x", newStatus->p.timestamp, p.timestamp); -#endif - return (newStatus->hasLock != hasLock || newStatus->isConnected != isConnected || + LOG_DEBUG_GPS("GPSStatus.match() new pos@%x to old pos@%x", newStatus->p.timestamp, p.timestamp); + return (newStatus->hasLock != hasLock || newStatus->isConnected != isConnected || newStatus->hasTime != hasTime || newStatus->isPowerSaving != isPowerSaving || newStatus->p.latitude_i != p.latitude_i || newStatus->p.longitude_i != p.longitude_i || newStatus->p.altitude != p.altitude || newStatus->p.altitude_hae != p.altitude_hae || newStatus->p.PDOP != p.PDOP || @@ -112,6 +115,7 @@ class GPSStatus : public Status initialized = true; hasLock = newStatus->hasLock; isConnected = newStatus->isConnected; + hasTime = newStatus->hasTime; p = newStatus->p; diff --git a/src/Power.cpp b/src/Power.cpp index 28c8a7d5af..aa752cf633 100644 --- a/src/Power.cpp +++ b/src/Power.cpp @@ -171,7 +171,7 @@ static bool initAdcCalibration() } #endif - LOG_INFO("ADC calibration not supported; using approximate scaling"); + LOG_INFO("ADC calibration unsupported; use approx scaling"); return false; } @@ -606,7 +606,7 @@ class AnalogBatteryLevel : public HasBatteryLevel // get current flow from INA sensor - negative value means power flowing // into the battery default assuming BATTERY+ <--> INA_VIN+ <--> SHUNT // RESISTOR <--> INA_VIN- <--> LOAD - LOG_DEBUG("Using INA on I2C addr 0x%x for charging detection", config.power.device_battery_ina_address); + LOG_TRACE("Using INA on I2C addr 0x%x for charging detection", config.power.device_battery_ina_address); #if defined(INA_CHARGING_DETECTION_INVERT) return getINACurrent() > 0; #else @@ -837,12 +837,13 @@ bool Power::setup() void Power::powerCommandsCheck() { - if (rebootAtMsec && millis() > rebootAtMsec) { + // 0 means "not scheduled" for both, and reads as long expired - test it first. + if (rebootAtMsec && Throttle::deadlinePassed(rebootAtMsec)) { LOG_INFO("Rebooting"); reboot(); } - if (shutdownAtMsec && millis() > shutdownAtMsec) { + if (shutdownAtMsec && Throttle::deadlinePassed(shutdownAtMsec)) { shutdownAtMsec = 0; shutdown(); } @@ -879,12 +880,13 @@ void Power::reboot() if (screen) { screen = nullptr; } - LOG_DEBUG("final reboot!"); + LOG_DEBUG("final reboot"); ::reboot(); #elif defined(ARCH_STM32) HAL_NVIC_SystemReset(); #else - rebootAtMsec = -1; + // 0 disarms; UINT32_MAX would read as long expired and reboot-loop. + rebootAtMsec = 0; LOG_WARN("FIXME implement reboot for this platform. Note that some settings " "require a restart to be applied"); #endif @@ -1117,6 +1119,7 @@ int32_t Power::runOnce() { readPowerStatus(); logHeapUsage(); + lipoChargerRetry(); #ifdef HAS_PMU // WE no longer use the IRQ line to wake the CPU (due to false wakes from @@ -1733,13 +1736,32 @@ bool Power::cw2015Init() #if defined(HAS_PPM) && HAS_PPM +// The gauge is soldered on, so a failed init means wedged rather than absent - retry from +// the power thread before writing it off. +#define BQ27220_INIT_ATTEMPTS 3 +#define BQ27220_RETRY_INTERVAL_MS (60 * 1000) + /** * Adapter class for BQ25896/BQ27220 Lipo battery charger. + * + * The gauge only adds time-to-full/empty, so its failure must not take the charger down. */ class LipoCharger : public HasBatteryLevel { private: BQ27220 *bq = nullptr; + uint8_t gaugeAttemptsLeft = BQ27220_INIT_ATTEMPTS; + uint32_t lastGaugeAttemptMs = 0; + + // An aborted transfer leaves the i2c_master driver holding a stale transaction, which + // the next transfer trips over. Deleting the bus frees it along with the interrupt. + void recoverI2CBus() + { +#ifdef ARCH_ESP32 + Wire.end(); + Wire.begin(I2C_SDA, I2C_SCL); +#endif + } public: /** @@ -1786,24 +1808,46 @@ class LipoCharger : public HasBatteryLevel return false; } } - if (bq == nullptr) { - bq = new BQ27220; - bq->setDefaultCapacity(BQ27220_DESIGN_CAPACITY); + gaugeRunOnce(); + // Ready on the charger alone, so Power stays enabled and can retry the gauge later. + return true; + } - bool result = bq->init(); - if (result) { - LOG_DEBUG("BQ27220 design capacity: %d", bq->getDesignCapacity()); - LOG_DEBUG("BQ27220 fullCharge capacity: %d", bq->getFullChargeCapacity()); - LOG_DEBUG("BQ27220 remaining capacity: %d", bq->getRemainingCapacity()); - return true; - } else { - LOG_WARN("BQ27220 init failed"); - delete bq; - bq = nullptr; - return false; - } + /// Bring up the BQ27220 fuel gauge, unless it is already up or out of attempts + void gaugeRunOnce() + { + if (bq != nullptr || gaugeAttemptsLeft == 0) + return; + if (gaugeAttemptsLeft < BQ27220_INIT_ATTEMPTS && + Throttle::isWithinTimespanMs(lastGaugeAttemptMs, BQ27220_RETRY_INTERVAL_MS)) + return; + + lastGaugeAttemptMs = millis(); + gaugeAttemptsLeft--; + + // Cheap probe first: a silent gauge costs one transaction instead of the + // multi-second unseal/reset/provision sequence inside init(). + Wire.beginTransmission(BQ27220_I2C_ADDRESS); + if (Wire.endTransmission() != 0) { + LOG_WARN("BQ27220 not responding at 0x%x", BQ27220_I2C_ADDRESS); + return; } - return false; + + bq = new BQ27220; + bq->setDefaultCapacity(BQ27220_DESIGN_CAPACITY); + + if (bq->init()) { + LOG_DEBUG("BQ27220 design capacity: %d", bq->getDesignCapacity()); + LOG_DEBUG("BQ27220 fullCharge capacity: %d", bq->getFullChargeCapacity()); + LOG_DEBUG("BQ27220 remaining capacity: %d", bq->getRemainingCapacity()); + return; + } + + delete bq; + bq = nullptr; + // init() bails out mid-sequence, so hand the next bus user a sane driver state. + recoverI2CBus(); + LOG_WARN("BQ27220 init failed (%d retries left), use BQ25896 for battery state", (int)gaugeAttemptsLeft); } /** @@ -1819,7 +1863,7 @@ class LipoCharger : public HasBatteryLevel /** * The raw voltage of the battery in millivolts, or NAN if unknown */ - virtual uint16_t getBattVoltage() override { return bq->getVoltage(); } + virtual uint16_t getBattVoltage() override { return bq ? bq->getVoltage() : PPM->getBattVoltage(); } /** * return true if there is a battery installed in this unit @@ -1837,11 +1881,13 @@ class LipoCharger : public HasBatteryLevel virtual bool isCharging() override { bool isCharging = PPM->isCharging(); - if (isCharging) { - LOG_DEBUG("BQ27220 time to full charge: %d min", bq->getTimeToFull()); - } else { - if (!PPM->isVbusIn()) { - LOG_DEBUG("BQ27220 time to empty: %d min (%d mAh)", bq->getTimeToEmpty(), bq->getRemainingCapacity()); + if (bq) { + if (isCharging) { + LOG_TRACE("BQ27220 time to full charge: %d min", bq->getTimeToFull()); + } else { + if (!PPM->isVbusIn()) { + LOG_TRACE("BQ27220 time to empty: %d min (%d mAh)", bq->getTimeToEmpty(), bq->getRemainingCapacity()); + } } } return isCharging; @@ -1863,6 +1909,12 @@ bool Power::lipoChargerInit() return true; } +/// Retry a fuel gauge that did not come up during setup +void Power::lipoChargerRetry() +{ + lipoCharger.gaugeRunOnce(); +} + #else /** * The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel @@ -1871,6 +1923,8 @@ bool Power::lipoChargerInit() { return false; } + +void Power::lipoChargerRetry() {} #endif #ifdef HELTEC_MESH_SOLAR @@ -1926,7 +1980,7 @@ meshSolarBatteryLevel meshSolarLevel; bool Power::meshSolarInit() { bool result = meshSolarLevel.runOnce(); - LOG_DEBUG("Power::meshSolarInit mesh solar sensor is %s", result ? "ready" : "not ready yet"); + LOG_DEBUG("Power::meshSolarInit sensor is %s", result ? "ready" : "not ready yet"); if (!result) return false; batteryLevel = &meshSolarLevel; @@ -2059,7 +2113,7 @@ bool Power::serialBatteryInit() #endif bool result = serialBatteryLevel.runOnce(); - LOG_DEBUG("Power::serialBatteryInit serial battery sensor is %s", result ? "ready" : "not ready yet"); + LOG_DEBUG("Power::serialBatteryInit sensor is %s", result ? "ready" : "not ready yet"); if (!result) return false; batteryLevel = &serialBatteryLevel; diff --git a/src/Power.h b/src/Power.h index 38a65b081b..b47d66aff2 100644 --- a/src/Power.h +++ b/src/Power.h @@ -121,6 +121,8 @@ class Power : public concurrency::OSThread bool max17048Init(); /// Setup a Lipo charger bool lipoChargerInit(); + /// Retry a fuel gauge that did not come up during setup + void lipoChargerRetry(); /// Setup a meshSolar battery sensor bool meshSolarInit(); /// Setup a serial battery sensor diff --git a/src/PowerFSM.cpp b/src/PowerFSM.cpp index 5f2b03f435..268cb8211d 100644 --- a/src/PowerFSM.cpp +++ b/src/PowerFSM.cpp @@ -165,7 +165,7 @@ static void lsIdle() wakeCause2 = doLightSleep(100); // leave led on for 1ms secsSlept += sleepTime; - // LOG_INFO("Sleep, flash led!"); + // LOG_INFO("Sleep, flash led"); break; case ESP_SLEEP_WAKEUP_UART: diff --git a/src/PowerFSMThread.h b/src/PowerFSMThread.h index 47c45c2629..60a52e71da 100644 --- a/src/PowerFSMThread.h +++ b/src/PowerFSMThread.h @@ -5,6 +5,7 @@ #include "concurrency/OSThread.h" #include "configuration.h" #include "main.h" +#include "mesh/Throttle.h" namespace concurrency { @@ -29,9 +30,9 @@ class PowerFSMThread : public OSThread if (powerStatus->getHasUSB()) { timeLastPowered = millis(); } else if (config.power.on_battery_shutdown_after_secs > 0 && config.power.on_battery_shutdown_after_secs != UINT32_MAX && - millis() > (timeLastPowered + - Default::getConfiguredOrDefaultMs( - config.power.on_battery_shutdown_after_secs))) { // shutdown after 30 minutes unpowered + Throttle::hasElapsed( + timeLastPowered, + Default::getConfiguredOrDefaultMs(config.power.on_battery_shutdown_after_secs))) { // unpowered too long powerFSM.trigger(EVENT_SHUTDOWN); } diff --git a/src/SafeFile.cpp b/src/SafeFile.cpp index 0173fde816..a5893db302 100644 --- a/src/SafeFile.cpp +++ b/src/SafeFile.cpp @@ -70,7 +70,7 @@ bool SafeFile::close() String filenameTmp = filename; filenameTmp += ".tmp"; if (!renameFile(filenameTmp.c_str(), filename.c_str())) { - LOG_ERROR("Error: can't rename new pref file"); + LOG_ERROR("Can't rename new pref file"); return false; } diff --git a/src/UptimeClock.cpp b/src/UptimeClock.cpp index 5f85f50ff2..45f9affad7 100644 --- a/src/UptimeClock.cpp +++ b/src/UptimeClock.cpp @@ -1,33 +1,98 @@ // See UptimeClock.h for the full contract. #include "UptimeClock.h" #include +#include uint32_t Time::getMillis() { #ifdef PIO_UNIT_TESTING - if (Time::useTestClock) - return Time::testNowMs; + if (Time::useTestClock.load(std::memory_order_relaxed)) + return Time::testNowMs.load(std::memory_order_relaxed); #endif return millis(); } -uint64_t Time::getMillis64() +namespace { - static uint32_t lastLow = 0; // last 32-bit sample - static uint32_t highWord = 0; // number of observed wraps +struct PublishedSnapshot { + std::atomic high{0}; + std::atomic low{0}; +}; - uint32_t now = Time::getMillis(); +// The constexpr atomic initializers make both snapshots available before firmware startup. +PublishedSnapshot published[2]; +std::atomic publishedGeneration{0}; #ifdef PIO_UNIT_TESTING - // A test swapping clock sources (real <-> injected) can make `now` jump backward for - // reasons other than a genuine wrap - rebase rather than miscount it as one. - if (Time::clockSourceChanged) { - lastLow = now; - highWord = 0; - Time::clockSourceChanged = false; - } +std::atomic monotonicPublishHook{nullptr}; #endif - if (now < lastLow) - highWord++; // low word wrapped since last call - lastLow = now; - return (static_cast(highWord) << 32) | now; + +// Extend a published (high, low) snapshot to `now`; unsigned subtraction is exact across the wrap +// for any gap under 49.7 days. One copy, because reader and writer must agree on it exactly. +uint64_t extendPublished(uint32_t high, uint32_t low, uint32_t now) +{ + return ((((uint64_t)high << 32) | low) + (uint32_t)(now - low)); } + +// A generation change means the writer completed a publish while this copy was being read. A +// paused publish leaves the generation unchanged and writes only the inactive snapshot. +void readPublished(uint32_t &high, uint32_t &low) +{ + for (;;) { + const uint32_t before = publishedGeneration.load(std::memory_order_acquire); + PublishedSnapshot &snapshot = published[before & 1u]; + high = snapshot.high.load(std::memory_order_relaxed); + low = snapshot.low.load(std::memory_order_relaxed); + std::atomic_thread_fence(std::memory_order_acquire); + if (publishedGeneration.load(std::memory_order_relaxed) == before) + return; + } +} +} // namespace + +uint64_t Time::getMillisMonotonic() +{ + uint32_t high, low; + readPublished(high, low); + // The reader writes nothing back; it just extends the last published carry to now. + return extendPublished(high, low, getMillis()); +} + +uint32_t Time::getUptimeSecs() +{ + return (uint32_t)(getMillisMonotonic() / 1000); +} + +void Time::serviceMonotonic() +{ + const uint32_t generation = publishedGeneration.load(std::memory_order_relaxed); + PublishedSnapshot &active = published[generation & 1u]; + const uint32_t low = active.low.load(std::memory_order_relaxed); + const uint32_t high = active.high.load(std::memory_order_relaxed); + const uint64_t next = extendPublished(high, low, getMillis()); + + PublishedSnapshot &inactive = published[(generation + 1u) & 1u]; + inactive.high.store((uint32_t)(next >> 32), std::memory_order_relaxed); + inactive.low.store((uint32_t)next, std::memory_order_relaxed); +#ifdef PIO_UNIT_TESTING + if (const auto hook = monotonicPublishHook.load(std::memory_order_relaxed)) + hook(); +#endif + publishedGeneration.store(generation + 1u, std::memory_order_release); +} + +#ifdef PIO_UNIT_TESTING +void Time::resetMonotonicForTests() +{ + publishedGeneration.store(0, std::memory_order_relaxed); + for (auto &snapshot : published) { + snapshot.high.store(0, std::memory_order_relaxed); + snapshot.low.store(0, std::memory_order_relaxed); + } + monotonicPublishHook.store(nullptr, std::memory_order_relaxed); +} + +void Time::setMonotonicPublishHookForTests(MonotonicPublishHook hook) +{ + monotonicPublishHook.store(hook, std::memory_order_relaxed); +} +#endif diff --git a/src/UptimeClock.h b/src/UptimeClock.h index 9329a7bf60..efc04eb899 100644 --- a/src/UptimeClock.h +++ b/src/UptimeClock.h @@ -1,46 +1,69 @@ #pragma once #include +#ifdef PIO_UNIT_TESTING +#include +#endif // Monotonic uptime clock, injectable so tests can drive a virtual timebase instead of sleeping. // Uptime only; see gps/RTC.h for wall-clock. Not named Time.h: -Isrc would shadow C's . namespace Time { #ifdef PIO_UNIT_TESTING -// Test-only virtual clock; OFF by default so suites relying on real time are unaffected. -inline uint32_t testNowMs = 0; -inline bool useTestClock = false; -inline bool clockSourceChanged = true; // forces getMillis64() to rebase its wrap accumulator +// Test-only virtual clock; OFF by default so suites relying on real time are unaffected. Atomic so +// a suite can step the clock from one thread while others read it - the concurrent-reader cases in +// test_uptime_clock/ do exactly that. +inline std::atomic testNowMs{0}; +inline std::atomic useTestClock{false}; +using MonotonicPublishHook = void (*)(); inline void setTestMillis(uint32_t ms) { - testNowMs = ms; - useTestClock = true; - clockSourceChanged = true; + testNowMs.store(ms, std::memory_order_relaxed); + useTestClock.store(true, std::memory_order_relaxed); } inline void advanceTestMillis(uint32_t deltaMs) { - // Advancing from 0 after getMillis64() sampled the real clock steps backward, which would - // otherwise be miscounted as a wrap. - if (!useTestClock) - clockSourceChanged = true; - testNowMs += deltaMs; - useTestClock = true; + testNowMs.fetch_add(deltaMs, std::memory_order_relaxed); + useTestClock.store(true, std::memory_order_relaxed); } // Restore real-clock behaviour (call in test tearDown if a suite mixes real and fake time). inline void useRealClock() { - useTestClock = false; - testNowMs = 0; - clockSourceChanged = true; + useTestClock.store(false, std::memory_order_relaxed); + testNowMs.store(0, std::memory_order_relaxed); } +// Zero the published wrap carry. Suites that assert absolute uptime values call this in setUp(): +// a previous case that moved the test clock backwards left a counted wrap behind. +void resetMonotonicForTests(); +void setMonotonicPublishHookForTests(MonotonicPublishHook hook); #endif -/// Milliseconds since boot, 32-bit (wraps ~49.7 days). Drop-in for millis(). +/// Milliseconds since boot, 32-bit (wraps ~49.7 days). Drop-in for millis(). For "has this interval +/// elapsed / deadline arrived" use Throttle (isWithinTimespanMs / hasElapsed / deadlinePassed), +/// which is wrap-correct with no carry state at all. uint32_t getMillis(); -/// Milliseconds since boot, 64-bit, rollover-immune. Must be polled at least once per ~49.7-day -/// wrap window to catch every wrap, and keeps mutable static carry state, so it is NOT ISR-safe. -uint64_t getMillis64(); +/// Milliseconds since boot as a monotonic 64-bit count. +/// +/// A pure read: it derives its answer from a complete snapshot published by serviceMonotonic() +/// plus the unsigned elapsed time since that snapshot, which is exact across the wrap. A reader +/// that preempts publication uses the previous snapshot. If publication completes during a copy, +/// the reader retries; it never waits for a publish in progress. +/// +/// Not intended for ISR call sites because lock-free std::atomic operations are not guaranteed by +/// every supported toolchain. ISRs use getMillis(); the publication protocol itself never waits. +uint64_t getMillisMonotonic(); + +/// Whole seconds since boot, derived from getMillisMonotonic() (~136 years of range). This is +/// the unit to store when an instant must be dated before the wall clock is trustworthy. +uint32_t getUptimeSecs(); + +/// Advances the published wrap carry. THE ONLY WRITER - call it from the main loop and nowhere +/// else. Two concurrent callers could count one wrap twice, jumping every uptime and wall-clock +/// reading ~49.7 days forward for the rest of the boot. +/// +/// Must run at least once per ~49.7-day wrap window; the main loop calls it every iteration. +void serviceMonotonic(); } // namespace Time diff --git a/src/airtime.cpp b/src/airtime.cpp index 0e0d72e20e..a9b4c7dc58 100644 --- a/src/airtime.cpp +++ b/src/airtime.cpp @@ -1,6 +1,8 @@ #include "airtime.h" #include "NodeDB.h" +#include "UptimeClock.h" #include "configuration.h" +#include AirTime *airTime = NULL; @@ -11,6 +13,9 @@ uint32_t air_period_rx[PERIODS_TO_LOG]; void AirTime::logAirtime(reportTypes reportType, uint32_t airtime_ms) { + // A packet may be logged immediately after waking from light sleep. Sync first so + // the packet is counted in the current wall-time bucket, not a stale awake-time bucket. + syncNow(); if (reportType == TX_LOG) { LOG_DEBUG("Packet TX: %ums", airtime_ms); @@ -33,47 +38,112 @@ void AirTime::logAirtime(reportTypes reportType, uint32_t airtime_ms) uint8_t AirTime::currentPeriodIndex() { - return ((getSecondsSinceBoot() / SECONDS_PER_PERIOD) % PERIODS_TO_LOG); + return ((secSinceBoot / SECONDS_PER_PERIOD) % PERIODS_TO_LOG); } uint8_t AirTime::getPeriodUtilMinute() { - return (getSecondsSinceBoot() / 10) % CHANNEL_UTILIZATION_PERIODS; + return (secSinceBoot / 10) % CHANNEL_UTILIZATION_PERIODS; } uint8_t AirTime::getPeriodUtilHour() { - return (getSecondsSinceBoot() / 60) % MINUTES_IN_HOUR; + return (secSinceBoot / 60) % MINUTES_IN_HOUR; } void AirTime::airtimeRotatePeriod() { + // Preserve the public helper while keeping all rotation logic in one monotonic-time path. + syncNow(); +} - if (this->airtimes.lastPeriodIndex != this->currentPeriodIndex()) { - LOG_DEBUG("Rotate airtimes to a new period = %u", this->currentPeriodIndex()); +void AirTime::syncNow() +{ + // Monotonic uptime, not RTC/network time: a user, GPS, or NTP clock change must not move + // airtime accounting. Pure read; the main loop publishes the wrap carry it derives from. + uint32_t nowSecs = Time::getUptimeSecs(); - for (int i = PERIODS_TO_LOG - 2; i >= 0; --i) { - this->airtimes.periodTX[i + 1] = this->airtimes.periodTX[i]; - this->airtimes.periodRX[i + 1] = this->airtimes.periodRX[i]; - this->airtimes.periodRX_ALL[i + 1] = this->airtimes.periodRX_ALL[i]; - - air_period_tx[i + 1] = this->airtimes.periodTX[i]; - air_period_rx[i + 1] = this->airtimes.periodRX[i]; - } - - this->airtimes.periodTX[0] = 0; - this->airtimes.periodRX[0] = 0; - this->airtimes.periodRX_ALL[0] = 0; - - air_period_tx[0] = 0; - air_period_rx[0] = 0; + if (firstTime) { + memset(this->utilizationTX, 0, sizeof(this->utilizationTX)); + memset(this->channelUtilization, 0, sizeof(this->channelUtilization)); + memset(this->airtimes.periodTX, 0, sizeof(this->airtimes.periodTX)); + memset(this->airtimes.periodRX, 0, sizeof(this->airtimes.periodRX)); + memset(this->airtimes.periodRX_ALL, 0, sizeof(this->airtimes.periodRX_ALL)); + memset(air_period_tx, 0, sizeof(air_period_tx)); + memset(air_period_rx, 0, sizeof(air_period_rx)); + this->secSinceBoot = nowSecs; + this->lastUtilPeriod = this->getPeriodUtilMinute(); + this->lastUtilPeriodTX = this->getPeriodUtilHour(); this->airtimes.lastPeriodIndex = this->currentPeriodIndex(); + firstTime = false; + return; } + + if (nowSecs == this->secSinceBoot) { + return; + } + + uint32_t oldSecSinceBoot = this->secSinceBoot; + this->secSinceBoot = nowSecs; + + // Historical airtime reports use 1-hour buckets. If multiple hours elapsed while + // asleep, rotate each crossed bucket or clear the whole report window. + uint32_t elapsedAirtimePeriods = (this->secSinceBoot / SECONDS_PER_PERIOD) - (oldSecSinceBoot / SECONDS_PER_PERIOD); + if (elapsedAirtimePeriods >= PERIODS_TO_LOG) { + memset(this->airtimes.periodTX, 0, sizeof(this->airtimes.periodTX)); + memset(this->airtimes.periodRX, 0, sizeof(this->airtimes.periodRX)); + memset(this->airtimes.periodRX_ALL, 0, sizeof(this->airtimes.periodRX_ALL)); + memset(air_period_tx, 0, sizeof(air_period_tx)); + memset(air_period_rx, 0, sizeof(air_period_rx)); + } else { + while (elapsedAirtimePeriods-- > 0) { + LOG_DEBUG("Rotate airtimes to a new period = %u", this->currentPeriodIndex()); + for (int i = PERIODS_TO_LOG - 2; i >= 0; --i) { + this->airtimes.periodTX[i + 1] = this->airtimes.periodTX[i]; + this->airtimes.periodRX[i + 1] = this->airtimes.periodRX[i]; + this->airtimes.periodRX_ALL[i + 1] = this->airtimes.periodRX_ALL[i]; + air_period_tx[i + 1] = this->airtimes.periodTX[i]; + air_period_rx[i + 1] = this->airtimes.periodRX[i]; + } + + this->airtimes.periodTX[0] = 0; + this->airtimes.periodRX[0] = 0; + this->airtimes.periodRX_ALL[0] = 0; + air_period_tx[0] = 0; + air_period_rx[0] = 0; + } + } + this->airtimes.lastPeriodIndex = this->currentPeriodIndex(); + + // Channel utilization is a rolling 60-second view split into six 10-second buckets. + // Clear every bucket crossed while asleep so old airtime decays by real elapsed time. + uint32_t elapsedUtilPeriods = (this->secSinceBoot / 10) - (oldSecSinceBoot / 10); + if (elapsedUtilPeriods >= CHANNEL_UTILIZATION_PERIODS) { + memset(this->channelUtilization, 0, sizeof(this->channelUtilization)); + } else { + for (uint32_t i = 1; i <= elapsedUtilPeriods; i++) { + this->channelUtilization[((oldSecSinceBoot / 10) + i) % CHANNEL_UTILIZATION_PERIODS] = 0; + } + } + this->lastUtilPeriod = this->getPeriodUtilMinute(); + + // TX utilization is a rolling 60-minute view used by duty-cycle checks. + uint32_t elapsedUtilTXPeriods = (this->secSinceBoot / 60) - (oldSecSinceBoot / 60); + if (elapsedUtilTXPeriods >= MINUTES_IN_HOUR) { + memset(this->utilizationTX, 0, sizeof(this->utilizationTX)); + } else { + for (uint32_t i = 1; i <= elapsedUtilTXPeriods; i++) { + this->utilizationTX[((oldSecSinceBoot / 60) + i) % MINUTES_IN_HOUR] = 0; + } + } + this->lastUtilPeriodTX = this->getPeriodUtilHour(); } uint32_t *AirTime::airtimeReport(reportTypes reportType) { + // Reports may be requested before runOnce() executes after wake. + syncNow(); if (reportType == TX_LOG) { return this->airtimes.periodTX; @@ -97,11 +167,16 @@ uint32_t AirTime::getSecondsPerPeriod() uint32_t AirTime::getSecondsSinceBoot() { + // Keep HTTP/debug reporting aligned with the same monotonic clock used by the buckets. + syncNow(); return this->secSinceBoot; } float AirTime::channelUtilizationPercent() { + // Gate decisions should see buckets that have decayed across light-sleep time. + syncNow(); + uint32_t sum = 0; for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) { sum += this->channelUtilization[i]; @@ -112,6 +187,9 @@ float AirTime::channelUtilizationPercent() float AirTime::utilizationTXPercent() { + // Duty-cycle checks use this value, so keep it current even outside the periodic thread. + syncNow(); + uint32_t sum = 0; for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) { sum += this->utilizationTX[i]; @@ -162,50 +240,6 @@ AirTime::AirTime() : concurrency::OSThread("AirTime"), airtimes({}) {} int32_t AirTime::runOnce() { - secSinceBoot++; - - uint8_t utilPeriod = this->getPeriodUtilMinute(); - uint8_t utilPeriodTX = this->getPeriodUtilHour(); - - if (firstTime) { - - // Init utilizationTX window to all 0 - for (uint32_t i = 0; i < MINUTES_IN_HOUR; i++) { - this->utilizationTX[i] = 0; - } - - // Init channelUtilization window to all 0 - for (uint32_t i = 0; i < CHANNEL_UTILIZATION_PERIODS; i++) { - this->channelUtilization[i] = 0; - } - - // Init airtime windows to all 0 - for (int i = 0; i < PERIODS_TO_LOG; i++) { - this->airtimes.periodTX[i] = 0; - this->airtimes.periodRX[i] = 0; - this->airtimes.periodRX_ALL[i] = 0; - - // air_period_tx[i] = 0; - // air_period_rx[i] = 0; - } - - firstTime = false; - lastUtilPeriod = utilPeriod; - } else { - this->airtimeRotatePeriod(); - - // Reset the channelUtilization window when we roll over - if (lastUtilPeriod != utilPeriod) { - lastUtilPeriod = utilPeriod; - - this->channelUtilization[utilPeriod] = 0; - } - - if (lastUtilPeriodTX != utilPeriodTX) { - lastUtilPeriodTX = utilPeriodTX; - - this->utilizationTX[utilPeriodTX] = 0; - } - } + syncNow(); return (1000 * 1); } diff --git a/src/airtime.h b/src/airtime.h index 8e3e6c5578..39c1d3e03d 100644 --- a/src/airtime.h +++ b/src/airtime.h @@ -39,6 +39,12 @@ void logAirtime(reportTypes reportType, uint32_t airtime_ms); uint32_t *airtimeReport(reportTypes reportType); +// Not thread-safe: everything but getPeriodsToLog()/getSecondsPerPeriod() either rotates the +// windows via syncNow() or reads the buckets. Current callers are all on the OSThread scheduler - +// RadioLibInterface/SimRadio, RadioInterface, Router, DeviceTelemetry, ContentHandler, and the +// screen renderers. New callers must be on that thread too, or this needs a lock. +// TODO: airtime lock-guarding - serialise the above behind a lock so the contract is enforced +// rather than documented. Kept out of this PR: it is a separate concern from millis() rollover. class AirTime : private concurrency::OSThread { @@ -66,6 +72,8 @@ class AirTime : private concurrency::OSThread bool firstTime = true; uint8_t lastUtilPeriod = 0; uint8_t lastUtilPeriodTX = 0; + // Time::getUptimeSecs() as of the last syncNow(); the gap since is what the windows rotate by, + // so they stay correct even if the scheduler was paused by light sleep. uint32_t secSinceBoot = 0; uint8_t max_channel_util_percent = 40; uint8_t polite_channel_util_percent = 25; @@ -81,6 +89,8 @@ class AirTime : private concurrency::OSThread uint8_t getPeriodUtilMinute(); uint8_t getPeriodUtilHour(); uint8_t currentPeriodIndex(); + // Advance rolling airtime windows from monotonic uptime, not from runOnce() calls. + void syncNow(); protected: virtual int32_t runOnce() override; diff --git a/src/configuration.h b/src/configuration.h index f9be2fc46c..0ed4dd893d 100644 --- a/src/configuration.h +++ b/src/configuration.h @@ -88,6 +88,12 @@ along with this program. If not, see . #define MESHTASTIC_PREHOP_DROP 1 #endif +// Use polynomial approximations for trigonometric functions to save flash. +// Override with -D MESHTASTIC_TRIG_APPROX=0 for exact trig for special use cases e.g. close to Earth's poles. +#ifndef MESHTASTIC_TRIG_APPROX +#define MESHTASTIC_TRIG_APPROX 1 +#endif + // Debug/test only: let a wired client (serial/TCP) inject frames into the RX pipeline as if they had // arrived over LoRa - a SIMULATOR_APP ToRadio packet is delivered through the real receive path on real // hardware (see MeshService::injectAsReceived). This forges over-the-air traffic, so it MUST stay 0 in diff --git a/src/detect/ReClockI2C.h b/src/detect/ReClockI2C.h index 503f1a48b1..24a166d53f 100644 --- a/src/detect/ReClockI2C.h +++ b/src/detect/ReClockI2C.h @@ -35,20 +35,20 @@ class ReClockI2C uint32_t currentClock = this->getClock(); if (currentClock) { - LOG_DEBUG("Current I2C frequency: %uHz", currentClock); + LOG_TRACE("Current I2C frequency: %uHz", currentClock); } if (currentClock != desiredClock) { - LOG_DEBUG("Changing I2C clock to %uHz", desiredClock); + LOG_TRACE("Changing I2C clock to %uHz", desiredClock); this->i2cBus->setClock(desiredClock); // If the clock is 0Hz, we still store it // We'll check in restoreClock function setPreviousClock(currentClock); - LOG_DEBUG("Stored previous clock I2C clock: %uHz", this->previousClock); + LOG_TRACE("Stored previous clock I2C clock: %uHz", this->previousClock); return true; } - LOG_DEBUG("I2C clock was already %uHz. Skipping", desiredClock); + LOG_TRACE("I2C clock was already %uHz. Skipping", desiredClock); setPreviousClock(0); return false; } @@ -56,12 +56,12 @@ class ReClockI2C bool restoreClock() { if (this->previousClock) { - LOG_DEBUG("Restoring I2C clock to %uHz", this->previousClock); + LOG_TRACE("Restoring I2C clock to %uHz", this->previousClock); i2cBus->setClock(this->previousClock); setPreviousClock(0); return true; } - LOG_DEBUG("I2C clock was unknown. Not restored"); + LOG_TRACE("I2C clock was unknown. Not restored"); return false; } diff --git a/src/detect/ScanI2CTwoWire.cpp b/src/detect/ScanI2CTwoWire.cpp index 0aa2301e3c..21a74b7599 100644 --- a/src/detect/ScanI2CTwoWire.cpp +++ b/src/detect/ScanI2CTwoWire.cpp @@ -743,7 +743,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize) logFoundDevice("DS2482-800", (uint8_t)addr.address); break; } - type = HMC5883L; logFoundDevice("HMC5883L", (uint8_t)addr.address); break; diff --git a/src/gps/GPS.cpp b/src/gps/GPS.cpp index dcd765c9e8..69000f2fef 100644 --- a/src/gps/GPS.cpp +++ b/src/gps/GPS.cpp @@ -5,10 +5,12 @@ #if !MESHTASTIC_EXCLUDE_GPS #include "Default.h" #include "GPS.h" +#include "GPSLog.h" #include "GpioLogic.h" #include "NodeDB.h" #include "PowerMon.h" #include "Throttle.h" +#include "UptimeClock.h" #include "buzz.h" #include "concurrency/Periodic.h" #include "gps/RTC.h" @@ -337,7 +339,7 @@ uint8_t GPS::makeCASPacket(uint8_t class_id, uint8_t msg_id, uint8_t payload_siz } CASChecksum(UBXscratch, (payload_size + 10)); -#if defined(GPS_DEBUG) && defined(DEBUG_PORT) +#if GPS_DEBUG && defined(DEBUG_PORT) LOG_DEBUG("CAS packet: "); DEBUG_PORT.hexDump(MESHTASTIC_LOG_LEVEL_DEBUG, UBXscratch, payload_size + 10); #endif @@ -349,27 +351,25 @@ GPS_RESPONSE GPS::getACK(const char *message, uint32_t waitMillis) uint8_t buffer[768] = {0}; uint8_t b; int bytesRead = 0; - uint32_t startTimeout = millis() + waitMillis; -#ifdef GPS_DEBUG + // Start stamp + interval rather than a stored deadline: same wrap-safety, but the full 49.7-day + // range instead of 24.8 days ahead, and Time::getMillis() makes the wait injectable. + const uint32_t waitStartMs = Time::getMillis(); +#if GPS_DEBUG std::string debugmsg = ""; #endif - while (millis() < startTimeout) { + while (Throttle::isWithinTimespanMs(waitStartMs, waitMillis)) { if (_serial_gps->available()) { b = _serial_gps->read(); -#ifdef GPS_DEBUG +#if GPS_DEBUG debugmsg += vformat("%c", (b >= 32 && b <= 126) ? b : '.'); #endif buffer[bytesRead] = b; bytesRead++; if ((bytesRead == 767) || (b == '\r')) { -#ifdef GPS_DEBUG - LOG_DEBUG(debugmsg.c_str()); -#endif + LOG_DEBUG_GPS("%s", debugmsg.c_str()); if (strnstr((char *)buffer, message, bytesRead) != nullptr) { -#ifdef GPS_DEBUG - LOG_DEBUG("Found: %s", message); // Log the found message -#endif + LOG_DEBUG_GPS("Found: %s", message); // Log the found message return GNSS_RESPONSE_OK; } else { bytesRead = 0; @@ -418,17 +418,13 @@ GPS_RESPONSE GPS::getACKCas(uint8_t class_id, uint8_t msg_id, uint32_t waitMilli // Check for an ACK-ACK for the specified class and message id if ((msg_cls == 0x05) && (msg_msg_id == 0x01) && payload_cls == class_id && payload_msg == msg_id) { -#ifdef GPS_DEBUG - LOG_INFO("Got ACK for class %02X message %02X in %dms", class_id, msg_id, millis() - startTime); -#endif + LOG_DEBUG_GPS("Got ACK for class %02X msg %02X in %dms", class_id, msg_id, millis() - startTime); return GNSS_RESPONSE_OK; } // Check for an ACK-NACK for the specified class and message id if ((msg_cls == 0x05) && (msg_msg_id == 0x00) && payload_cls == class_id && payload_msg == msg_id) { -#ifdef GPS_DEBUG - LOG_WARN("Got NACK for class %02X message %02X in %dms", class_id, msg_id, millis() - startTime); -#endif + LOG_DEBUG_GPS("Got NACK for class %02X msg %02X in %dms", class_id, msg_id, millis() - startTime); return GNSS_RESPONSE_NAK; } @@ -450,7 +446,7 @@ GPS_RESPONSE GPS::getACK(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis) uint32_t startTime = millis(); const char frame_errors[] = "More than 100 frame errors"; int sCounter = 0; -#ifdef GPS_DEBUG +#if GPS_DEBUG std::string debugmsg = ""; #endif @@ -467,9 +463,7 @@ GPS_RESPONSE GPS::getACK(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis) while (Throttle::isWithinTimespanMs(startTime, waitMillis)) { if (ack > 9) { -#ifdef GPS_DEBUG - LOG_INFO("Got ACK for class %02X message %02X in %dms", class_id, msg_id, millis() - startTime); -#endif + LOG_DEBUG_GPS("Got ACK for class %02X msg %02X in %dms", class_id, msg_id, millis() - startTime); return GNSS_RESPONSE_OK; // ACK received } if (_serial_gps->available()) { @@ -477,36 +471,29 @@ GPS_RESPONSE GPS::getACK(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis) if (b == frame_errors[sCounter]) { sCounter++; if (sCounter == 26) { -#ifdef GPS_DEBUG - - LOG_DEBUG(debugmsg.c_str()); -#endif + LOG_DEBUG_GPS("%s", debugmsg.c_str()); return GNSS_RESPONSE_FRAME_ERRORS; } } else { sCounter = 0; } -#ifdef GPS_DEBUG +#if GPS_DEBUG debugmsg += vformat("%02X", b); #endif if (b == buf[ack]) { ack++; } else { if (ack == 3 && b == 0x00) { // UBX-ACK-NAK message -#ifdef GPS_DEBUG - LOG_DEBUG(debugmsg.c_str()); -#endif - LOG_WARN("Got NAK for class %02X message %02X", class_id, msg_id); + LOG_DEBUG_GPS("%s", debugmsg.c_str()); + LOG_WARN("Got NAK for class %02X msg %02X", class_id, msg_id); return GNSS_RESPONSE_NAK; // NAK received } ack = 0; // Reset the acknowledgement counter } } } -#ifdef GPS_DEBUG - LOG_DEBUG(debugmsg.c_str()); - LOG_WARN("No response for class %02X message %02X", class_id, msg_id); -#endif + LOG_DEBUG_GPS("%s", debugmsg.c_str()); + LOG_DEBUG_GPS("No response for class %02X msg %02X", class_id, msg_id); return GNSS_RESPONSE_NONE; // No response received within timeout } @@ -577,9 +564,7 @@ int GPS::getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t ubxFrameCounter = 0; } else { // return payload length -#ifdef GPS_DEBUG - LOG_INFO("Got ACK for class %02X message %02X in %dms", requestedClass, requestedID, millis() - startTime); -#endif + LOG_DEBUG_GPS("Got ACK for class %02X msg %02X in %dms", requestedClass, requestedID, millis() - startTime); return needRead; } break; @@ -789,7 +774,7 @@ bool GPS::verifyCachedProbePresence() present = sawNmeaSentenceAtBaud(_serial_gps, 3000); } if (!present) { - LOG_WARN("Cached GPS probe is stale (%s @ %d), clearing cache", cachedProbeModelName, cachedProbeBaud); + LOG_WARN("Cached GPS probe stale (%s @ %d), clearing", cachedProbeModelName, cachedProbeBaud); clearProbeCache(); return false; } @@ -843,7 +828,7 @@ bool GPS::setup() if (gnssModel != GNSS_MODEL_UNKNOWN) { detectedBaud = rareSerialSpeeds[speedSelect]; } else if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) { - LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE); + LOG_WARN("Give up GPS probe, set to %d", GPS_BAUDRATE); return true; } } @@ -922,14 +907,14 @@ bool GPS::setup() msglen = makeCASPacket(0x06, 0x07, sizeof(_message_CAS_CFG_NAVX_CONF), _message_CAS_CFG_NAVX_CONF); _serial_gps->write(UBXscratch, msglen); if (getACKCas(0x06, 0x07, 250) != GNSS_RESPONSE_OK) { - LOG_WARN("ATGM336H: Could not set Config"); + LOG_WARN("ATGM336H: Can't set Config"); } // Set the update frequency to 1Hz msglen = makeCASPacket(0x06, 0x04, sizeof(_message_CAS_CFG_RATE_1HZ), _message_CAS_CFG_RATE_1HZ); _serial_gps->write(UBXscratch, msglen); if (getACKCas(0x06, 0x04, 250) != GNSS_RESPONSE_OK) { - LOG_WARN("ATGM336H: Could not set Update Frequency"); + LOG_WARN("ATGM336H: Can't set Update Frequency"); } // Set the NEMA output messages @@ -941,7 +926,7 @@ bool GPS::setup() msglen = makeCASPacket(0x06, 0x01, sizeof(cas_cfg_msg_packet), cas_cfg_msg_packet); _serial_gps->write(UBXscratch, msglen); if (getACKCas(0x06, 0x01, 250) != GNSS_RESPONSE_OK) { - LOG_WARN("ATGM336H: Could not enable NMEA MSG: %d", fields[i]); + LOG_WARN("ATGM336H: Can't enable NMEA MSG: %d", fields[i]); } } } else if (gnssModel == GNSS_MODEL_UC6580) { @@ -1009,9 +994,9 @@ bool GPS::setup() msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE); _serial_gps->write(UBXscratch, msglen); if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) { - LOG_WARN("Unable to save GNSS module config"); + LOG_WARN("Can't save GNSS module config"); } else { - LOG_INFO("GNSS module config saved!"); + LOG_INFO("GNSS module config saved"); } } else if (IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9)) { if (gnssModel == GNSS_MODEL_UBLOX7) { @@ -1025,7 +1010,7 @@ bool GPS::setup() if (getACK(0x06, 0x3e, 800) == GNSS_RESPONSE_NAK) { // It's not critical if the module doesn't acknowledge this configuration. - LOG_DEBUG("reconfigure GNSS - defaults maintained. Is this module GPS-only?"); + LOG_DEBUG("reconfigure GNSS - defaults kept. GPS-only module?"); } else { if (gnssModel == GNSS_MODEL_UBLOX7) { LOG_INFO("GPS+SBAS configured"); @@ -1078,9 +1063,9 @@ bool GPS::setup() msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE); _serial_gps->write(UBXscratch, msglen); if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) { - LOG_WARN("Unable to save GNSS module config"); + LOG_WARN("Can't save GNSS module config"); } else { - LOG_INFO("GNSS module configuration saved!"); + LOG_INFO("GNSS module config saved"); } } else if (gnssModel == GNSS_MODEL_UBLOX10) { delay(1000); @@ -1126,9 +1111,9 @@ bool GPS::setup() msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE_10), _message_SAVE_10); _serial_gps->write(UBXscratch, msglen); if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) { - LOG_WARN("Unable to save GNSS module config"); + LOG_WARN("Can't save GNSS module config"); } else { - LOG_INFO("GNSS module configuration saved!"); + LOG_INFO("GNSS module config saved"); } } else if (gnssModel == GNSS_MODEL_CM121) { // only ask for RMC and GGA @@ -1159,7 +1144,7 @@ void GPS::setPowerState(GPSPowerState newState, uint32_t sleepTime) // Update the stored GPSPowerstate, and create local copies GPSPowerState oldState = powerState; powerState = newState; - LOG_INFO("GPS power state move from %s to %s", getGPSPowerStateString(oldState), getGPSPowerStateString(newState)); + LOG_INFO("GPS power state %s -> %s", getGPSPowerStateString(oldState), getGPSPowerStateString(newState)); switch (newState) { case GPS_ACTIVE: @@ -1234,9 +1219,7 @@ void GPS::writePinEN(bool on) // Write and log enablePin->set(on); -#ifdef GPS_DEBUG - LOG_DEBUG("Pin EN %s", on == HIGH ? "HI" : "LOW"); -#endif + LOG_DEBUG_GPS("Pin EN %s", on == HIGH ? "HI" : "LOW"); } // Set the value of the STANDBY pin, if relevant @@ -1259,9 +1242,7 @@ void GPS::writePinStandby(bool standby) _serial_gps->write("$PMTK225,4*2F\r\n"); } -#ifdef GPS_DEBUG - LOG_DEBUG("Pin STANDBY %s", val == HIGH ? "HI" : "LOW"); -#endif + LOG_DEBUG_GPS("Pin STANDBY %s", val == HIGH ? "HI" : "LOW"); #endif } @@ -1272,9 +1253,7 @@ void GPS::writePinRFEN(bool on) bool val = on ? GPS_RF_EN_ACTIVE : !GPS_RF_EN_ACTIVE; pinMode(PIN_GPS_RF_EN, OUTPUT); digitalWrite(PIN_GPS_RF_EN, val); -#ifdef GPS_DEBUG - LOG_DEBUG("Pin RF EN %s", val == HIGH ? "HI" : "LOW"); -#endif + LOG_DEBUG_GPS("Pin RF EN %s", val == HIGH ? "HI" : "LOW"); #else (void)on; #endif @@ -1310,9 +1289,7 @@ void GPS::setPowerPMU(bool on) // t-beam v1.1 GNSS power channel on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3); } -#ifdef GPS_DEBUG - LOG_DEBUG("PMU %s", on ? "on" : "off"); -#endif + LOG_DEBUG_GPS("PMU %s", on ? "on" : "off"); #endif } @@ -1358,9 +1335,7 @@ void GPS::setPowerUBLOX(bool on, uint32_t sleepMs) // Send the UBX packet gps->_serial_gps->write(gps->UBXscratch, msglen); -#ifdef GPS_DEBUG - LOG_DEBUG("UBLOX: sleep for %dmS", sleepMs); -#endif + LOG_DEBUG_GPS("UBLOX: sleep for %dmS", sleepMs); } } @@ -1417,12 +1392,8 @@ void GPS::down() #endif if (softsleepSupported) { - // How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than - // GPS_SOFTSLEEP? Heuristic equation. A compromise manually fitted to power observations from U-blox NEO-6M - // and M10050 https://www.desmos.com/calculator/6gvjghoumr This is not particularly accurate, but probably an - // improvement over a single, fixed threshold - uint32_t hardsleepThreshold = (2750 * pow(predictedSearchDuration / 1000, 1.22)); - LOG_DEBUG("gps_update_interval >= %us needed to justify hardsleep", hardsleepThreshold / 1000); + uint32_t hardsleepThreshold = gpsHardsleepThresholdMs(predictedSearchDuration / 1000); + LOG_DEBUG("gps_update_interval >= %us needed for hardsleep", hardsleepThreshold / 1000); // If update interval too short: softsleep (if supported by hardware) if (updateInterval < hardsleepThreshold) { @@ -1446,7 +1417,7 @@ void GPS::publishUpdate() LOG_DEBUG("Publish pos@%x:2, hasVal=%d, Sats=%d, GPSlock=%d", p.timestamp, hasValidLocation, p.sats_in_view, hasLock()); // Notify any status instances that are observing us - const meshtastic::GPSStatus status = meshtastic::GPSStatus(hasValidLocation, isConnected(), isPowerSaving(), p); + const meshtastic::GPSStatus status = meshtastic::GPSStatus(hasValidLocation, isConnected(), isPowerSaving(), p, gotTime); newStatus.notifyObservers(&status); if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) { positionModule->handleNewPosition(); @@ -1454,6 +1425,29 @@ void GPS::publishUpdate() } } +/// Is a post-lock ephemeris hold currently in force? The `!= 0` is the "never armed" sentinel, which +/// deadlinePassed() reads as passed for the first half of each wrap cycle and as ~24.8 days in the +/// future for the second. No header: test_gps_fix_hold declares the prototypes itself. +bool fixHoldInForce(uint32_t fixHoldEnds, uint32_t threadIntervalMs) +{ + return fixHoldEnds != 0 && !Throttle::deadlinePassed(fixHoldEnds + threadIntervalMs); +} + +/// Did an armed hold just expire? `!= 0` guards against negating fixHoldInForce() alone, which would +/// call an unarmed hold "expired" every cycle. No grace interval: the deadline itself is go-down time. +bool holdJustExpired(uint32_t fixHoldEnds) +{ + return fixHoldEnds != 0 && !fixHoldInForce(fixHoldEnds, 0); +} + +/// Should a post-lock ephemeris hold be (re-)armed this cycle? "No hold in force" fires often, since +/// every publish clears the hold, including ones that don't put the receiver back to sleep. +bool shouldArmFixHold(bool hasValidLocation, uint8_t prevFixQual, uint32_t fixHoldEnds, uint32_t threadIntervalMs) +{ + // First lock of a cycle, first lock after the receiver was off, or nothing holding right now. + return !hasValidLocation || prevFixQual == 0 || !fixHoldInForce(fixHoldEnds, threadIntervalMs); +} + int32_t GPS::runOnce() { #if defined(SENSECAP_INDICATOR) @@ -1480,7 +1474,7 @@ int32_t GPS::runOnce() return currentDelay; // Setup failed, re-run in two seconds if (gnssModel == GNSS_MODEL_UNKNOWN) { - LOG_WARN("GPS not detected; marked not present for this boot"); + LOG_WARN("GPS not detected; not present this boot"); return disable(); } @@ -1502,7 +1496,7 @@ int32_t GPS::runOnce() // gps_update_interval is faster than the position broadcast interval so there's a // fresh position ready when the device wants to broadcast one on the mesh. // - // 1. Got a time for the first time --> set the time, don't publish. + // 1. Got a time for the first time --> set the time, publish so the UI can show the time-only state. // 2. Got a lock for the first time // --> If gps_update_interval is <= 10s --> publishUpdate // --> Otherwise, hold for MIN(gps_update_interval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS, 20s) @@ -1536,12 +1530,17 @@ int32_t GPS::runOnce() // 1. Got a time for the first time this cycle if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time gotTime = true; + // Publish immediately (rather than via the block below, which would clear fixHoldEnds) so the + // time-only state reaches the UI without waiting for a location. Safe without a valid location: + // PositionModule::handleNewPosition ignores invalid positions. + shouldPublish = true; + publishUpdate(); } // 2. Got a lock for the first time, or 3. Got a lock after turning back on bool gotLoc = lookForLocation(); if (gotLoc) { -#ifdef GPS_DEBUG +#if GPS_DEBUG if (!hasValidLocation) { // declare that we have location ASAP LOG_DEBUG("hasValidLocation RISING EDGE"); } @@ -1549,35 +1548,33 @@ int32_t GPS::runOnce() if (updateInterval <= GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS) { hasValidLocation = true; shouldPublish = true; - } else if (!hasValidLocation || prev_fixQual == 0 || (fixHoldEnds + GPS_THREAD_INTERVAL) < millis()) { + } else if (shouldArmFixHold(hasValidLocation, prev_fixQual, fixHoldEnds, GPS_THREAD_INTERVAL)) { hasValidLocation = true; // Hold for up to 20secs after getting a lock to download ephemeris etc uint32_t holdTime = updateInterval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS; if (holdTime > GPS_FIX_HOLD_MAX_MS) holdTime = GPS_FIX_HOLD_MAX_MS; - fixHoldEnds = millis() + holdTime; -#ifdef GPS_DEBUG - LOG_DEBUG("Holding for %ums after lock", holdTime); -#endif + // Same clock the Throttle evaluation reads, and never the "no hold" sentinel. + const uint32_t holdEnds = Time::getMillis() + holdTime; + fixHoldEnds = holdEnds == 0 ? 1 : holdEnds; + LOG_DEBUG_GPS("Holding for %ums after lock", holdTime); } } bool tooLong = scheduling.searchedTooLong(); if (tooLong && !gotLoc) { - LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time"); + LOG_WARN("Can't publish valid location: no GPS lock in time"); // we didn't get a location during this ack window, therefore declare loss of lock if (hasValidLocation) { p = meshtastic_Position_init_default; hasValidLocation = false; shouldPublish = true; -#ifdef GPS_DEBUG - LOG_DEBUG("hasValidLocation FALLING EDGE"); -#endif + LOG_DEBUG_GPS("hasValidLocation FALLING EDGE"); } } // Hold has expired , Search time has expired, we got a time only, or we never needed to hold. - bool holdExpired = (fixHoldEnds != 0 && millis() > fixHoldEnds); + bool holdExpired = holdJustExpired(fixHoldEnds); if (shouldPublish || tooLong || holdExpired) { if (gotTime && hasValidLocation) { shouldPublish = true; @@ -1592,9 +1589,9 @@ int32_t GPS::runOnce() down(); } -#ifdef GPS_DEBUG +#if GPS_DEBUG } else if (fixHoldEnds != 0) { - LOG_DEBUG("Holding for GPS data download: %d ms (numSats=%d)", fixHoldEnds - millis(), p.sats_in_view); + LOG_DEBUG("Holding for GPS data download: %d ms (numSats=%d)", fixHoldEnds - Time::getMillis(), p.sats_in_view); #endif } } @@ -1623,7 +1620,7 @@ void GPS::clearBuffer() /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs int GPS::prepareDeepSleep(void *unused) { - LOG_INFO("GPS deep sleep!"); + LOG_INFO("GPS deep sleep"); disable(); return 0; } @@ -1819,7 +1816,6 @@ GnssModel_t GPS::probe(int serialSpeed) break; } - LOG_DEBUG("Module Info : "); LOG_DEBUG("Soft version: %s", ublox_info.swVersion); LOG_DEBUG("Hard version: %s", ublox_info.hwVersion); LOG_DEBUG("Extensions:%d", ublox_info.extensionNo); @@ -1899,27 +1895,21 @@ GnssModel_t GPS::getProbeResponse(unsigned long timeout, const std::vector= 2 && response[responseLen - 2] == '\r' && response[responseLen - 1] == '\n') { -#ifdef GPS_DEBUG - LOG_DEBUG(response.get()); -#endif + LOG_DEBUG_GPS("%s", response.get()); // Reset the response buffer for the next potential message responseLen = 0; response[0] = '\0'; } } } -#ifdef GPS_DEBUG - LOG_DEBUG(response.get()); -#endif + LOG_DEBUG_GPS("%s", response.get()); return GNSS_MODEL_UNKNOWN; // Return unknown on timeout } @@ -2025,7 +2015,7 @@ std::unique_ptr GPS::createGps() #endif #if defined(SENSECAP_INDICATOR) - LOG_DEBUG("Use the RP2040 tunnel for GPS, no local pins"); + LOG_DEBUG("Use RP2040 tunnel for GPS, no local pins"); #else LOG_DEBUG("Use GPIO%d for GPS RX", new_gps->rx_gpio); LOG_DEBUG("Use GPIO%d for GPS TX", new_gps->tx_gpio); @@ -2120,10 +2110,10 @@ bool GPS::lookForLocation() #ifndef TINYGPS_OPTION_NO_STATISTICS if (reader.failedChecksum() > lastChecksumFailCount) { // In a GPS_DEBUG build we want to log all of these. In production, we only care if there are many of them. -#ifndef GPS_DEBUG +#if !GPS_DEBUG if (reader.failedChecksum() > 4) #endif - LOG_WARN("%u new GPS checksum failures, for a total of %u", reader.failedChecksum() - lastChecksumFailCount, + LOG_WARN("%u new GPS checksum failures, total %u", reader.failedChecksum() - lastChecksumFailCount, reader.failedChecksum()); lastChecksumFailCount = reader.failedChecksum(); } @@ -2137,7 +2127,7 @@ bool GPS::lookForLocation() if (!hasLock()) return false; -#ifdef GPS_DEBUG +#if GPS_DEBUG LOG_DEBUG("AGE: LOC=%d FIX=%d DATE=%d TIME=%d", reader.location.age(), #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS gsafixtype.age(), @@ -2159,7 +2149,7 @@ bool GPS::lookForLocation() (gsafixtype.age() < GPS_SOL_EXPIRY_MS) && #endif (reader.time.age() < GPS_SOL_EXPIRY_MS) && (reader.date.age() < GPS_SOL_EXPIRY_MS))) { - LOG_WARN("SOME data is TOO OLD: LOC %u, TIME %u, DATE %u", reader.location.age(), reader.time.age(), reader.date.age()); + LOG_WARN("SOME data TOO OLD: LOC %u, TIME %u, DATE %u", reader.location.age(), reader.time.age(), reader.date.age()); return false; } @@ -2168,15 +2158,11 @@ bool GPS::lookForLocation() // Bail out EARLY to avoid overwriting previous good data (like #857) if (toDegInt(loc.lat) > 900000000) { -#ifdef GPS_DEBUG - LOG_DEBUG("Bail out EARLY on LAT %i", toDegInt(loc.lat)); -#endif + LOG_DEBUG_GPS("Bail out EARLY on LAT %i", toDegInt(loc.lat)); return false; } if (toDegInt(loc.lng) > 1800000000) { -#ifdef GPS_DEBUG - LOG_DEBUG("Bail out EARLY on LNG %i", toDegInt(loc.lng)); -#endif + LOG_DEBUG_GPS("Bail out EARLY on LNG %i", toDegInt(loc.lng)); return false; } @@ -2261,7 +2247,7 @@ bool GPS::whileActive() { unsigned int charsInBuf = 0; bool isValid = false; -#ifdef GPS_DEBUG +#if GPS_DEBUG std::string debugmsg = ""; #endif if (powerState != GPS_ACTIVE) { @@ -2270,7 +2256,7 @@ bool GPS::whileActive() } #ifdef SERIAL_BUFFER_SIZE if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) { - LOG_WARN("GPS Buffer full with %u bytes waiting. Flush to avoid corruption", _serial_gps->available()); + LOG_WARN("GPS Buffer full (%u bytes). Flush to avoid corruption", _serial_gps->available()); clearBuffer(); } #endif @@ -2278,7 +2264,7 @@ bool GPS::whileActive() while (_serial_gps->available() > 0) { int c = _serial_gps->read(); UBXscratch[charsInBuf] = c; -#ifdef GPS_DEBUG +#if GPS_DEBUG debugmsg += vformat("%c", (c >= 32 && c <= 126) ? c : '.'); #endif isValid |= reader.encode(c); @@ -2291,9 +2277,9 @@ bool GPS::whileActive() charsInBuf++; } } -#ifdef GPS_DEBUG +#if GPS_DEBUG if (debugmsg != "") { - LOG_DEBUG(debugmsg.c_str()); + LOG_DEBUG("%s", debugmsg.c_str()); } #endif return isValid; diff --git a/src/gps/GPSLog.h b/src/gps/GPSLog.h new file mode 100644 index 0000000000..9ee85096d9 --- /dev/null +++ b/src/gps/GPSLog.h @@ -0,0 +1,14 @@ +#pragma once + +#include "DebugConfiguration.h" + +// GPS_DEBUG=1 enables verbose GNSS diagnostics (probe/ACK byte dumps, pin states, NMEA ages). +// Costs no flash when off. Genuine LOG_WARN anomalies stay unconditional. +#ifndef GPS_DEBUG +#define GPS_DEBUG 0 +#endif +#if GPS_DEBUG +#define LOG_DEBUG_GPS(...) LOG_DEBUG(__VA_ARGS__) +#else +#define LOG_DEBUG_GPS(...) ((void)0) +#endif diff --git a/src/gps/GPSUpdateScheduling.cpp b/src/gps/GPSUpdateScheduling.cpp index a19d9c7d57..fe2c3ae78a 100644 --- a/src/gps/GPSUpdateScheduling.cpp +++ b/src/gps/GPSUpdateScheduling.cpp @@ -2,6 +2,31 @@ #include "Default.h" +// Sampled from the original `2750 * seconds^1.22` curve. Interpolation tracks it within 0.6% for +// inputs >=10s and 1.7% below that; the 1s/2s/3s points keep the convex first segment from +// overshooting (a 0s-to-5s chord reads 42% high at 1s). +static constexpr uint32_t kThresholdCurveSecs[] = {0, 1, 2, 3, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 240, 300, 450, 600, 900}; +static constexpr uint32_t kThresholdCurveMs[] = {0, 2750, 6406, 10506, 19592, 45639, 74845, + 106314, 174350, 285925, 406141, 666053, 946093, 1551548, + 2203893, 2893481, 4745172, 6740269, 11053722}; +static constexpr size_t kThresholdCurvePoints = sizeof(kThresholdCurveSecs) / sizeof(kThresholdCurveSecs[0]); + +// How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than +// GPS_SOFTSLEEP? Avoids pow() so this heuristic doesn't pull double-precision libm into the image. +uint32_t gpsHardsleepThresholdMs(uint32_t predictedSearchSecs) +{ + if (predictedSearchSecs >= kThresholdCurveSecs[kThresholdCurvePoints - 1]) + return kThresholdCurveMs[kThresholdCurvePoints - 1]; + + size_t i = 1; + while (kThresholdCurveSecs[i] < predictedSearchSecs) + i++; + + uint32_t x0 = kThresholdCurveSecs[i - 1], x1 = kThresholdCurveSecs[i]; + uint32_t y0 = kThresholdCurveMs[i - 1], y1 = kThresholdCurveMs[i]; + return y0 + (uint32_t)((uint64_t)(y1 - y0) * (predictedSearchSecs - x0) / (x1 - x0)); +} + // Mark the time when searching for GPS position begins void GPSUpdateScheduling::informSearching() { diff --git a/src/gps/GPSUpdateScheduling.h b/src/gps/GPSUpdateScheduling.h index 120605c4ef..d7609d704e 100644 --- a/src/gps/GPSUpdateScheduling.h +++ b/src/gps/GPSUpdateScheduling.h @@ -2,6 +2,10 @@ #include "configuration.h" +// Approximates the GPS_HARDSLEEP/GPS_SOFTSLEEP crossover curve without pow(); see .cpp for the +// sampled reference values it interpolates between. +uint32_t gpsHardsleepThresholdMs(uint32_t predictedSearchSecs); + // Encapsulates code responsible for the timing of GPS updates class GPSUpdateScheduling { diff --git a/src/gps/GeoCoord.cpp b/src/gps/GeoCoord.cpp index 4afae9394d..1fc60c3049 100644 --- a/src/gps/GeoCoord.cpp +++ b/src/gps/GeoCoord.cpp @@ -1,4 +1,5 @@ #include "GeoCoord.h" +#include "configuration.h" #include // Narrow a UTM meter value to its unsigned field, clamping non-finite/negative/oversized inputs: an @@ -433,6 +434,43 @@ void GeoCoord::convertWGS84ToOSGB36(const double lat, const double lon, double & //(airyA*airyA/(airyA / sqrt(1 - airyEcc*sin(osgb.latitude)*sin(osgb.latitude)))); // Not used, no OSTN data } +#if MESHTASTIC_TRIG_APPROX +// cos(x) minimax approx for x in [-pi/2, pi/2] ("cos_52"): https://www.ganssle.com/approx.htm +static double cosLatitudeApprox(double latRad) +{ + constexpr double c1 = 0.9999932946, c2 = -0.4999124376, c3 = 0.0414877472, c4 = -0.0012712095; + double x2 = latRad * latRad; + return c1 + x2 * (c2 + x2 * (c3 + c4 * x2)); +} + +/// Approximate distance in meters via equirectangular projection (not exact spherical trig). +/// <1% error to ~500km, degrading near the poles at long range (see test_geocoord_distance). +float GeoCoord::latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b) +{ + // Don't do math if the points are the same + if (lat_a == lat_b && lng_a == lng_b) + return 0.0; + + double a1 = lat_a / DEG_CONVERT; + double a2 = lng_a / DEG_CONVERT; + double b1 = lat_b / DEG_CONVERT; + double b2 = lng_b / DEG_CONVERT; + + double meanLat = (a1 + b1) / 2; + double dLng = b2 - a2; + // Wrap to [-PI, PI]: unlike cos()/sin(), a raw longitude difference doesn't handle points that + // straddle the antimeridian (e.g. 179.9 and -179.9 are ~0.2 degrees apart, not ~360). + if (dLng > PI) + dLng -= 2 * PI; + else if (dLng < -PI) + dLng += 2 * PI; + double x = dLng * cosLatitudeApprox(meanLat); + double y = b1 - a1; + double tt = sqrt(x * x + y * y); + + return (float)(6366000 * tt); +} +#else /// Ported from my old java code, returns distance in meters along the globe /// surface (by Haversine formula) float GeoCoord::latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b) @@ -456,6 +494,7 @@ float GeoCoord::latLongToMeter(double lat_a, double lng_a, double lat_b, double return (float)(6366000 * tt); } +#endif /** * Computes the bearing in degrees between two points on Earth. Ported from my diff --git a/src/gps/RTC.cpp b/src/gps/RTC.cpp index 1559e5e276..5c18cca623 100644 --- a/src/gps/RTC.cpp +++ b/src/gps/RTC.cpp @@ -1,9 +1,12 @@ #include "gps/RTC.h" +#include "UptimeClock.h" #include "configuration.h" #include "detect/ScanI2C.h" #include "detect/ScanI2CTwoWire.h" +#include "gps/GPSLog.h" #include "main.h" #include "mesh/MeshService.h" +#include "mesh/NodeDB.h" #include "modules/NodeInfoModule.h" #include #include @@ -22,12 +25,15 @@ static const uint32_t TIME_VALIDATION_WARNING_INTERVAL_MS = 15000; // 15 seconds static void onTimeSourceQualityChanged(RTCQuality oldQuality, RTCQuality newQuality) { if (oldQuality == RTCQualityNone && newQuality > RTCQualityNone && nodeInfoModule) { - LOG_DEBUG("Time source acquired (%s -> %s), triggering NodeInfo recheck", RtcName(oldQuality), RtcName(newQuality)); + LOG_DEBUG("Time source acquired (%s -> %s), recheck NodeInfo", RtcName(oldQuality), RtcName(newQuality)); nodeInfoModule->triggerImmediateNodeInfoCheck(); } - if (oldQuality < RTCQualityFromNet && newQuality >= RTCQualityFromNet && service) { + if (oldQuality < RTCQualityFromNet && newQuality >= RTCQualityFromNet) { LOG_DEBUG("RTC net quality reached (%s -> %s), reconciling rx_time", RtcName(oldQuality), RtcName(newQuality)); - service->reconcilePendingRxTimes(); + if (service) + service->reconcilePendingRxTimes(); + if (nodeDB) + nodeDB->backfillHeardAt(); } } @@ -37,8 +43,9 @@ RTCQuality getRTCQuality() } // stuff that really should be in in the instance instead... -static uint32_t - timeStartMsec; // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time +// The Time::getMillisMonotonic() instant corresponding to zeroOffsetSecs. 64-bit so getTime()'s +// elapsed term cannot wrap: a 32-bit anchor walks the wall clock back 49.7 days per millis() cycle. +static uint64_t timeStartMs64; static uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock #ifdef PIO_UNIT_TESTING @@ -70,14 +77,14 @@ static struct timeval mockSystemTime = {}; { struct timeval tv; if (readSystemTime(&tv)) { - uint32_t now = millis(); + const uint64_t now = Time::getMillisMonotonic(); uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms if (currentQuality == RTCQualityNone) { LOG_DEBUG("Seed time from system clock: %lu", (unsigned long)printableEpoch); - timeStartMsec = now; + timeStartMs64 = now; zeroOffsetSecs = tv.tv_sec; } else { - LOG_DEBUG("Ignore system clock fallback (%lu); current RTC quality is %s", (unsigned long)printableEpoch, + LOG_DEBUG("Ignore system clock fallback (%lu); RTC quality is %s", (unsigned long)printableEpoch, RtcName(currentQuality)); } return RTCSetResultSuccess; @@ -100,7 +107,7 @@ RTCSetResult readFromRTC() [[maybe_unused]] struct timeval tv; /* btw settimeofday() is helpful here too*/ #ifdef RV3028_RTC if (rtc_found.address == RV3028_RTC) { - uint32_t now = millis(); + const uint64_t now = Time::getMillisMonotonic(); Melopero_RV3028 rtc; #if WIRE_INTERFACES_COUNT == 2 rtc.initI2C(*ScanI2CTwoWire::fetchI2CBus(rtc_found)); @@ -121,24 +128,24 @@ RTCSetResult readFromRTC() #ifdef BUILD_EPOCH if (tv.tv_sec < BUILD_EPOCH) { if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) { - LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH); + LOG_WARN("Ignore time (%ld) before build epoch (%ld)", printableEpoch, BUILD_EPOCH); } return RTCSetResultInvalidTime; } #endif - LOG_DEBUG("Read RTC time from RV3028 getTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900, t.tm_mon + 1, - t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch); + LOG_DEBUG_GPS("RTC time from RV3028 getTime: %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900, t.tm_mon + 1, + t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch); if (currentQuality == RTCQualityNone) { RTCQuality oldQuality = currentQuality; - timeStartMsec = now; + timeStartMs64 = now; zeroOffsetSecs = tv.tv_sec; currentQuality = RTCQualityDevice; onTimeSourceQualityChanged(oldQuality, currentQuality); } return RTCSetResultSuccess; } else { - LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address); + LOG_WARN("RTC read: not found (addr 0x%02X)", rtc_found.address); } #elif defined(PCF8563_RTC) || defined(PCF85063_RTC) #if defined(PCF8563_RTC) @@ -149,7 +156,7 @@ RTCSetResult readFromRTC() SensorPCF85063 rtc; #endif - uint32_t now = millis(); + const uint64_t now = Time::getMillisMonotonic(); #if WIRE_INTERFACES_COUNT == 2 rtc.begin(*ScanI2CTwoWire::fetchI2CBus(rtc_found)); @@ -166,29 +173,29 @@ RTCSetResult readFromRTC() #ifdef BUILD_EPOCH if (tv.tv_sec < BUILD_EPOCH) { if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) { - LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH); + LOG_WARN("Ignore time (%ld) before build epoch (%ld)", printableEpoch, BUILD_EPOCH); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; } #endif - LOG_DEBUG("Read RTC time from %s getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", rtc.getChipName(), t.tm_year + 1900, - t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch); + LOG_DEBUG_GPS("RTC time from %s getDateTime: %02d-%02d-%02d %02d:%02d:%02d (%ld)", rtc.getChipName(), t.tm_year + 1900, + t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch); if (currentQuality == RTCQualityNone) { RTCQuality oldQuality = currentQuality; - timeStartMsec = now; + timeStartMs64 = now; zeroOffsetSecs = tv.tv_sec; currentQuality = RTCQualityDevice; onTimeSourceQualityChanged(oldQuality, currentQuality); } return RTCSetResultSuccess; } else { - LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address); + LOG_WARN("RTC read: not found (addr 0x%02X)", rtc_found.address); } #elif defined(RX8130CE_RTC) if (rtc_found.address == RX8130CE_RTC) { - uint32_t now = millis(); + const uint64_t now = Time::getMillisMonotonic(); #ifdef MUZI_BASE ArtronShop_RX8130CE rtc(&Wire1); #else @@ -200,12 +207,12 @@ RTCSetResult readFromRTC() tv.tv_usec = 0; uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms - LOG_DEBUG("Read RTC time from RX8130CE getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900, - t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch); + LOG_DEBUG_GPS("RTC time from RX8130CE getDateTime: %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900, + t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch); #ifdef BUILD_EPOCH if (tv.tv_sec < BUILD_EPOCH) { if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) { - LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH); + LOG_WARN("Ignore time (%ld) before build epoch (%ld)", printableEpoch, BUILD_EPOCH); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; @@ -213,7 +220,7 @@ RTCSetResult readFromRTC() #endif if (currentQuality == RTCQualityNone) { RTCQuality oldQuality = currentQuality; - timeStartMsec = now; + timeStartMs64 = now; zeroOffsetSecs = tv.tv_sec; currentQuality = RTCQualityDevice; onTimeSourceQualityChanged(oldQuality, currentQuality); @@ -223,14 +230,14 @@ RTCSetResult readFromRTC() } #elif HAS_LSE if (stm32wlRtcAvailable()) { - uint32_t now = millis(); + const uint64_t now = Time::getMillisMonotonic(); tv.tv_sec = STM32RTC::getInstance().getEpoch(); tv.tv_usec = 0; uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms #ifdef BUILD_EPOCH if (tv.tv_sec < BUILD_EPOCH) { if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) { - LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH); + LOG_WARN("Ignore time (%ld) before build epoch (%ld)", printableEpoch, BUILD_EPOCH); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; @@ -238,7 +245,7 @@ RTCSetResult readFromRTC() #endif if (currentQuality == RTCQualityNone) { RTCQuality oldQuality = currentQuality; - timeStartMsec = now; + timeStartMs64 = now; zeroOffsetSecs = tv.tv_sec; currentQuality = RTCQualityDevice; onTimeSourceQualityChanged(oldQuality, currentQuality); @@ -263,12 +270,13 @@ RTCSetResult readFromRTC() RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpdate) { static uint32_t lastSetMsec = 0; - uint32_t now = millis(); + const uint64_t now64 = Time::getMillisMonotonic(); + const uint32_t now = (uint32_t)now64; // low word == getMillis(); fine for the Throttle-checked stamps below uint32_t printableEpoch = tv->tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms #ifdef BUILD_EPOCH if (tv->tv_sec < BUILD_EPOCH) { if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) { - LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH); + LOG_WARN("Ignore time (%ld) before build epoch (%ld)", printableEpoch, BUILD_EPOCH); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; @@ -277,8 +285,8 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd // Calculate max allowed time safely to avoid overflow in logging uint64_t maxAllowedTime = (uint64_t)BUILD_EPOCH + FORTY_YEARS; uint32_t maxAllowedPrintable = (maxAllowedTime > UINT32_MAX) ? UINT32_MAX : (uint32_t)maxAllowedTime; - LOG_WARN("Ignore time (%ld) too far in the future (build epoch: %ld, max allowed: %ld)!", printableEpoch, - (uint32_t)BUILD_EPOCH, maxAllowedPrintable); + LOG_WARN("Ignore time (%ld) too far in future (build epoch: %ld, max: %ld)", printableEpoch, (uint32_t)BUILD_EPOCH, + maxAllowedPrintable); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; @@ -288,21 +296,20 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd bool shouldSet; if (forceUpdate) { shouldSet = true; - LOG_DEBUG("Override current RTC quality (%s) with incoming time of RTC quality of %s", RtcName(currentQuality), - RtcName(q)); + LOG_DEBUG("Override RTC quality (%s) with incoming quality %s", RtcName(currentQuality), RtcName(q)); } else if (q > currentQuality) { shouldSet = true; LOG_DEBUG("Upgrade time to quality %s", RtcName(q)); } else if (q == RTCQualityGPS) { shouldSet = true; - LOG_DEBUG("Reapply GPS time: %ld secs", printableEpoch); + LOG_DEBUG_GPS("Reapply GPS time: %ld secs", printableEpoch); } else if (q == RTCQualityNTP && !Throttle::isWithinTimespanMs(lastSetMsec, (30 * 60 * 1000UL))) { // Every 30 minutes we will slam in a new NTP or Phone GPS / NTP time, to correct for local RTC clock drift shouldSet = true; - LOG_DEBUG("Reapply external time to correct clock drift %ld secs", printableEpoch); + LOG_DEBUG_GPS("Reapply external time to fix clock drift %ld secs", printableEpoch); } else { shouldSet = false; - LOG_DEBUG("Current RTC quality: %s. Ignore time of RTC quality of %s", RtcName(currentQuality), RtcName(q)); + LOG_DEBUG_GPS("RTC quality: %s. Ignore time of quality %s", RtcName(currentQuality), RtcName(q)); } if (shouldSet) { @@ -314,7 +321,7 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd } // This delta value works on all platforms - timeStartMsec = now; + timeStartMs64 = now64; zeroOffsetSecs = tv->tv_sec; // If this platform has a settable RTC, set it #ifdef RV3028_RTC @@ -328,12 +335,12 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd // tv_sec is a long, which is not time_t everywhere: on Windows // time_t is 64-bit while long is 32-bit. Copy before taking &. time_t setSecs = tv->tv_sec; - tm *t = gmtime(&setSecs); + const tm *t = gmtime(&setSecs); rtc.setTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_wday, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); - LOG_DEBUG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, - t->tm_hour, t->tm_min, t->tm_sec, printableEpoch); + LOG_DEBUG_GPS("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, + t->tm_hour, t->tm_min, t->tm_sec, printableEpoch); } else { - LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address); + LOG_WARN("RTC set: not found (addr 0x%02X)", rtc_found.address); } #elif defined(PCF8563_RTC) || defined(PCF85063_RTC) #if defined(PCF8563_RTC) @@ -353,12 +360,12 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd // tv_sec is a long, which is not time_t everywhere: on Windows // time_t is 64-bit while long is 32-bit. Copy before taking &. time_t setSecs = tv->tv_sec; - tm *t = gmtime(&setSecs); + const tm *t = gmtime(&setSecs); rtc.setDateTime(*t); - LOG_DEBUG("%s setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", rtc.getChipName(), t->tm_year + 1900, t->tm_mon + 1, - t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch); + LOG_DEBUG_GPS("%s setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", rtc.getChipName(), t->tm_year + 1900, + t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch); } else { - LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address); + LOG_WARN("RTC set: not found (addr 0x%02X)", rtc_found.address); } #elif defined(RX8130CE_RTC) if (rtc_found.address == RX8130CE_RTC) { @@ -370,12 +377,12 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd // tv_sec is a long, which is not time_t everywhere: on Windows // time_t is 64-bit while long is 32-bit. Copy before taking &. time_t setSecs = tv->tv_sec; - tm *t = gmtime(&setSecs); + const tm *t = gmtime(&setSecs); if (rtc.setTime(*t)) { - LOG_DEBUG("RX8130CE setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, - t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch); + LOG_DEBUG_GPS("RX8130CE setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, + t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch); } else { - LOG_WARN("Failed to set time for RX8130CE"); + LOG_WARN("RX8130CE set time failed"); } } #elif HAS_LSE @@ -435,7 +442,7 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct tm &t) #ifdef BUILD_EPOCH if (tv.tv_sec < BUILD_EPOCH) { if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) { - LOG_WARN("Ignore time (%lu) before build epoch (%lu)!", printableEpoch, BUILD_EPOCH); + LOG_WARN("Ignore time (%lu) before build epoch (%lu)", printableEpoch, BUILD_EPOCH); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; @@ -444,8 +451,8 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct tm &t) // Calculate max allowed time safely to avoid overflow in logging uint64_t maxAllowedTime = (uint64_t)BUILD_EPOCH + FORTY_YEARS; uint32_t maxAllowedPrintable = (maxAllowedTime > UINT32_MAX) ? UINT32_MAX : (uint32_t)maxAllowedTime; - LOG_WARN("Ignore time (%lu) too far in the future (build epoch: %lu, max allowed: %lu)!", printableEpoch, - (uint32_t)BUILD_EPOCH, maxAllowedPrintable); + LOG_WARN("Ignore time (%lu) too far in future (build epoch: %lu, max: %lu)", printableEpoch, (uint32_t)BUILD_EPOCH, + maxAllowedPrintable); lastTimeValidationWarning = millis(); } return RTCSetResultInvalidTime; @@ -486,10 +493,12 @@ int32_t getTZOffset() */ uint32_t getTime(bool local) { + // Both terms are 64-bit monotonic, so the elapsed time cannot wrap - see timeStartMs64. + const uint64_t elapsedSecs = (Time::getMillisMonotonic() - timeStartMs64) / 1000; if (local) { - return (((uint32_t)millis() - timeStartMsec) / 1000) + zeroOffsetSecs + getTZOffset(); + return elapsedSecs + zeroOffsetSecs + getTZOffset(); } else { - return (((uint32_t)millis() - timeStartMsec) / 1000) + zeroOffsetSecs; + return elapsedSecs + zeroOffsetSecs; } } @@ -509,7 +518,7 @@ void setBootRelativeTimeForUnitTest(uint32_t secondsSinceBoot) { currentQuality = RTCQualityNone; zeroOffsetSecs = 0; - timeStartMsec = millis() - (secondsSinceBoot * 1000); + timeStartMs64 = Time::getMillisMonotonic() - ((uint64_t)secondsSinceBoot * 1000); lastSetFromPhoneNtpOrGps = 0; lastTimeValidationWarning = 0; } @@ -538,7 +547,7 @@ void setReadFromRTCUseSystemTimeForTests(bool enabled) void resetRTCStateForTests() { currentQuality = RTCQualityNone; - timeStartMsec = 0; + timeStartMs64 = 0; zeroOffsetSecs = 0; lastSetFromPhoneNtpOrGps = 0; lastTimeValidationWarning = 0; diff --git a/src/graphics/EInkDisplay2.cpp b/src/graphics/EInkDisplay2.cpp index a44e8ef4b3..dca31be605 100644 --- a/src/graphics/EInkDisplay2.cpp +++ b/src/graphics/EInkDisplay2.cpp @@ -99,7 +99,6 @@ bool EInkDisplay::forceDisplay(uint32_t msecLimit) // End the update process endUpdate(); - LOG_DEBUG("done"); return true; } diff --git a/src/graphics/EInkDynamicDisplay.cpp b/src/graphics/EInkDynamicDisplay.cpp index a48ba5c939..c51f0a5bba 100644 --- a/src/graphics/EInkDynamicDisplay.cpp +++ b/src/graphics/EInkDynamicDisplay.cpp @@ -157,7 +157,7 @@ bool EInkDynamicDisplay::determineMode() resetRateLimiting(); // Once determineMode() ends, will have to wait again hashImage(); // Generate here, so we can still copy it to previousImageHash, even if we skip the comparison check - LOG_DEBUG("determineMode(): "); // Begin log entry + LOG_TRACE("determineMode(): "); // Begin log entry // Once mode determined, any remaining checks will bypass checkCosmetic(); @@ -232,9 +232,7 @@ void EInkDynamicDisplay::checkForPromotion() // Is it too soon for another frame of this type? void EInkDynamicDisplay::checkRateLimiting() { - // Sanity check: millis() overflow - just let the update run.. - if (previousRunMs > millis()) - return; + // No millis()-overflow guard needed: the Throttle checks below are wrap-correct already. // Skip update: too soon for BACKGROUND if (frameFlags == BACKGROUND) { @@ -254,7 +252,7 @@ void EInkDynamicDisplay::checkRateLimiting() if (Throttle::isWithinTimespanMs(previousRunMs, 1000)) { refresh = SKIPPED; reason = EXCEEDED_RATELIMIT_FAST; - LOG_DEBUG("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x", frameFlags); return; } } @@ -271,7 +269,7 @@ void EInkDynamicDisplay::checkCosmetic() if (frameFlags & COSMETIC) { refresh = FULL; reason = FLAGGED_COSMETIC; - LOG_DEBUG("refresh=FULL, reason=FLAGGED_COSMETIC, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=FULL, reason=FLAGGED_COSMETIC, frameFlags=0x%x", frameFlags); } } @@ -286,7 +284,7 @@ void EInkDynamicDisplay::checkDemandingFast() if (frameFlags & DEMAND_FAST) { refresh = FAST; reason = FLAGGED_DEMAND_FAST; - LOG_DEBUG("refresh=FAST, reason=FLAGGED_DEMAND_FAST, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=FAST, reason=FLAGGED_DEMAND_FAST, frameFlags=0x%x", frameFlags); } } @@ -306,7 +304,7 @@ void EInkDynamicDisplay::checkFrameMatchesPrevious() if (frameFlags == BACKGROUND && fastRefreshCount > 0) { refresh = FULL; reason = REDRAW_WITH_FULL; - LOG_DEBUG("refresh=FULL, reason=REDRAW_WITH_FULL, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=FULL, reason=REDRAW_WITH_FULL, frameFlags=0x%x", frameFlags); return; } #endif @@ -314,7 +312,7 @@ void EInkDynamicDisplay::checkFrameMatchesPrevious() // Not redrawn, not COSMETIC, not DEMAND_FAST refresh = SKIPPED; reason = FRAME_MATCHED_PREVIOUS; - LOG_DEBUG("refresh=SKIPPED, reason=FRAME_MATCHED_PREVIOUS, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=SKIPPED, reason=FRAME_MATCHED_PREVIOUS, frameFlags=0x%x", frameFlags); } // Have too many fast-refreshes occurred consecutively, since last full refresh? @@ -328,7 +326,7 @@ void EInkDynamicDisplay::checkConsecutiveFastRefreshes() if (frameFlags & UNLIMITED_FAST) { refresh = FAST; reason = NO_OBJECTIONS; - LOG_DEBUG("refresh=FAST, reason=UNLIMITED_FAST_MODE_ACTIVE, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=FAST, reason=UNLIMITED_FAST_MODE_ACTIVE, frameFlags=0x%x", frameFlags); return; } @@ -336,7 +334,7 @@ void EInkDynamicDisplay::checkConsecutiveFastRefreshes() if (fastRefreshCount >= EINK_LIMIT_FASTREFRESH) { refresh = FULL; reason = EXCEEDED_LIMIT_FASTREFRESH; - LOG_DEBUG("refresh=FULL, reason=EXCEEDED_LIMIT_FASTREFRESH, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=FULL, reason=EXCEEDED_LIMIT_FASTREFRESH, frameFlags=0x%x", frameFlags); } } @@ -351,13 +349,13 @@ void EInkDynamicDisplay::checkFastRequested() // If we want BACKGROUND to use fast. (FULL only when a limit is hit) refresh = FAST; reason = BACKGROUND_USES_FAST; - LOG_DEBUG("refresh=FAST, reason=BACKGROUND_USES_FAST, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount, + LOG_TRACE("refresh=FAST, reason=BACKGROUND_USES_FAST, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount, frameFlags); #else // If we do want to use FULL for BACKGROUND updates refresh = FULL; reason = FLAGGED_BACKGROUND; - LOG_DEBUG("refresh=FULL, reason=FLAGGED_BACKGROUND"); + LOG_TRACE("refresh=FULL, reason=FLAGGED_BACKGROUND"); #endif } @@ -365,7 +363,7 @@ void EInkDynamicDisplay::checkFastRequested() if (frameFlags & RESPONSIVE) { refresh = FAST; reason = NO_OBJECTIONS; - LOG_DEBUG("refresh=FAST, reason=NO_OBJECTIONS, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount, frameFlags); + LOG_TRACE("refresh=FAST, reason=NO_OBJECTIONS, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount, frameFlags); } } @@ -430,7 +428,7 @@ void EInkDynamicDisplay::countGhostPixels() } } - LOG_DEBUG("ghostPixels=%hu, ", ghostPixelCount); + LOG_TRACE("ghostPixels=%hu, ", ghostPixelCount); } // Check if ghost pixel count exceeds the defined limit @@ -446,7 +444,7 @@ void EInkDynamicDisplay::checkExcessiveGhosting() if (ghostPixelCount > EINK_LIMIT_GHOSTING_PX) { refresh = FULL; reason = EXCEEDED_GHOSTINGLIMIT; - LOG_DEBUG("refresh=FULL, reason=EXCEEDED_GHOSTINGLIMIT, frameFlags=0x%x", frameFlags); + LOG_TRACE("refresh=FULL, reason=EXCEEDED_GHOSTINGLIMIT, frameFlags=0x%x", frameFlags); } } diff --git a/src/graphics/Screen.cpp b/src/graphics/Screen.cpp index f1d8f33fa9..c8271ddf13 100644 --- a/src/graphics/Screen.cpp +++ b/src/graphics/Screen.cpp @@ -430,7 +430,7 @@ void Screen::showAlphanumericPicker(const char *message, const char *initialText void Screen::showTextInput(const char *header, const char *initialText, uint32_t durationMs, std::function textCallback) { - LOG_INFO("showTextInput called with header='%s', durationMs=%d", header ? header : "NULL", durationMs); + LOG_INFO("showTextInput header='%s', durationMs=%d", header ? header : "NULL", durationMs); // Start OnScreenKeyboardModule session (non-touch variant) OnScreenKeyboardModule::instance().start(header, initialText, durationMs, textCallback); @@ -581,7 +581,7 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O #elif defined(USE_SPISSD1306) dispdev = new SSD1306Spi(SSD1306_RESET, SSD1306_RS, SSD1306_NSS, GEOMETRY_64_48); if (!dispdev->init()) { - LOG_DEBUG("Error: SSD1306 not detected!"); + LOG_DEBUG("SSD1306 not detected"); } else { static_cast(dispdev)->setHorizontalOffset(32); LOG_INFO("SSD1306 init success"); @@ -592,14 +592,14 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O // runtime via config.yaml Display: Panel: HUB75. if (portduino_config.displayPanel == hub75) { #if defined(HAS_HUB75_NATIVE) - LOG_DEBUG("Make HUB75Native!"); + LOG_DEBUG("Make HUB75Native"); dispdev = new HUB75Native(address.address, -1, -1, GEOMETRY_RAWMODE, HW_I2C::I2C_ONE); #else - LOG_ERROR("HUB75 panel requested but rpi-rgb-led-matrix not compiled in!"); + LOG_ERROR("HUB75 panel requested but rpi-rgb-led-matrix not compiled in"); #endif } else if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) { if (portduino_config.displayPanel != no_screen) { - LOG_DEBUG("Make TFTDisplay!"); + LOG_DEBUG("Make TFTDisplay"); dispdev = new TFTDisplay(address.address, -1, -1, geometry, (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE); } else { @@ -610,7 +610,7 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O } } #elif USE_TFTDISPLAY - LOG_DEBUG("Make TFTDisplay!"); + LOG_DEBUG("Make TFTDisplay"); dispdev = new TFTDisplay(address.address, -1, -1, geometry, (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE); #elif defined(USE_EINK) && defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS) && !defined(MESHTASTIC_INCLUDE_INKHUD) @@ -1112,7 +1112,7 @@ int32_t Screen::runOnce() // Show boot screen for first logo_timeout seconds, then switch to normal operation. // serialSinceMsec adjusts for additional serial wait time during nRF52 bootup static bool showingBootScreen = true; - if (showingBootScreen && (millis() > (logo_timeout + serialSinceMsec))) { + if (showingBootScreen && Throttle::hasElapsed(serialSinceMsec, logo_timeout)) { LOG_INFO("Done with boot screen"); stopBootScreen(); showingBootScreen = false; @@ -1120,7 +1120,7 @@ int32_t Screen::runOnce() #ifdef USERPREFS_OEM_TEXT static bool showingOEMBootScreen = true; - if (showingOEMBootScreen && (millis() > ((logo_timeout / 2) + serialSinceMsec))) { + if (showingOEMBootScreen && Throttle::hasElapsed(serialSinceMsec, logo_timeout / 2)) { LOG_INFO("Switch to OEM screen..."); // Change frames. static FrameCallback bootOEMFrames[] = {graphics::UIRenderer::drawOEMBootScreen}; @@ -1271,7 +1271,7 @@ int32_t Screen::runOnce() EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); #endif - LOG_DEBUG("LastScreenTransition exceeded %ums transition to next frame", (millis() - lastScreenTransition)); + LOG_DEBUG("LastScreenTransition exceeded %ums, next frame", (millis() - lastScreenTransition)); handleOnPress(); } } diff --git a/src/graphics/TFTDisplay.cpp b/src/graphics/TFTDisplay.cpp index f67e35fce8..ba2d50320c 100644 --- a/src/graphics/TFTDisplay.cpp +++ b/src/graphics/TFTDisplay.cpp @@ -851,7 +851,7 @@ class LGFX : public lgfx::LGFX_Device #endif else { _panel_instance = new lgfx::Panel_NULL; - LOG_ERROR("Unknown display panel configured!"); + LOG_ERROR("Unknown display panel configured"); } auto buscfg = _bus_instance.config(); @@ -1187,7 +1187,7 @@ static inline uint16_t getThemeDefaultOffColor() TFTDisplay::TFTDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus) { - LOG_DEBUG("TFTDisplay!"); + LOG_DEBUG("TFTDisplay"); #ifdef TFT_BL GpioPin *p = new GpioHwPin(TFT_BL); @@ -1441,7 +1441,7 @@ void TFTDisplay::sdlLoop() if (portduino_config.displayPanel == x11) { lgfx::Panel_sdl *sdl_panel_ = (lgfx::Panel_sdl *)tft->_panel_instance; if (sdl_panel_->loop() && !shuttingDown) { - LOG_WARN("Window Closed!"); + LOG_WARN("Window Closed"); InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_SHUTDOWN, .kbchar = 0, .touchX = 0, .touchY = 0}; inputBroker->injectInputEvent(&event); } @@ -1625,9 +1625,9 @@ bool TFTDisplay::connect() #ifdef HACKADAY_COMMUNICATOR bool beginStatus = tft->begin(); if (beginStatus) - LOG_DEBUG("TFT Success!"); + LOG_DEBUG("TFT Success"); else - LOG_ERROR("TFT Fail!"); + LOG_ERROR("TFT Fail"); #else tft->init(); #endif @@ -1656,7 +1656,7 @@ bool TFTDisplay::connect() this->linePixelBuffer = (uint16_t *)malloc(sizeof(uint16_t) * displayWidth); if (!this->linePixelBuffer) { - LOG_ERROR("Not enough memory to create TFT line buffer\n"); + LOG_ERROR("Not enough memory to create TFT line buffer"); return false; } memaudit::add("display", sizeof(uint16_t) * displayWidth); @@ -1665,7 +1665,7 @@ bool TFTDisplay::connect() this->repaintChunkBuffer = (uint16_t *)malloc(sizeof(uint16_t) * displayWidth * kFullRepaintChunkRows); if (!this->repaintChunkBuffer) { - LOG_ERROR("Not enough memory to create TFT repaint chunk buffer\n"); + LOG_ERROR("Not enough memory to create TFT repaint chunk buffer"); return false; } memaudit::add("display", sizeof(uint16_t) * displayWidth * kFullRepaintChunkRows); diff --git a/src/graphics/draw/MenuHandler.cpp b/src/graphics/draw/MenuHandler.cpp index ff19e81bcc..f5cd21e1a5 100644 --- a/src/graphics/draw/MenuHandler.cpp +++ b/src/graphics/draw/MenuHandler.cpp @@ -20,6 +20,9 @@ #include "input/UpDownInterruptImpl1.h" #include "main.h" #include "mesh/Default.h" +#if HAS_LORA_FEM +#include "mesh/LoRaFEMInterface.h" +#endif #include "mesh/MeshTypes.h" #include "mesh/RadioLibInterface.h" #include "modules/AdminModule.h" @@ -139,12 +142,34 @@ uint8_t test_count = 0; void menuHandler::loraMenu() { - static const char *optionsArray[] = {"Back", "Device Role", "Radio Preset", "Frequency Slot", "LoRa Region"}; - enum optionsNumbers { Back = 0, DeviceRolePicker = 1, RadioPresetPicker = 2, FrequencySlot = 3, LoraPicker = 4 }; + static const char *optionsArray[] = { + "Back", + "Device Role", + "Radio Preset", + "Frequency Slot", + "LoRa Region", +#if HAS_LORA_FEM + "FEM LNA", +#endif + }; + enum optionsNumbers { + Back = 0, + DeviceRolePicker = 1, + RadioPresetPicker = 2, + FrequencySlot = 3, + LoraPicker = 4, +#if HAS_LORA_FEM + LoraFemLna = 5 +#endif + }; BannerOverlayOptions bannerOptions; bannerOptions.message = "LoRa Actions"; bannerOptions.optionsArrayPtr = optionsArray; +#if HAS_LORA_FEM + bannerOptions.optionsCount = loraFEMInterface.isLnaCanControl() ? 6 : 5; +#else bannerOptions.optionsCount = 5; +#endif bannerOptions.bannerCallback = [](int selected) -> void { if (selected == Back) { // No action @@ -157,6 +182,11 @@ void menuHandler::loraMenu() } else if (selected == LoraPicker) { menuHandler::menuQueue = menuHandler::LoraPicker; } +#if HAS_LORA_FEM + else if (selected == LoraFemLna) { + menuHandler::menuQueue = menuHandler::LoraFemLnaToggleMenu; + } +#endif }; screen->showOverlayBanner(bannerOptions); } @@ -193,7 +223,7 @@ static void applyLoraRegion(meshtastic_Config_LoRaConfig_RegionCode region, bool // flip the region right back. The user picked the region, so the preset follows it. const RegionInfo *newRegion = getRegion(region); if (config.lora.use_preset && !newRegion->supportsPreset(config.lora.modem_preset)) { - LOG_INFO("Preset %s not available in %s, using default %s", + LOG_INFO("Preset %s unavailable in %s, use default %s", DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false, true), newRegion->name, DisplayFormatters::getModemPresetDisplayName(newRegion->getDefaultPreset(), false, true)); config.lora.modem_preset = newRegion->getDefaultPreset(); @@ -319,7 +349,7 @@ void menuHandler::LoraRegionPicker(uint32_t duration) menuQueue = HamModeConfirm; screen->runNow(); } else if (owner.is_licensed) { - LOG_INFO("Licensed user chose a non-ham region; prompting to revert licensed mode"); + LOG_INFO("Licensed user chose non-ham region; prompt to revert licensed mode"); pendingRegion = selectedRegion; menuQueue = LicensedToNormalConfirm; screen->runNow(); @@ -439,10 +469,10 @@ void menuHandler::FrequencySlotPicker() if (denominator > 0.0) { numChannels = static_cast(round(numerator / denominator)); } else { - LOG_WARN("Invalid region configuration: non-positive channel spacing/width"); + LOG_WARN("Invalid region config: non-positive channel spacing/width"); } } else { - LOG_WARN("Region not set, cannot calculate number of channels"); + LOG_WARN("Region not set, can't calc channel count"); return; } @@ -944,7 +974,7 @@ void menuHandler::deleteMessagesMenu() // This only appears in non-ALL modes if (selected == DeleteThis) { - LOG_INFO("Deleting all messages in this thread"); + LOG_INFO("Deleting all messages in thread"); if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) { messageStore.deleteAllMessagesInChannel(ch); @@ -1792,7 +1822,7 @@ void menuHandler::resetNodeDBMenu() disableBluetooth(); rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000); } else if (selected == 2) { - LOG_INFO("Initiate node-db reset but keeping favorites"); + LOG_INFO("Initiate node-db reset, keep favorites"); nodeDB->resetNodes(1); disableBluetooth(); rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000); @@ -2359,7 +2389,7 @@ void menuHandler::removeFavoriteMenu() void menuHandler::traceRouteMenu() { screen->showNodePicker("Node to Trace", 30000, [](uint32_t nodenum) -> void { - LOG_INFO("Menu: Node picker selected node 0x%08x, traceRouteModule=%p", nodenum, traceRouteModule); + LOG_INFO("Menu: Node picker selected 0x%08x, traceRouteModule=%p", nodenum, traceRouteModule); if (traceRouteModule) { traceRouteModule->startTraceRoute(nodenum); } @@ -2804,6 +2834,49 @@ void menuHandler::messageBubblesMenu() screen->showOverlayBanner(bannerOptions); } +#if HAS_LORA_FEM +void menuHandler::LoRaFEMLNAToggleMenu() +{ + static const LoRaFEMLNAToggleOption femToggleOptions[] = { + {"Back", OptionsAction::Back}, + {"Enabled", OptionsAction::Select, meshtastic_Config_LoRaConfig_FEM_LNA_Mode_ENABLED}, + {"Disabled", OptionsAction::Select, meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED}, + }; + constexpr size_t toggleCount = sizeof(femToggleOptions) / sizeof(femToggleOptions[0]); + static std::array toggleLabels{}; + + auto bannerOptions = createStaticBannerOptions( + "FEM LNA", femToggleOptions, toggleLabels, [](const LoRaFEMLNAToggleOption &option, int) -> void { + if (option.action == OptionsAction::Back) { + menuQueue = LoraMenu; + screen->runNow(); + return; + } + + if (!option.hasValue || config.lora.fem_lna_mode == option.value) { + return; + } + + const bool enabled = option.value != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED; + config.lora.fem_lna_mode = option.value; + loraFEMInterface.setLNAEnable(enabled); + service->reloadConfig(SEGMENT_CONFIG); + LOG_INFO("FEM LNA %s", enabled ? "enabled" : "disabled"); + }); + + int initialSelection = 0; + for (size_t i = 0; i < toggleCount; ++i) { + if (femToggleOptions[i].hasValue && config.lora.fem_lna_mode == femToggleOptions[i].value) { + initialSelection = static_cast(i); + break; + } + } + bannerOptions.InitialSelected = initialSelection; + + screen->showOverlayBanner(bannerOptions); +} +#endif + void menuHandler::themeMenu() { // Build menu dynamically from the theme table. @@ -3013,6 +3086,11 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display) case LicensedToNormalConfirm: licensedToNormalConfirmMenu(); break; +#if HAS_LORA_FEM + case LoraFemLnaToggleMenu: + LoRaFEMLNAToggleMenu(); + break; +#endif } menuQueue = MenuNone; } diff --git a/src/graphics/draw/MenuHandler.h b/src/graphics/draw/MenuHandler.h index e05742f97f..311205e0aa 100644 --- a/src/graphics/draw/MenuHandler.h +++ b/src/graphics/draw/MenuHandler.h @@ -59,7 +59,10 @@ class menuHandler MessageBubblesMenu, ThemeMenu, HamModeConfirm, - LicensedToNormalConfirm + LicensedToNormalConfirm, +#if HAS_LORA_FEM + LoraFemLnaToggleMenu +#endif }; static screenMenus menuQueue; static uint32_t pickedNodeNum; // node selected by NodePicker for ManageNodeMenu @@ -120,6 +123,9 @@ class menuHandler static void textMessageMenu(); static void hamModeConfirmMenu(); static void licensedToNormalConfirmMenu(); +#if HAS_LORA_FEM + static void LoRaFEMLNAToggleMenu(); +#endif // Lifted out of its banner-callback lambda so it is reachable without a Screen. The lambda only // ever runs via screen->showOverlayBanner(), which is why nothing here was unit-testable. @@ -159,6 +165,9 @@ using NodeNameOption = MenuOption; using PositionMenuOption = MenuOption; using ManageNodeOption = MenuOption; using ClockFaceOption = MenuOption; +#if HAS_LORA_FEM +using LoRaFEMLNAToggleOption = MenuOption; +#endif } // namespace graphics #endif diff --git a/src/graphics/draw/MessageRenderer.cpp b/src/graphics/draw/MessageRenderer.cpp index a6ae217e73..05a283b8ff 100644 --- a/src/graphics/draw/MessageRenderer.cpp +++ b/src/graphics/draw/MessageRenderer.cpp @@ -14,6 +14,7 @@ #include "graphics/TFTColorRegions.h" #include "graphics/TFTPalette.h" #include "graphics/TimeFormatters.h" +#include "graphics/draw/NotificationRenderer.h" #include "graphics/emotes.h" #include "main.h" #include "meshUtils.h" @@ -1128,6 +1129,9 @@ void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const mesht if (packet.from != 0) { hasUnreadMessage = true; const bool suppressBanner = cannedMessageModule && cannedMessageModule->isFreeTextActive(); + // Don't let the pop-up clobber a menu/picker the user is interacting with; the wake below + // still happens so a message can light the screen back up. + const bool menuShowing = NotificationRenderer::isMenuShowing(); // Determine if message belongs to a muted channel bool isChannelMuted = false; @@ -1222,7 +1226,7 @@ void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const mesht screen->setOn(true); } - if (!suppressBanner) { + if (!suppressBanner && !menuShowing) { screen->showSimpleBanner(banner, inThread ? 1000 : 3000); } } diff --git a/src/graphics/draw/NotificationRenderer.cpp b/src/graphics/draw/NotificationRenderer.cpp index 33d36535b2..7abfd210da 100644 --- a/src/graphics/draw/NotificationRenderer.cpp +++ b/src/graphics/draw/NotificationRenderer.cpp @@ -12,6 +12,7 @@ #include "graphics/images.h" #include "input/RotaryEncoderInterruptImpl1.h" #include "input/UpDownInterruptImpl1.h" +#include "mesh/Throttle.h" #if HAS_BUTTON #include "input/ButtonThread.h" #endif @@ -84,7 +85,7 @@ static inline graphics::NotificationRenderer::BannerFont parseFontTagPrefix(cons { // Tags must be at the start of the line: // [S] small, [M] medium, [L] large - if (p && p[0] == '[' && p[2] == ']' && p[1] != '\0') { + if (p && p[0] == '[' && p[1] != '\0' && p[2] == ']') { char t = p[1]; if (t == 'S') { p += 3; @@ -136,6 +137,26 @@ static inline uint8_t effectiveLineHeightForBannerLine(graphics::NotificationRen return (height > 3) ? (height - 3) : height; } +const char *graphics::NotificationRenderer::resolveBannerLine(uint16_t lineIndex, const char *rawLine, BannerFont &lineFont) +{ + lineFont = BANNER_FONT_DEFAULT; + bool tagAware = (current_notification_type == notificationTypeEnum::text_banner || + current_notification_type == notificationTypeEnum::pairing_pin) && + alertBannerOptions == 0; + if (!tagAware) + return rawLine; + if (lineIndex < alertBannerLineCount) { + lineFont = alertBannerLineFonts[lineIndex]; + return alertBannerLines[lineIndex]; + } + // The parsed-line cache doesn't cover this line (the banner text was stored without a + // re-parse, or a draw raced the parse from another task): strip the tag here too, so it + // acts as a font change and never renders as literal text - the BLE pair PIN banner + // prefixes its PIN line with [M]. + lineFont = parseFontTagPrefix(rawLine); + return rawLine; +} + void graphics::NotificationRenderer::parseBannerMessageWithFonts(const char *message) { alertBannerLineCount = 0; @@ -233,7 +254,7 @@ void NotificationRenderer::drawBannercallback(OLEDDisplay *display, OLEDDisplayU // Handle text_input notifications first - they have their own timeout/banner logic if (current_notification_type == notificationTypeEnum::text_input) { // Check for timeout and reset if needed for text input - if (millis() > alertBannerUntil && alertBannerUntil > 0) { + if (alertBannerUntil > 0 && Throttle::deadlinePassed(alertBannerUntil)) { resetBanner(); return; } @@ -241,7 +262,8 @@ void NotificationRenderer::drawBannercallback(OLEDDisplay *display, OLEDDisplayU return; } - if (millis() > alertBannerUntil && alertBannerUntil > 0) { + // 0 means "no deadline set", and reads as long expired - test it first. + if (alertBannerUntil > 0 && Throttle::deadlinePassed(alertBannerUntil)) { resetBanner(); } @@ -845,9 +867,6 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay BannerFont lineFonts[totalLines] = {}; uint8_t lineEffectiveHeights[totalLines] = {0}; const char *renderLines[totalLines] = {0}; - bool useTaggedBannerFonts = (current_notification_type == notificationTypeEnum::text_banner || - current_notification_type == notificationTypeEnum::pairing_pin) && - alertBannerOptions == 0; if (maxWidth != 0) is_picker = true; @@ -860,12 +879,8 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay uint16_t widestLineWithBars = 0; while (lines[lineCount] != nullptr) { - const char *renderText = lines[lineCount]; BannerFont lineFont = BANNER_FONT_DEFAULT; - if (useTaggedBannerFonts && lineCount < alertBannerLineCount) { - renderText = alertBannerLines[lineCount]; - lineFont = alertBannerLineFonts[lineCount]; - } + const char *renderText = resolveBannerLine(lineCount, lines[lineCount], lineFont); renderLines[lineCount] = renderText; lineFonts[lineCount] = lineFont; lineEffectiveHeights[lineCount] = effectiveLineHeightForBannerLine(lineFont); @@ -879,10 +894,10 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay if (current_notification_type == notificationTypeEnum::node_picker) { char measureBuffer[64] = {0}; - strncpy(measureBuffer, lines[lineCount], std::min(lineLengths[lineCount], sizeof(measureBuffer) - 1)); + strncpy(measureBuffer, renderText, std::min(lineLengths[lineCount], sizeof(measureBuffer) - 1)); lineWidths[lineCount] = UIRenderer::measureStringWithEmotes(display, measureBuffer); } else { - lineWidths[lineCount] = display->getStringWidth(lines[lineCount], lineLengths[lineCount], true); + lineWidths[lineCount] = display->getStringWidth(renderText, lineLengths[lineCount], true); } // Consider extra width for signal bars on lines that contain "Signal:" @@ -1213,7 +1228,16 @@ void NotificationRenderer::drawTextInput(OLEDDisplay *display, OLEDDisplayUiStat bool NotificationRenderer::isOverlayBannerShowing() { - return strlen(alertBannerMessage) > 0 && (alertBannerUntil == 0 || millis() <= alertBannerUntil); + // Here 0 means "show indefinitely", so it must short-circuit the comparison. + return strlen(alertBannerMessage) > 0 && (alertBannerUntil == 0 || !Throttle::deadlinePassed(alertBannerUntil)); +} + +bool NotificationRenderer::isMenuShowing() +{ + // A menu, picker, keyboard, or pairing-PIN overlay - anything interactive, as opposed to a plain + // informational text banner (which has no options and type text_banner). Menus don't set a + // notificationType of their own, so options are the only thing distinguishing them. + return isOverlayBannerShowing() && (alertBannerOptions > 0 || current_notification_type != notificationTypeEnum::text_banner); } } // namespace graphics diff --git a/src/graphics/draw/NotificationRenderer.h b/src/graphics/draw/NotificationRenderer.h index 360bfac3c2..d4b7781d5b 100644 --- a/src/graphics/draw/NotificationRenderer.h +++ b/src/graphics/draw/NotificationRenderer.h @@ -38,6 +38,10 @@ class NotificationRenderer static uint8_t alertBannerLineCount; static BannerFont alertBannerLineFonts[MAX_LINES + 1]; static void parseBannerMessageWithFonts(const char *message); + // Decide what text and font a banner line actually renders with: parsed (tag-stripped) + // line if the cache covers it, otherwise the raw line with any leading font tag stripped + // on the fly. Exposed for unit tests. + static const char *resolveBannerLine(uint16_t lineIndex, const char *rawLine, BannerFont &lineFont); static void resetBanner(); static void drawBannercallback(OLEDDisplay *display, OLEDDisplayUiState *state); static void drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisplayUiState *state); @@ -53,6 +57,7 @@ class NotificationRenderer static void drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y); static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y); static bool isOverlayBannerShowing(); + static bool isMenuShowing(); static graphics::notificationTypeEnum current_notification_type; }; diff --git a/src/graphics/draw/UIRenderer.cpp b/src/graphics/draw/UIRenderer.cpp index b8ead27066..b82b850f9d 100644 --- a/src/graphics/draw/UIRenderer.cpp +++ b/src/graphics/draw/UIRenderer.cpp @@ -582,7 +582,7 @@ void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y, } } else if (!gps->getHasLock() && !config.position.fixed_position) { if (strcmp(mode, "line1") == 0) { - strcpy(displayLine, "No GPS Lock"); + strcpy(displayLine, gps->getHasTime() ? "GPS Time Only" : "No GPS Lock"); display->drawString(x, y, displayLine); } } else { diff --git a/src/graphics/eink/Drivers/EInk.cpp b/src/graphics/eink/Drivers/EInk.cpp index cd2e9dc98f..ef9b820e0e 100644 --- a/src/graphics/eink/Drivers/EInk.cpp +++ b/src/graphics/eink/Drivers/EInk.cpp @@ -54,7 +54,7 @@ int32_t EInk::runOnce() // - polling timeout // - other error (derived classes) if (failed) { - LOG_WARN("Display update failed. Check wiring & power supply."); + LOG_WARN("Display update failed. Check wiring & power supply"); updateRunning = false; failed = false; return disable(); diff --git a/src/graphics/niche/Drivers/EInk/EInk.cpp b/src/graphics/niche/Drivers/EInk/EInk.cpp index cd2e9dc98f..ef9b820e0e 100644 --- a/src/graphics/niche/Drivers/EInk/EInk.cpp +++ b/src/graphics/niche/Drivers/EInk/EInk.cpp @@ -54,7 +54,7 @@ int32_t EInk::runOnce() // - polling timeout // - other error (derived classes) if (failed) { - LOG_WARN("Display update failed. Check wiring & power supply."); + LOG_WARN("Display update failed. Check wiring & power supply"); updateRunning = false; failed = false; return disable(); diff --git a/src/graphics/niche/InkHUD/PlatformioConfig.ini b/src/graphics/niche/InkHUD/PlatformioConfig.ini index 4c03773b9f..f5bc5c28c4 100644 --- a/src/graphics/niche/InkHUD/PlatformioConfig.ini +++ b/src/graphics/niche/InkHUD/PlatformioConfig.ini @@ -24,4 +24,4 @@ build_flags = -D HAS_BUTTON=0 ; Suppress default ButtonThread lib_deps = # renovate: datasource=github-tags depName=GFX_Root packageName=ZinggJM/GFX_Root - https://github.com/ZinggJM/GFX_Root/archive/3195764e352a0d2567c8d277ac408ca7293a99b0.zip ; Used by InkHUD as a "slimmer" version of AdafruitGFX + https://github.com/ZinggJM/GFX_Root.git#3195764e352a0d2567c8d277ac408ca7293a99b0 ; Used by InkHUD as a "slimmer" version of AdafruitGFX diff --git a/src/graphics/niche/Utils/FlashData.h b/src/graphics/niche/Utils/FlashData.h index 233d0922eb..43fcd7355a 100644 --- a/src/graphics/niche/Utils/FlashData.h +++ b/src/graphics/niche/Utils/FlashData.h @@ -96,7 +96,7 @@ template class FlashData f.close(); } else { - LOG_ERROR("Could not open / read %s", filename.c_str()); + LOG_ERROR("Can't open/read %s", filename.c_str()); okay = false; } #else @@ -135,10 +135,10 @@ template class FlashData bool writeSucceeded = f.close(); if (!writeSucceeded) { - LOG_ERROR("Can't write data!"); + LOG_ERROR("Can't write data"); } #else - LOG_ERROR("ERROR: Filesystem not implemented\n"); + LOG_ERROR("Filesystem not implemented"); #endif } }; @@ -165,7 +165,7 @@ inline void clearFlashData() file = dir.openNextFile(); } #else - LOG_ERROR("ERROR: Filesystem not implemented\n"); + LOG_ERROR("Filesystem not implemented"); #endif } diff --git a/src/graphics/tftSetup.cpp b/src/graphics/tftSetup.cpp index ff872f169f..40e533177e 100644 --- a/src/graphics/tftSetup.cpp +++ b/src/graphics/tftSetup.cpp @@ -405,7 +405,7 @@ void tftSetup(void) PacketAPI::create(PacketServer::init()); deviceScreen->init(new PacketClient); } else { - LOG_INFO("Running without TFT display!"); + LOG_INFO("Running without TFT display"); } #endif diff --git a/src/input/ButtonThread.cpp b/src/input/ButtonThread.cpp index bf08836912..29f56dba5f 100644 --- a/src/input/ButtonThread.cpp +++ b/src/input/ButtonThread.cpp @@ -226,7 +226,7 @@ int32_t ButtonThread::runOnce() } case BUTTON_EVENT_DOUBLE_PRESSED: { // not wired in if screen detected - LOG_INFO("Double press!"); + LOG_INFO("Double press"); #if defined(ELECROW_ThinkNode_M8) if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) config.device.buzzer_mode = meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED; diff --git a/src/input/RotaryEncoderImpl.cpp b/src/input/RotaryEncoderImpl.cpp index dcdbf0d36b..88075c2f10 100644 --- a/src/input/RotaryEncoderImpl.cpp +++ b/src/input/RotaryEncoderImpl.cpp @@ -3,6 +3,7 @@ #include "RotaryEncoderImpl.h" #include "InputBroker.h" #include "RotaryEncoder.h" +#include "mesh/Throttle.h" #ifdef ARCH_ESP32 #include "sleep.h" #endif @@ -66,7 +67,7 @@ void RotaryEncoderImpl::pollOnce() static uint32_t lastPressed = millis(); if (rotary->readButton() == RotaryEncoder::ButtonState::BUTTON_PRESSED) { - if (lastPressed + 200 < millis()) { + if (Throttle::hasElapsed(lastPressed, 200)) { LOG_DEBUG("Rotary event Press"); lastPressed = millis(); e.inputEvent = this->eventPressed; diff --git a/src/main.cpp b/src/main.cpp index f2b40da01b..3a4eb5f5fa 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -16,6 +16,7 @@ #include "RadioLibInterface.h" #include "ReliableRouter.h" #include "TransmitHistory.h" +#include "UptimeClock.h" #include "airtime.h" #include "buzz.h" #include "power/PowerHAL.h" @@ -316,11 +317,13 @@ __attribute__((weak, noinline)) bool loopCanSleep() // Weak empty variant initialization function. // May be redefined by variant files. -void lateInitVariant() __attribute__((weak)); -void lateInitVariant() {} +// noinline: weak default and call site share this TU, so LTO would inline the empty body and +// never link the variant's strong override. nrf52_lto.py's _VARIANT_OVERRIDES guards this. +__attribute__((noinline)) void lateInitVariant() __attribute__((weak)); +__attribute__((noinline)) void lateInitVariant() {} -void earlyInitVariant() __attribute__((weak)); -void earlyInitVariant() {} +__attribute__((noinline)) void earlyInitVariant() __attribute__((weak)); +__attribute__((noinline)) void earlyInitVariant() {} // NRF52 (and probably other platforms) can report when system is in power failure mode // (eg. too low battery voltage) and operating it is unsafe (data corruption, bootloops, etc). @@ -544,9 +547,9 @@ void setup() EncryptedStorage::initLocked(); if (!EncryptedStorage::isUnlocked()) { if (!EncryptedStorage::isProvisioned()) { - LOG_WARN("Lockdown: Device not provisioned - connect and set a passphrase to unlock storage"); + LOG_WARN("Lockdown: Device not provisioned - set passphrase to unlock storage"); } else { - LOG_WARN("Lockdown: Device locked - connect and provide passphrase to unlock storage"); + LOG_WARN("Lockdown: Device locked - provide passphrase to unlock storage"); } } #endif @@ -563,7 +566,7 @@ void setup() if (EncryptedStorage::isProvisioned()) { enableAPProtect(); } else { - LOG_INFO("APPROTECT deferred: device not yet provisioned"); + LOG_INFO("APPROTECT deferred: not provisioned"); } #elif defined(MESHTASTIC_ENABLE_APPROTECT) // Lockdown without encrypted storage shouldn't be reachable per @@ -650,7 +653,7 @@ void setup() // the bus behind it is scanned right below and its devices are registered // once, so the link has to be up by then if (!sensecapIndicator->wait_ready(5000)) - LOG_ERROR("RP2040 co-processor did not answer, its sensors, GPS and SD card are unavailable this session"); + LOG_ERROR("RP2040 co-processor no reply; sensors, GPS, SD card unavailable this session"); #endif #if !MESHTASTIC_EXCLUDE_I2C @@ -693,7 +696,7 @@ void setup() #ifdef ARCH_ESP32 // Don't init display if we don't have one or we are waking headless due to a timer event if (wakeCause == ESP_SLEEP_WAKEUP_TIMER) { - LOG_DEBUG("suppress screen wake because this is a headless timer wakeup"); + LOG_DEBUG("suppress screen wake: headless timer wakeup"); i2cScanner->setSuppressScreen(); } #endif @@ -755,7 +758,7 @@ void setup() break; default: // use this as default since it's also just zero - LOG_WARN("kb_info.type is unknown(0x%02x), setting kb_model=0x00", kb_info.type); + LOG_WARN("kb_info.type unknown(0x%02x), set kb_model=0x00", kb_info.type); kb_model = 0x00; } } @@ -1358,12 +1361,15 @@ void loop() { runASAP = false; + // The single writer of the monotonic wrap carry; every other caller only reads it. + Time::serviceMonotonic(); + #if defined(MESHTASTIC_ENCRYPTED_STORAGE) && defined(MESHTASTIC_PHONEAPI_ACCESS_CONTROL) if (lockdownDisablePending) { lockdownDisablePending = false; LOG_INFO("Lockdown: disabling - reverting encrypted storage to plaintext"); if (nodeDB->disableLockdownToPlaintext()) { - LOG_INFO("Lockdown: disabled, rebooting into normal mode"); + LOG_INFO("Lockdown: disabled, reboot to normal mode"); PhoneAPI::broadcastLockdownStatus(meshtastic_LockdownStatus_State_DISABLED, "", 0, 0, 0); rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000; } else { @@ -1371,14 +1377,14 @@ void loop() // The DEK file is still present (it's deleted last), so the device // stays in lockdown and the operator can retry disable. Surface // the failure rather than leaving the client hanging. - LOG_ERROR("Lockdown: disable revert failed - device remains in lockdown"); + LOG_ERROR("Lockdown: disable revert failed - still in lockdown"); PhoneAPI::broadcastLockdownStatus(meshtastic_LockdownStatus_State_LOCKED, "disable_failed", 0, 0, 0); } } if (lockdownReloadPending) { lockdownReloadPending = false; - LOG_INFO("Lockdown: reloading config from disk after unlock"); + LOG_INFO("Lockdown: reload config after unlock"); bool reloadOk = nodeDB->reloadFromDisk(); if (!reloadOk) { // Storage decrypt/decode failed during reload. Treat as @@ -1389,7 +1395,7 @@ void loop() // might have), and notify clients. Storage will be locked // on next boot anyway; deferring to the user-visible // notification path is sufficient for now. - LOG_ERROR("Lockdown: reload failed - locking and notifying clients"); + LOG_ERROR("Lockdown: reload failed - lock and notify clients"); EncryptedStorage::lockNow(); PhoneAPI::revokeAllAuth(); } @@ -1415,14 +1421,14 @@ void loop() // sessions to grant. Hard lock (token deleted, DEK // zeroed) and reboot. Operator must re-enter passphrase. if (EncryptedStorage::getBootsRemaining() == 0) { - LOG_WARN("Lockdown: session limit reached and boot budget exhausted, locking and rebooting"); + LOG_WARN("Lockdown: session limit hit, boot budget exhausted - lock and reboot"); EncryptedStorage::lockNow(); PhoneAPI::revokeAllAuth(); PhoneAPI::broadcastLockdownStatus(meshtastic_LockdownStatus_State_LOCKED, "session_budget_exhausted", 0, 0, 0); rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000; } else { uint8_t newBoots = EncryptedStorage::consumeSessionBoot(); - LOG_WARN("Lockdown: session expired, rolled to next budget slot (boots=%u remaining)", newBoots); + LOG_WARN("Lockdown: session expired, next budget slot (boots=%u left)", newBoots); PhoneAPI::revokeAllAuth(); meshtastic_security::lockScreen(); // Signal clients that they need to re-auth on this @@ -1484,7 +1490,7 @@ void loop() ch341Hal->checkError(); } if (portduino_status.LoRa_in_error && rebootAtMsec == 0) { - LOG_ERROR("LoRa in error detected, attempting to recover"); + LOG_ERROR("LoRa error detected, recovering"); router->addInterface(nullptr); if (portduino_config.lora_spi_dev == "ch341") { if (ch341Hal != nullptr) { diff --git a/src/mesh/Channels.cpp b/src/mesh/Channels.cpp index 2d8d4f246c..5860c6fc74 100644 --- a/src/mesh/Channels.cpp +++ b/src/mesh/Channels.cpp @@ -497,6 +497,21 @@ bool Channels::isWellKnownChannel(ChannelIndex chIndex) return false; } +bool Channels::isEventChannel(ChannelIndex chIndex) +{ +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + static const uint8_t configuredEventPsk[] = USERPREFS_CHANNEL_0_PSK; + static_assert(sizeof(configuredEventPsk) == 16 || sizeof(configuredEventPsk) == 32, + "USERPREFS_CHANNEL_0_PSK must be an AES-128 or AES-256 key"); + CryptoKey effectiveKey = getKey(chIndex); + return effectiveKey.length == sizeof(configuredEventPsk) && + memcmp(effectiveKey.bytes, configuredEventPsk, sizeof(configuredEventPsk)) == 0; +#else + (void)chIndex; + return false; +#endif +} + bool Channels::hasDefaultChannel() { // If we don't use a preset or the default frequency slot, or we override the frequency, we don't have a default channel diff --git a/src/mesh/Channels.h b/src/mesh/Channels.h index 6e17a7ab61..27833130c0 100644 --- a/src/mesh/Channels.h +++ b/src/mesh/Channels.h @@ -5,6 +5,10 @@ #include "mesh-pb-constants.h" #include +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && !defined(USERPREFS_CHANNEL_0_PSK) +#error "USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL requires USERPREFS_CHANNEL_0_PSK" +#endif + /** A channel number (index into the channel table) */ typedef uint8_t ChannelIndex; @@ -95,6 +99,9 @@ class Channels // matches the current preset's name and PSK byte 1. bool isWellKnownChannel(ChannelIndex chIndex); + // Returns true if this channel's effective key matches USERPREFS_CHANNEL_0_PSK. + bool isEventChannel(ChannelIndex chIndex); + // Returns true if we can be reached via a channel with the default settings given a region and modem preset bool hasDefaultChannel(); @@ -164,4 +171,4 @@ bool channelFileUsesPublicKey(const meshtastic_ChannelFile &cf, ChannelIndex chI static const uint8_t eventpsk[] = {0x38, 0x4b, 0xbc, 0xc0, 0x1d, 0xc0, 0x22, 0xd1, 0x81, 0xbf, 0x36, 0xb8, 0x61, 0x21, 0xe1, 0xfb, 0x96, 0xb7, 0x2e, 0x55, 0xbf, 0x74, - 0x22, 0x7e, 0x9d, 0x6a, 0xfb, 0x48, 0xd6, 0x4c, 0xb1, 0xa1}; \ No newline at end of file + 0x22, 0x7e, 0x9d, 0x6a, 0xfb, 0x48, 0xd6, 0x4c, 0xb1, 0xa1}; diff --git a/src/mesh/CryptoEngine.cpp b/src/mesh/CryptoEngine.cpp index 95c640d539..f2c966cc7c 100644 --- a/src/mesh/CryptoEngine.cpp +++ b/src/mesh/CryptoEngine.cpp @@ -336,7 +336,7 @@ bool CryptoEngine::setDHPublicKey(uint8_t *pubKey) // Calculate the shared secret with the specified node's public key and our private key // This includes an internal weak key check, which among other things looks for an all 0 public key and shared key. if (!Curve25519::dh2(shared_key, local_priv)) { - LOG_WARN("Curve25519DH step 2 failed!"); + LOG_WARN("Curve25519DH step 2 failed"); return false; } return true; @@ -373,7 +373,7 @@ concurrency::Lock *cryptLock; void CryptoEngine::setKey(const CryptoKey &k) { - LOG_DEBUG("Use AES%d key!", k.length * 8); + LOG_DEBUG("Use AES%d key", k.length * 8); key = k; } @@ -389,7 +389,7 @@ void CryptoEngine::encryptPacket(uint32_t fromNode, uint64_t packetId, size_t nu if (numBytes <= MAX_BLOCKSIZE) { encryptAESCtr(key, nonce, numBytes, bytes); } else { - LOG_ERROR("Packet too large for crypto engine: %d. noop encryption!", numBytes); + LOG_ERROR("Packet too large for crypto engine: %d. noop encryption", numBytes); } } } diff --git a/src/mesh/IndicatorSerial.cpp b/src/mesh/IndicatorSerial.cpp index 14f60d9212..74608b5fa9 100644 --- a/src/mesh/IndicatorSerial.cpp +++ b/src/mesh/IndicatorSerial.cpp @@ -486,7 +486,7 @@ bool SensecapIndicator::handle_packet(size_t payload_len) LOG_WARN("Request 0x%08x nacked by the co-processor", expected_id); request_nacked = true; } else if (message.id == 0) { - LOG_WARN("Co-processor could not decode a frame"); + LOG_WARN("Co-processor can't decode a frame"); } return true; case meshtastic_InterdeviceMessage_sd_info_tag: diff --git a/src/mesh/LR11x0Interface.cpp b/src/mesh/LR11x0Interface.cpp index b7a6040e37..8be0b64139 100644 --- a/src/mesh/LR11x0Interface.cpp +++ b/src/mesh/LR11x0Interface.cpp @@ -104,11 +104,11 @@ template bool LR11x0Interface::init() // DIO3 is free to be used as an IRQ only while no TCXO Vref is driven on it if (tcxoVoltage > 0) - LOG_DEBUG("LR11x0 TCXO Vref %f V on DIO3 (DIO3 unavailable as an IRQ)", tcxoVoltage); + LOG_DEBUG("LR11x0 TCXO Vref %f V on DIO3 (DIO3 unavailable as IRQ)", tcxoVoltage); else - LOG_DEBUG("LR11x0 no TCXO Vref, XTAL only (DIO3 free as an IRQ)"); + LOG_DEBUG("LR11x0 no TCXO Vref, XTAL only (DIO3 free as IRQ)"); #if defined(TCXO_OPTIONAL) - LOG_DEBUG("TCXO_OPTIONAL: oscillator type unknown, probing XTAL first and using any TCXO Vref only as fallback"); + LOG_DEBUG("TCXO_OPTIONAL: osc type unknown, probe XTAL first, TCXO Vref as fallback"); #endif RadioLibInterface::init(); @@ -156,7 +156,7 @@ template bool LR11x0Interface::init() #if defined(TCXO_OPTIONAL) // 2. XTAL failed with the chip present, so fall back to the TCXO if the variant configured one if (res != RADIOLIB_ERR_NONE && res != RADIOLIB_ERR_CHIP_NOT_FOUND && tcxoVoltage > 0) { - LOG_WARN("LR11x0 XTAL init failed (err %d), retrying with TCXO Vref %f V", res, tcxoVoltage); + LOG_WARN("LR11x0 XTAL init failed (err %d), retry with TCXO Vref %f V", res, tcxoVoltage); attemptVoltage = tcxoVoltage; res = tryBegin(2, attemptVoltage); if (res == RADIOLIB_ERR_NONE) @@ -167,7 +167,7 @@ template bool LR11x0Interface::init() // 3. Some units need extra settling time, so give whichever oscillator we settled on one retry. // After a step 2 fallback that is a second TCXO attempt, which is where settling actually matters. if (lr11x0SpiFailed(res)) { - LOG_WARN("LR11x0 init failed with %d (SPI command failure), retrying after delay...", res); + LOG_WARN("LR11x0 init failed with %d (SPI cmd failure), retry after delay", res); delay(100); res = tryBegin(3, attemptVoltage); } @@ -179,9 +179,9 @@ template bool LR11x0Interface::init() #ifdef LR11X0_UPDATE_FIRMWARE_TO // An interrupted update leaves the radio sitting in bootloader mode, where begin() fails. Retry the // flash from here rather than giving up, otherwise the device could never recover on its own. - LOG_WARN("LR11x0 did not start; attempting firmware recovery in case an update was interrupted"); + LOG_WARN("LR11x0 did not start; firmware recovery in case update was interrupted"); if (lora.updateFirmware(lr11xx_firmware_image, LR11XX_FIRMWARE_IMAGE_SIZE, true) == RADIOLIB_ERR_NONE) { - LOG_INFO("LR1110 firmware recovery succeeded, re-initializing radio"); + LOG_INFO("LR1110 firmware recovery OK, re-init radio"); res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage); } #endif @@ -202,8 +202,8 @@ template bool LR11x0Interface::init() // One-shot transceiver firmware update, opt-in per variant. Only runs when the part is an LR1110 running // older firmware than the baked-in image, so once it has succeeded it is a no-op on subsequent boots. if (transceiverDevice == RADIOLIB_LR11X0_DEVICE_LR1110 && transceiverFw != 0 && transceiverFw < LR11X0_UPDATE_FIRMWARE_TO) { - LOG_WARN("LR1110 transceiver FW %d.%d is older than %d.%d - updating now. DO NOT POWER OFF: this " - "erases and rewrites the radio's own flash.", + LOG_WARN("LR1110 transceiver FW %d.%d older than %d.%d - updating. DO NOT POWER OFF: " + "rewrites radio's own flash", transceiverFw >> 8, transceiverFw & 0xFF, LR11X0_UPDATE_FIRMWARE_TO >> 8, LR11X0_UPDATE_FIRMWARE_TO & 0xFF); int upd = lora.updateFirmware(lr11xx_firmware_image, LR11XX_FIRMWARE_IMAGE_SIZE, true); @@ -214,7 +214,7 @@ template bool LR11x0Interface::init() return false; } - LOG_INFO("LR1110 firmware update complete, re-initializing radio"); + LOG_INFO("LR1110 firmware update complete, re-init radio"); res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage); if (res != RADIOLIB_ERR_NONE) { LOG_ERROR("LR11x0 re-init after firmware update failed %s%d", radioLibErr, res); @@ -259,7 +259,7 @@ template bool LR11x0Interface::init() LOG_INFO("Set RX gain to boosted mode; result: %d", res); } else { res = lora.setRxBoostedGainMode(false); - LOG_INFO("Set RX gain to power saving mode (boosted mode off); result: %d", res); + LOG_INFO("Set RX gain to power saving mode; result: %d", res); } } @@ -318,7 +318,7 @@ template bool LR11x0Interface::reconfigure() return true; } -template void LR11x0Interface::disableInterrupt() +template void LR11x0Interface::clearRadioIsr() { lora.clearIrqAction(); } @@ -330,7 +330,7 @@ template void LR11x0Interface::setStandby() int err = lora.standby(); if (err != RADIOLIB_ERR_NONE) { - LOG_DEBUG("LR11x0 standby failed with error %d", err); + LOG_DEBUG("LR11x0 standby failed, err %d", err); } assert(err == RADIOLIB_ERR_NONE); diff --git a/src/mesh/LR11x0Interface.h b/src/mesh/LR11x0Interface.h index 552dd5e5e9..9280c05dee 100644 --- a/src/mesh/LR11x0Interface.h +++ b/src/mesh/LR11x0Interface.h @@ -47,12 +47,12 @@ template class LR11x0Interface : public RadioLibInterface /** * Glue functions called from ISR land */ - virtual void disableInterrupt() override; + virtual void clearRadioIsr() override; /** * Enable a particular ISR callback glue function */ - virtual void enableInterrupt(void (*callback)()) { lora.setIrqAction(callback); } + virtual void setRadioIsr(void (*callback)()) override { lora.setIrqAction(callback); } /** can we detect a LoRa preamble on the current channel? */ virtual bool isChannelActive() override; diff --git a/src/mesh/LR20x0Interface.cpp b/src/mesh/LR20x0Interface.cpp index 88ab392e79..dcc514041e 100644 --- a/src/mesh/LR20x0Interface.cpp +++ b/src/mesh/LR20x0Interface.cpp @@ -69,17 +69,17 @@ template bool LR20x0Interface::init() // FIXME: correct logic to default to not using TCXO if no voltage is specified for LR20x0_DIO3_TCXO_VOLTAGE #elif defined(LR2021_DIO3_TCXO_VOLTAGE) float tcxoVoltage = LR2021_DIO3_TCXO_VOLTAGE; - LOG_DEBUG("LR2021_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V", LR2021_DIO3_TCXO_VOLTAGE); + LOG_DEBUG("LR2021_DIO3_TCXO_VOLTAGE defined, DIO3 as TCXO Vref %f V", LR2021_DIO3_TCXO_VOLTAGE); // (DIO3 is not free to be used as an IRQ) #elif defined(TCXO_OPTIONAL) float tcxoVoltage = 1.6f; // TCXO_OPTIONAL: try default 1.6 V first, fall back to XTAL on failure - LOG_DEBUG("TCXO_OPTIONAL: no LR2021_DIO3_TCXO_VOLTAGE defined, trying default TCXO Vref 1.6 V first"); + LOG_DEBUG("TCXO_OPTIONAL: no LR2021_DIO3_TCXO_VOLTAGE, try default TCXO Vref 1.6 V first"); #else float tcxoVoltage = 0; // "TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip." per // https://github.com/jgromes/RadioLib/blob/690a050ebb46e6097c5d00c371e961c1caa3b52e/src/modules/LR11x0/LR11x0.h#L471C26-L471C104 // (DIO3 is free to be used as an IRQ) - LOG_DEBUG("LR2021_DIO3_TCXO_VOLTAGE not defined, not using DIO3 as TCXO reference voltage"); + LOG_DEBUG("LR2021_DIO3_TCXO_VOLTAGE not defined, DIO3 not used as TCXO Vref"); #endif RadioLibInterface::init(); @@ -119,7 +119,7 @@ template bool LR20x0Interface::init() // Retry if we get SPI command failed - some units need extra TCXO stabilization time if (res == RADIOLIB_ERR_SPI_CMD_FAILED) { - LOG_WARN("LR20x0 init failed with %d (SPI_CMD_FAILED), retrying after delay...", res); + LOG_WARN("LR20x0 init failed with %d (SPI_CMD_FAILED), retry after delay", res); delay(100); res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage); } @@ -127,7 +127,7 @@ template bool LR20x0Interface::init() #if defined(TCXO_OPTIONAL) // If init failed for any reason other than chip not found, retry without TCXO (XTAL mode) if (res != RADIOLIB_ERR_NONE && res != RADIOLIB_ERR_CHIP_NOT_FOUND && tcxoVoltage > 0) { - LOG_WARN("LR20x0 init failed with TCXO Vref %f V (err %d), retrying without TCXO", tcxoVoltage, res); + LOG_WARN("LR20x0 init failed with TCXO Vref %f V (err %d), retry without TCXO", tcxoVoltage, res); tcxoVoltage = 0; res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage); if (res == RADIOLIB_ERR_NONE) @@ -166,7 +166,7 @@ template bool LR20x0Interface::init() LOG_INFO("Set RX gain to boosted mode; result: %d", res); } else { res = lora.setRxBoostedGainMode(false); - LOG_INFO("Set RX gain to power saving mode (boosted mode off); result: %d", res); + LOG_INFO("Set RX gain to power saving mode; result: %d", res); } } @@ -220,7 +220,7 @@ template bool LR20x0Interface::reconfigure() int res = lora.begin(freq, bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage); if (res == RADIOLIB_ERR_SPI_CMD_FAILED) { - LOG_WARN("LR20x0 band-hop begin SPI_CMD_FAILED, retrying..."); + LOG_WARN("LR20x0 band-hop begin SPI_CMD_FAILED, retrying"); delay(100); res = lora.begin(freq, bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage); } @@ -323,7 +323,7 @@ template bool LR20x0Interface::reconfigure() return success; } -template void LR20x0Interface::disableInterrupt() +template void LR20x0Interface::clearRadioIsr() { lora.clearIrqAction(); } @@ -335,7 +335,7 @@ template void LR20x0Interface::setStandby() int err = lora.standby(); if (err != RADIOLIB_ERR_NONE) { - LOG_DEBUG("LR20x0 standby failed with error %d", err); + LOG_DEBUG("LR20x0 standby failed, err %d", err); } assert(err == RADIOLIB_ERR_NONE); diff --git a/src/mesh/LR20x0Interface.h b/src/mesh/LR20x0Interface.h index 263c83429d..ed04dfb0e1 100644 --- a/src/mesh/LR20x0Interface.h +++ b/src/mesh/LR20x0Interface.h @@ -42,12 +42,12 @@ template class LR20x0Interface : public RadioLibInterface /** * Glue functions called from ISR land */ - virtual void disableInterrupt() override; + virtual void clearRadioIsr() override; /** * Enable a particular ISR callback glue function */ - virtual void enableInterrupt(void (*callback)()) { lora.setIrqAction(callback); } + virtual void setRadioIsr(void (*callback)()) override { lora.setIrqAction(callback); } /** can we detect a LoRa preamble on the current channel? */ virtual bool isChannelActive() override; diff --git a/src/mesh/MemoryPool.h b/src/mesh/MemoryPool.h index ed20fb334c..e1b84a4b43 100644 --- a/src/mesh/MemoryPool.h +++ b/src/mesh/MemoryPool.h @@ -115,7 +115,7 @@ template class MemoryDynamic : public Allocator { T *p = (T *)malloc(sizeof(T)); if (!p) { - LOG_WARN("malloc(%u) failed, heap exhausted!", (unsigned)sizeof(T)); + LOG_WARN("malloc(%u) failed, heap exhausted", (unsigned)sizeof(T)); return nullptr; } this->auditAdd((int32_t)sizeof(T)); @@ -156,7 +156,7 @@ template class MemoryPool : public Allocator this->auditAdd(-(int32_t)sizeof(T)); LOG_HEAP("Released static pool item %d at 0x%x", index, p); } else { - LOG_WARN("Pointer 0x%x not from our pool!", p); + LOG_WARN("Pointer 0x%x not from our pool", p); } } @@ -175,7 +175,7 @@ template class MemoryPool : public Allocator } // No free slots available - return nullptr instead of asserting - LOG_WARN("No free slots available in static memory pool!"); + LOG_WARN("No free slots available in static memory pool"); return nullptr; } }; diff --git a/src/mesh/MeshModule.cpp b/src/mesh/MeshModule.cpp index d8bff724e6..71da37145b 100644 --- a/src/mesh/MeshModule.cpp +++ b/src/mesh/MeshModule.cpp @@ -170,7 +170,7 @@ void MeshModule::callModules(meshtastic_MeshPacket &mp, RxSource src) pi.sendResponse(mp); LOG_INFO("Asked module '%s' to send a response", pi.name); } else { - LOG_DEBUG("Module '%s' cannot respond on portnum=%d", pi.name, mp.decoded.portnum); + LOG_DEBUG("Module '%s' can't respond on portnum=%d", pi.name, mp.decoded.portnum); } ignoreRequest = ignoreRequest || pi.ignoreRequest; // If at least one module asks it, we may ignore a request } else { diff --git a/src/mesh/MeshService.cpp b/src/mesh/MeshService.cpp index 2f3dbb1a5f..162d15353d 100644 --- a/src/mesh/MeshService.cpp +++ b/src/mesh/MeshService.cpp @@ -13,6 +13,7 @@ #include "PowerFSM.h" #include "TypeConversions.h" #include "UptimeClock.h" +#include "gps/GPSLog.h" #include "gps/RTC.h" #include "graphics/draw/MessageRenderer.h" #include "main.h" @@ -95,7 +96,7 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp) meshtastic_Config_DeviceConfig_Role_CLIENT_BASE); if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp->decoded.portnum == meshtastic_PortNum_TELEMETRY_APP && mp->decoded.request_id > 0) { - LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo"); + LOG_DEBUG("Got telemetry response. Skip our NodeInfo"); // ignore our request for its NodeInfo } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeInfoLiteHasUser(nodeDB->getMeshNode(mp->from)) && nodeInfoModule && !isPreferredRebroadcaster && @@ -103,13 +104,13 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp) if (airTime->isTxAllowedChannelUtil(true)) { const int8_t hopsUsed = getHopsAway(*mp, config.lora.hop_limit); if (hopsUsed > (int32_t)(config.lora.hop_limit + 2)) { - LOG_DEBUG("Skip send NodeInfo: %d hops away is too far away", hopsUsed); + LOG_DEBUG("Skip send NodeInfo: %d hops too far", hopsUsed); } else { - LOG_INFO("Heard new node on ch. %d, send NodeInfo and ask for response", mp->channel); + LOG_INFO("Heard new node on ch. %d, send NodeInfo, ask response", mp->channel); nodeInfoModule->sendOurNodeInfo(mp->from, true, mp->channel); } } else { - LOG_DEBUG("Skip sending NodeInfo > 25%% ch. util"); + LOG_DEBUG("Skip NodeInfo > 25%% ch. util"); } } @@ -181,14 +182,14 @@ NodeNum MeshService::getNodenumFromRequestId(uint32_t request_id) return nodenum; } -// Back-calculate the real epoch for any queued packet still carrying a millis() rx_time +// Back-calculate the real epoch for any queued packet still carrying an uptime-seconds rx_time // placeholder, now that the clock is trustworthy. void MeshService::reconcilePendingRxTimes() { const uint32_t nowEpoch = getValidTime(RTCQualityFromNet); if (nowEpoch == 0) // called before the clock was actually valid - nothing to reconcile against return; - const uint32_t nowMillis = Time::getMillis(); + const uint32_t nowUptimeSecs = Time::getUptimeSecs(); // Rotate the queue once. TypedQueue is strictly FIFO on both backends, so dequeueing and // re-enqueueing every element in turn leaves the delivery order unchanged. @@ -197,14 +198,16 @@ void MeshService::reconcilePendingRxTimes() if (!p) // drained from under us - nothing left to rotate break; if (!p->has_rx_time) { - // Unsigned subtraction is wraparound-safe; rx_time is a 32-bit wire field, so the - // placeholder was never wider than 32 bits to begin with. - const uint32_t elapsedMs = nowMillis - p->rx_time; - p->rx_time = nowEpoch - (elapsedMs / 1000); - p->has_rx_time = true; + // Both stamps are monotonic uptime seconds, so the elapsed term is exact at any age. + // If it somehow exceeds the epoch, leave the packet un-dated rather than pre-1970. + const uint32_t elapsedSecs = nowUptimeSecs - p->rx_time; + if (elapsedSecs < nowEpoch) { + p->rx_time = nowEpoch - elapsedSecs; + p->has_rx_time = true; + } } if (!toPhoneQueue.enqueue(p, 0)) { // mirrors sendToPhone()'s degrade-on-failure path - LOG_CRIT("Failed to requeue a packet into toPhoneQueue!"); + LOG_CRIT("Requeue to toPhoneQueue failed"); releaseToPool(p); fromNum++; // notify observers so the phone can resync } @@ -232,14 +235,14 @@ void MeshService::injectAsReceived(meshtastic_MeshPacket &p) p.decoded.portnum = scratch.portnum; } } else { - LOG_ERROR("inject: could not decode Compressed envelope, dropping"); + LOG_ERROR("inject: can't decode Compressed envelope, drop"); return; } } // The real RX path (RadioLibInterface::handleReceiveInterrupt) drops sender==0; mirror it so injection // behaves identically to an over-the-air frame. if (p.from == 0) { - LOG_WARN("inject: dropping frame with from==0 (matches real LoRa RX)"); + LOG_WARN("inject: drop frame with from==0 (matches real LoRa RX)"); return; } meshtastic_MeshPacket *mp = packetPool.allocCopy(p); @@ -341,7 +344,7 @@ ErrorCode MeshService::sendQueueStatusToPhone(const meshtastic_QueueStatus &qs, copied->mesh_packet_id = mesh_packet_id; if (toPhoneQueueStatusQueue.numFree() == 0) { - LOG_INFO("tophone queue status queue is full, discard oldest"); + LOG_INFO("tophone queue status queue full, discard oldest"); meshtastic_QueueStatus *d = toPhoneQueueStatusQueue.dequeuePtr(0); if (d) releaseQueueStatusToPool(d); @@ -421,9 +424,8 @@ bool MeshService::trySendPosition(NodeNum dest, bool wantReplies) if (!found) { // No channel with position enabled: fall back to sending nodeinfo, as before. if (nodeInfoModule) { - LOG_INFO( - "No channel with position enabled; sending nodeinfo instead to 0x%08x, wantReplies=%d, channel=%d", - dest, wantReplies, node->channel); + LOG_INFO("No position-enabled channel; send nodeinfo instead to 0x%08x, wantReplies=%d, channel=%d", dest, + wantReplies, node->channel); nodeInfoModule->sendOurNodeInfo(dest, wantReplies, node->channel); } return false; @@ -470,7 +472,7 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p) // Withhold decoded nested payloads a strict phone decoder would reject; still-encrypted packets // pass through (the phone may hold the key). if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !phonePayloadIsDecodable(p->decoded)) { - LOG_WARN("Dropping undecodable portnum=%d payload from phone delivery (from=0x%08x)", p->decoded.portnum, p->from); + LOG_WARN("Drop undecodable portnum=%d payload from phone delivery (from=0x%08x)", p->decoded.portnum, p->from); releaseToPool(p); fromNum++; // notify observers so the phone can resync return; @@ -490,12 +492,12 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p) if (toPhoneQueue.numFree() == 0) { if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP || p->decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP) { - LOG_WARN("ToPhone queue is full, discard oldest"); + LOG_WARN("ToPhone queue full, discard oldest"); meshtastic_MeshPacket *d = toPhoneQueue.dequeuePtr(0); if (d) releaseToPool(d); } else { - LOG_WARN("ToPhone queue is full, drop packet"); + LOG_WARN("ToPhone queue full, drop packet"); releaseToPool(p); fromNum++; // Make sure to notify observers in case they are reconnected so they can get the packets return; @@ -503,7 +505,7 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p) } if (toPhoneQueue.enqueue(p, 0) == false) { - LOG_CRIT("Failed to queue a packet into toPhoneQueue!"); + LOG_CRIT("Queue to toPhoneQueue failed"); releaseToPool(p); fromNum++; // notify observers so phone can resync return; @@ -513,16 +515,16 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p) void MeshService::sendMqttMessageToClientProxy(meshtastic_MqttClientProxyMessage *m) { - LOG_DEBUG("Send mqtt message on topic '%s' to client for proxy", m->topic); + LOG_DEBUG("Send mqtt msg on topic '%s' to proxy client", m->topic); if (toPhoneMqttProxyQueue.numFree() == 0) { - LOG_WARN("MqttClientProxyMessagePool queue is full, discard oldest"); + LOG_WARN("MqttClientProxyMessagePool queue full, discard oldest"); meshtastic_MqttClientProxyMessage *d = toPhoneMqttProxyQueue.dequeuePtr(0); if (d) releaseMqttClientProxyMessageToPool(d); } if (toPhoneMqttProxyQueue.enqueue(m, 0) == false) { - LOG_CRIT("Failed to queue a packet into toPhoneMqttProxyQueue!"); + LOG_CRIT("Queue to toPhoneMqttProxyQueue failed"); releaseMqttClientProxyMessageToPool(m); return; } @@ -532,7 +534,7 @@ void MeshService::sendMqttMessageToClientProxy(meshtastic_MqttClientProxyMessage void MeshService::sendRoutingErrorResponse(meshtastic_Routing_Error error, const meshtastic_MeshPacket *mp) { if (!mp) { - LOG_WARN("Cannot send routing error response: null packet"); + LOG_WARN("Can't send routing error response: null packet"); return; } @@ -540,7 +542,7 @@ void MeshService::sendRoutingErrorResponse(meshtastic_Routing_Error error, const if (routingModule) { routingModule->sendAckNak(error, mp->from, mp->id, mp->channel); } else { - LOG_ERROR("Cannot send routing error response: no routing module"); + LOG_ERROR("Can't send routing error response: no routing module"); } } @@ -548,14 +550,14 @@ void MeshService::sendClientNotification(meshtastic_ClientNotification *n) { LOG_DEBUG("Send client notification to phone"); if (toPhoneClientNotificationQueue.numFree() == 0) { - LOG_WARN("ClientNotification queue is full, discard oldest"); + LOG_WARN("ClientNotification queue full, discard oldest"); meshtastic_ClientNotification *d = toPhoneClientNotificationQueue.dequeuePtr(0); if (d) releaseClientNotificationToPool(d); } if (toPhoneClientNotificationQueue.enqueue(n, 0) == false) { - LOG_CRIT("Failed to queue a notification into toPhoneClientNotificationQueue!"); + LOG_CRIT("Queue to toPhoneClientNotificationQueue failed"); releaseClientNotificationToPool(n); return; } @@ -597,9 +599,7 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus) pos = gps->p; } else { // The GPS has lost lock -#ifdef GPS_DEBUG - LOG_DEBUG("onGPSchanged() - lost validLocation"); -#endif + LOG_DEBUG_GPS("onGPSchanged() - lost validLocation"); } // Used fixed position if configured regardless of GPS lock if (config.position.fixed_position) { @@ -629,7 +629,7 @@ bool MeshService::isToPhoneQueueEmpty() uint32_t MeshService::GetTimeSinceMeshPacket(const meshtastic_MeshPacket *mp) { - // rx_time may be a millis() placeholder while has_rx_time is false - don't age it as + // rx_time may be an uptime-seconds placeholder while has_rx_time is false - don't age it as // wall-clock, and don't pass it off as "just now" either. if (!mp->has_rx_time) return SINCE_UNKNOWN; diff --git a/src/mesh/MeshService.h b/src/mesh/MeshService.h index bae955969e..8ddc6e4349 100644 --- a/src/mesh/MeshService.h +++ b/src/mesh/MeshService.h @@ -137,8 +137,8 @@ class MeshService // search the queue for a request id and return the matching nodenum NodeNum getNodenumFromRequestId(uint32_t request_id); - // Rewrite any queued-for-phone packet still carrying a millis() rx_time placeholder into a - // real epoch, now that the wall clock is trustworthy. + // Rewrite any queued-for-phone packet still carrying an uptime-seconds rx_time placeholder + // into a real epoch, now that the wall clock is trustworthy. void reconcilePendingRxTimes(); // Release QueueStatus packet to pool diff --git a/src/mesh/NextHopRouter.cpp b/src/mesh/NextHopRouter.cpp index 0a64a1f1a9..3be7a1ba6b 100644 --- a/src/mesh/NextHopRouter.cpp +++ b/src/mesh/NextHopRouter.cpp @@ -1,6 +1,8 @@ #include "NextHopRouter.h" #include "Default.h" #include "MeshTypes.h" +#include "Throttle.h" +#include "UptimeClock.h" #include "meshUtils.h" #if !MESHTASTIC_EXCLUDE_TRACEROUTE #include "modules/TraceRouteModule.h" @@ -67,7 +69,7 @@ ErrorCode NextHopRouter::send(meshtastic_MeshPacket *p) wasSeenRecently(p); // FIXME, move this to a sniffSent method p->next_hop = getNextHop(p->to, p->relay_node).value_or(NO_NEXT_HOP_PREFERENCE); // set the next hop - LOG_DEBUG("Setting next hop for packet with dest %x to %x", p->to, p->next_hop); + LOG_TRACE("Set next hop for dest 0x%08x to 0x%x", p->to, p->next_hop); // If it's from us, ReliableRouter already handles retransmissions if want_ack is set. If a next hop is set and hop limit is // not 0 or want_ack is set, start retransmissions @@ -113,7 +115,8 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p) // If repeated and not in Tx queue anymore, try relaying again, or if we are the destination, send the ACK again if (isRepeated) { if (!findInTxQueue(p->from, p->id)) { - if (reprocessPacket(p) && !perhapsRebroadcast(p) && isToUs(p) && p->want_ack) { + if (reprocessPacket(p) && !isBlockedEventCoordinatePacket(p) && !perhapsRebroadcast(p) && isToUs(p) && + p->want_ack) { sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0); } } @@ -157,7 +160,7 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast // -> store nothing and keep flooding (safe). if (nodeDB->resolveUniqueLastByte(p->relay_node, /*requireDirectNeighbor=*/false)) { if (origTx && origTx->next_hop != p->relay_node) { // Not already set - LOG_INFO("Update next hop of 0x%08x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from, + LOG_INFO("Update next hop of 0x%08x to 0x%x from ACK/reply (was relayer %d we were sole %d)", p->from, p->relay_node, wasAlreadyRelayer, weWereSoleRelayer); origTx->next_hop = p->relay_node; } @@ -190,6 +193,14 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast /* Check if we should be rebroadcasting this packet if so, do so. */ bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p) { +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL + // Never relay coordinate-bearing packets on the event ("everyone") channel. + // Closes the reliable-retransmit-dupe path that runs before handleReceived(). + if (isBlockedEventCoordinatePacket(p)) { + return false; + } +#endif + // Check if traffic management wants to exhaust this packet's hops bool exhaustHops = false; #if HAS_TRAFFIC_MANAGEMENT @@ -214,17 +225,17 @@ bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p) meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it if (!tosend) return true; - LOG_INFO("Rebroadcast received message coming from %x", p->relay_node); + LOG_INFO("Rebroadcast msg from %x", p->relay_node); // If exhausting hops, force hop_limit = 0 regardless of other logic if (exhaustHops) { tosend->hop_limit = 0; - LOG_INFO("Traffic management: exhausting hops for 0x%08x, setting hop_limit=0", getFrom(p)); + LOG_INFO("Traffic management: exhaust hops for 0x%08x, hop_limit=0", getFrom(p)); } else if (shouldDecrementHopLimit(p)) { // Use shared logic to determine if hop_limit should be decremented tosend->hop_limit--; // bump down the hop count } else { - LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE rebroadcast: preserving hop_limit"); + LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE rebroadcast: keep hop_limit"); } #if USERPREFS_EVENT_MODE capEventRelayHops(tosend); @@ -266,7 +277,7 @@ std::optional NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node) // TraceRouteModule) with no matching record is left authoritative. const RouteHealth *h = findRouteHealth(to); if (h && h->lastNextHop == node->next_hop && isRouteStale(*h, millis())) { - LOG_INFO("Next hop 0x%x for 0x%08x is stale (age/fails); flood and clear", node->next_hop, to); + LOG_INFO("Next hop 0x%x for 0x%08x stale (age/fails); flood and clear", node->next_hop, to); node->next_hop = NO_NEXT_HOP_PREFERENCE; // clear persisted route clearRouteHealth(to); // clear RAM health return std::nullopt; @@ -298,14 +309,14 @@ std::optional NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node) if (hint && hint != relay_node) { const RouteHealth *h = findRouteHealth(to); if (h && h->lastNextHop == hint && isRouteStale(*h, millis())) { - LOG_INFO("TMM next hop 0x%x for 0x%08x is stale (age/fails); flood and clear", hint, to); + LOG_INFO("TMM next hop 0x%x for 0x%08x stale (age/fails); flood and clear", hint, to); trafficManagementModule->clearNextHop(to); // clear overflow route (setNextHop won't store 0) clearRouteHealth(to); // clear RAM health return std::nullopt; } ResolvedNode r = nodeDB->resolveLastByte(hint, /*requireDirectNeighbor=*/true); if (r.status == LastByteResolution::Unique) { - LOG_DEBUG("Next hop for 0x%08x is 0x%x (TMM cache)", to, hint); + LOG_TRACE("Next hop for 0x%08x is 0x%x (TMM cache)", to, hint); return hint; } LOG_WARN("TMM next hop 0x%x for 0x%08x %s; set no pref", hint, to, @@ -394,7 +405,9 @@ PendingPacket *NextHopRouter::startRetransmission(meshtastic_MeshPacket *p, uint */ int32_t NextHopRouter::doRetransmissions() { - uint32_t now = millis(); + // Same clock Throttle reads, so setNextTx() deadlines and this test can't diverge under an + // injected test clock. + uint32_t now = Time::getMillis(); int32_t d = INT32_MAX; // FIXME, we should use a better datastructure rather than walking through this map. @@ -405,19 +418,20 @@ int32_t NextHopRouter::doRetransmissions() bool stillValid = true; // assume we'll keep this record around - // FIXME, handle 51 day rolloever here!!! - if (p.nextTxMsec <= now) { + // Judged against the snapshot above, so one pass sees one instant and the 49.7 day wrap + // can't stall retransmission. + if (Throttle::deadlinePassedAt(now, p.nextTxMsec)) { if (p.numRetransmissions == 0) { if (isFromUs(p.packet)) { - LOG_DEBUG("Reliable send failed, returning a nak for fr=0x%08x,to=0x%08x,id=0x%08x", p.packet->from, - p.packet->to, p.packet->id); + LOG_DEBUG("Reliable send failed, return nak fr=0x%08x,to=0x%08x,id=0x%08x", p.packet->from, p.packet->to, + p.packet->id); sendAckNak(meshtastic_Routing_Error_MAX_RETRANSMIT, getFrom(p.packet), p.packet->id, p.packet->channel); } // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived stopRetransmission(it->first); stillValid = false; // just deleted it } else { - LOG_DEBUG("Sending retransmission fr=0x%08x,to=0x%08x,id=0x%08x, tries left=%d", p.packet->from, p.packet->to, + LOG_DEBUG("Send retransmission fr=0x%08x,to=0x%08x,id=0x%08x, tries left=%d", p.packet->from, p.packet->to, p.packet->id, p.numRetransmissions); if (!isBroadcast(p.packet->to)) { @@ -430,7 +444,7 @@ int32_t NextHopRouter::doRetransmissions() // Also reset it in the nodeDB meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to); if (sentTo) { - LOG_INFO("Resetting next hop for packet with dest 0x%08x", p.packet->to); + LOG_INFO("Reset next hop for dest 0x%08x", p.packet->to); sentTo->next_hop = NO_NEXT_HOP_PREFERENCE; } #if HAS_TRAFFIC_MANAGEMENT @@ -502,8 +516,8 @@ void NextHopRouter::setNextTx(PendingPacket *pending) { assert(iface); auto d = iface->getRetransmissionMsec(pending->packet); - pending->nextTxMsec = millis() + d; - LOG_DEBUG("Setting next retransmission in %u msecs: ", d); + pending->nextTxMsec = Time::getMillis() + d; + LOG_TRACE("Next retransmission in %u msecs", d); printPacket("", pending->packet); setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time } diff --git a/src/mesh/NodeDB.cpp b/src/mesh/NodeDB.cpp index 20af1a0172..abccda70ff 100644 --- a/src/mesh/NodeDB.cpp +++ b/src/mesh/NodeDB.cpp @@ -19,6 +19,7 @@ #include "SafeFile.h" #include "TransmitHistory.h" #include "TypeConversions.h" +#include "UptimeClock.h" #include "error.h" #include "gps/RTC.h" #include "main.h" @@ -98,11 +99,13 @@ static unsigned char userprefs_admin_key_2[] = USERPREFS_USE_ADMIN_KEY_2; // Weak empty variant initialization function. // May be redefined by variant files. -void variantDefaultConfig() __attribute__((weak)); -void variantDefaultConfig() {} +// noinline: weak default and call site share this TU, so LTO would inline the empty body and +// never link the variant's strong override. Same guard as earlyInitVariant() in main.cpp. +__attribute__((noinline)) void variantDefaultConfig() __attribute__((weak)); +__attribute__((noinline)) void variantDefaultConfig() {} -void variantDefaultModuleConfig() __attribute__((weak)); -void variantDefaultModuleConfig() {} +__attribute__((noinline)) void variantDefaultModuleConfig() __attribute__((weak)); +__attribute__((noinline)) void variantDefaultModuleConfig() {} #ifdef HELTEC_MESH_NODE_T114 @@ -486,12 +489,12 @@ NodeDB::NodeDB() preferences.begin("meshtastic", false); myNodeInfo.reboot_count = preferences.getUInt("rebootCounter", 0); preferences.end(); - LOG_DEBUG("Number of Device Reboots: %d", myNodeInfo.reboot_count); + LOG_DEBUG("Device reboots: %d", myNodeInfo.reboot_count); #endif // UA_868 is obsolete; migrate to EU_868 before resetRadioConfig() below validates the region. if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UA_868) { - LOG_INFO("UA_868 region is obsolete, migrating saved config to EU_868"); + LOG_INFO("UA_868 obsolete, migrating config to EU_868"); config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868; } @@ -504,7 +507,7 @@ NodeDB::NodeDB() // If we are setup to broadcast on any default channel slot (with default frequency slot semantics), // ensure that the telemetry intervals are coerced to the role-aware minimum value. if (channels.hasDefaultChannel()) { - LOG_DEBUG("Coerce telemetry to role-aware minimum on defaults"); + LOG_DEBUG("Coerce telemetry to role-aware min on defaults"); moduleConfig.telemetry.device_update_interval = Default::getConfiguredOrMinimumValue( moduleConfig.telemetry.device_update_interval, min_default_telemetry_interval_secs); moduleConfig.telemetry.environment_update_interval = Default::getConfiguredOrMinimumValue( @@ -527,7 +530,7 @@ NodeDB::NodeDB() } } if (positionUsesDefaultChannel) { - LOG_DEBUG("Coerce position broadcasts to role-aware minimum and smart broadcast min of 5 minutes on defaults"); + LOG_DEBUG("Coerce position broadcasts to role-aware min and smart broadcast min of 5 min on defaults"); config.position.position_broadcast_secs = Default::getConfiguredOrMinimumValue(config.position.position_broadcast_secs, min_default_broadcast_interval_secs); config.position.broadcast_smart_minimum_interval_secs = Default::getConfiguredOrMinimumValue( @@ -738,7 +741,7 @@ void NodeDB::resetRadioConfig(bool is_fresh_install) } if (channelFile.channels_count != MAX_NUM_CHANNELS) { - LOG_INFO("Set default channel and radio preferences!"); + LOG_INFO("Set default channel and radio prefs"); channels.initDefaults(); // Defaults ship the public PSK, so strip it again before onConfigChanged() publishes hashes; @@ -755,14 +758,14 @@ void NodeDB::resetRadioConfig(bool is_fresh_install) bool NodeDB::factoryReset(bool eraseBleBonds) { - LOG_INFO("Perform factory reset!"); + LOG_INFO("Factory reset"); // first, remove the "/prefs" (this removes most prefs) spiLock->lock(); rmDir("/prefs"); // this uses spilock internally... #ifdef FSCom if (FSCom.exists("/static/rangetest.csv") && !FSCom.remove("/static/rangetest.csv")) { - LOG_ERROR("Could not remove rangetest.csv file"); + LOG_ERROR("Can't remove rangetest.csv"); } #endif @@ -806,7 +809,7 @@ bool NodeDB::factoryReset(bool eraseBleBonds) #endif #ifdef ARCH_NRF52 - LOG_INFO("Clear bluetooth bonds!"); + LOG_INFO("Clear bluetooth bonds"); bond_print_list(BLE_GAP_ROLE_PERIPH); bond_print_list(BLE_GAP_ROLE_CENTRAL); Bluefruit.Periph.clearBonds(); @@ -884,7 +887,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false) // Restrict ROUTER*, LOST AND FOUND roles for security reasons if (IS_ONE_OF(USERPREFS_CONFIG_DEVICE_ROLE, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND)) { - LOG_WARN("ROUTER roles are restricted, falling back to CLIENT role"); + LOG_WARN("ROUTER roles restricted, fall back to CLIENT"); config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT; } else { config.device.role = USERPREFS_CONFIG_DEVICE_ROLE; @@ -983,7 +986,8 @@ void NodeDB::installDefaultConfig(bool preserveKey = false) if (shouldPreserveKey) { config.security.private_key.size = 32; memcpy(config.security.private_key.bytes, private_key_temp, config.security.private_key.size); - printBytes("Restored key", config.security.private_key.bytes, config.security.private_key.size); + // Never log the key bytes: debug logs get pasted into public bug reports. + LOG_DEBUG("Restored preserved private key"); } else { config.security.private_key.size = 0; } @@ -1628,7 +1632,7 @@ void NodeDB::resetNodes(bool keepFavorites) NodeNum ourNum = getNodeNum(); numMeshNodes = 1; if (keepFavorites) { - LOG_INFO("Clearing node database - preserving favorites"); + LOG_INFO("Clear node database, keep favorites"); // Compact favorites into contiguous low slots: zeroing in place leaves one above // numMeshNodes, invisible to every `i < numMeshNodes` scan yet still serialized to flash. for (size_t i = 1; i < meshNodes->size(); i++) { @@ -1643,7 +1647,7 @@ void NodeDB::resetNodes(bool keepFavorites) } std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite()); } else { - LOG_INFO("Clearing node database - removing favorites"); + LOG_INFO("Clear node database, remove favorites"); for (size_t i = 1; i < meshNodes->size(); i++) { const NodeNum gone = meshNodes->at(i).num; if (gone) @@ -1699,7 +1703,7 @@ void NodeDB::removeNodeByNum(NodeNum nodeNum) trafficManagementModule->purgeNode(nodeNum); #endif - LOG_DEBUG("NodeDB::removeNodeByNum purged %d entries. Save changes", removed); + LOG_DEBUG("NodeDB::removeNodeByNum purged %d entries, saving", removed); saveNodeDatabaseToDisk(); } @@ -2041,7 +2045,7 @@ void NodeDB::pickNewNodeNum() (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) { NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice if (found) - LOG_WARN("NOTE! Our desired nodenum 0x%08x is invalid or in use, picking 0x%08x", nodeNum, candidate); + LOG_WARN("NOTE! Desired nodenum 0x%08x invalid or in use, picking 0x%08x", nodeNum, candidate); nodeNum = candidate; } LOG_DEBUG("Use nodenum 0x%08x ", nodeNum); @@ -2073,11 +2077,11 @@ LoadFileResult NodeDB::loadProto(const char *filename, size_t protoSize, size_t if (fields != &meshtastic_NodeDatabase_msg) memset(dest_struct, 0, objSize); if (!pb_decode(&stream, fields, dest_struct)) { - LOG_ERROR("Error: can't decode protobuf %s", PB_GET_ERROR(&stream)); + LOG_ERROR("Can't decode protobuf %s", PB_GET_ERROR(&stream)); state = LoadFileResult::DECODE_FAILED; storageCorruptThisLoad = true; } else { - LOG_INFO("Loaded encrypted %s successfully", filename); + LOG_INFO("Loaded encrypted %s", filename); state = LoadFileResult::LOAD_SUCCESS; } } else { @@ -2101,18 +2105,18 @@ LoadFileResult NodeDB::loadProto(const char *filename, size_t protoSize, size_t fields != &meshtastic_NodeDatabase_Legacy_msg) // both NodeDatabase descriptors contain std::vector members memset(dest_struct, 0, objSize); if (!pb_decode(&stream, fields, dest_struct)) { - LOG_ERROR("Error: can't decode protobuf %s", PB_GET_ERROR(&stream)); + LOG_ERROR("Can't decode protobuf %s", PB_GET_ERROR(&stream)); state = LoadFileResult::DECODE_FAILED; } else { - LOG_INFO("Loaded %s successfully", filename); + LOG_INFO("Loaded %s", filename); state = LoadFileResult::LOAD_SUCCESS; } f.close(); } else { - LOG_ERROR("Could not open / read %s", filename); + LOG_ERROR("Can't open/read %s", filename); } #else - LOG_ERROR("ERROR: Filesystem not implemented"); + LOG_ERROR("Filesystem not implemented"); state = LoadFileResult::NO_FILESYSTEM; #endif return state; @@ -2251,7 +2255,7 @@ void NodeDB::loadFromDisk() spiLock->lock(); for (const char *filename : eventProfileFiles) { if (FSCom.exists(filename) && !FSCom.remove(filename)) - LOG_WARN("Unable to remove stale event profile file %s", filename); + LOG_WARN("Can't remove stale event profile file %s", filename); } spiLock->unlock(); #endif @@ -2269,7 +2273,7 @@ void NodeDB::loadFromDisk() const size_t usedBytes = fsUsedBytes(); eventProfileStorageUnavailable = !hasEventProfileStorageSpace(totalBytes, usedBytes); if (eventProfileStorageUnavailable) { - LOG_ERROR("Event profile requires %u bytes free; only %u bytes available. Profile changes will not persist.", + LOG_ERROR("Event profile needs %u bytes free; only %u available. Changes won't persist", static_cast(EVENT_PROFILE_STORAGE_RESERVATION_BYTES), static_cast(totalBytes >= usedBytes ? totalBytes - usedBytes : 0)); } @@ -2293,7 +2297,7 @@ void NodeDB::loadFromDisk() #if defined(FACTORY_INSTALL) && !defined(ARCH_PORTDUINO) spiLock->lock(); if (!FSCom.exists("/prefs/" xstr(BUILD_EPOCH))) { - LOG_WARN("Factory Install Reset!"); + LOG_WARN("Factory Install Reset"); rmDir("/prefs"); FSCom.mkdir("/prefs"); File f2 = FSCom.open("/prefs/" xstr(BUILD_EPOCH), FILE_O_WRITE); @@ -2307,11 +2311,11 @@ void NodeDB::loadFromDisk() spiLock->lock(); if (FSCom.exists(legacyPrefFileName)) { spiLock->unlock(); - LOG_WARN("Legacy prefs version found, factory resetting"); + LOG_WARN("Legacy prefs version, factory reset"); if (loadProto(configFileName, meshtastic_LocalConfig_size, sizeof(meshtastic_LocalConfig), &meshtastic_LocalConfig_msg, &config) == LoadFileResult::LOAD_SUCCESS && config.has_security && config.security.private_key.size > 0) { - LOG_DEBUG("Saving backup of security config and keys"); + LOG_DEBUG("Backup security config and keys"); backupSecurity = config.security; } spiLock->lock(); @@ -2332,7 +2336,7 @@ void NodeDB::loadFromDisk() // Encrypted storage is locked. Install defaults and wait for the // passphrase over BLE/serial; PhoneAPI::handleLockdownAuthInline // calls reloadFromDisk() once the storage is unlocked. - LOG_WARN("NodeDB: Encrypted storage locked, using default config until unlocked"); + LOG_WARN("NodeDB: Encrypted storage locked, default config until unlocked"); installDefaultNodeDatabase(); installDefaultDeviceState(); installDefaultConfig(); @@ -2443,7 +2447,7 @@ void NodeDB::loadFromDisk() // Attempt recovery of owner fields from our own NodeDB entry if available. const meshtastic_NodeInfoLite *us = getMeshNode(getNodeNum()); if (nodeInfoLiteHasUser(us)) { - LOG_WARN("Restoring owner fields (long_name/short_name/is_licensed/is_unmessagable) from NodeDB for our node 0x%08x", + LOG_WARN("Restore owner fields (long_name/short_name/is_licensed/is_unmessagable) from NodeDB for node 0x%08x", us->num); // owner.long_name (40) is wider than the lite source (25); bound by the source memcpy(owner.long_name, us->long_name, sizeof(us->long_name)); @@ -2458,7 +2462,7 @@ void NodeDB::loadFromDisk() saveToDisk(SEGMENT_DEVICESTATE); } } else { - LOG_INFO("Loaded saved devicestate version %d", devicestate.version); + LOG_INFO("Loaded saved devicestate v%d", devicestate.version); } // Devicestate saved by firmware that allowed 39-byte names gets clamped on @@ -2484,7 +2488,7 @@ void NodeDB::loadFromDisk() config.lora = eventLora; state = LoadFileResult::LOAD_SUCCESS; initializedEventConfig = true; - LOG_INFO("Initialized event config without modifying %s", STANDARD_CONFIG_FILE_NAME); + LOG_INFO("Init event config without modifying %s", STANDARD_CONFIG_FILE_NAME); } else { // Keep the event load outcome because loadProto() clears config before decoding. // A normal decode failure must not create a replacement identity. @@ -2498,7 +2502,7 @@ void NodeDB::loadFromDisk() // our NodeNum (== crc32(public_key)) and orphan us on the mesh. configDecodeFailed freezes identity and // skips persisting (see ctor), so a transient failure self-heals on the next clean boot. A genuinely // absent config returns OTHER_FAILURE, so this never fires on first boot. Boot degraded + radio-silent. - LOG_ERROR("Config decode failed - freezing identity, booting degraded (radio silent until restored)"); + LOG_ERROR("Config decode failed - freeze identity, boot degraded (radio silent until restored)"); configDecodeFailed = true; installDefaultConfig(true); config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET; @@ -2511,7 +2515,7 @@ void NodeDB::loadFromDisk() LOG_WARN("config %d is old, discard", config.version); installDefaultConfig(true); } else { - LOG_INFO("Loaded saved config version %d", config.version); + LOG_INFO("Loaded saved config v%d", config.version); } configLoadComplete = true; @@ -2559,12 +2563,12 @@ void NodeDB::loadFromDisk() // This is the first durable event-profile write. A failed write is // safe: normal files remain untouched and the next event boot retries. if (!saveToDisk(SEGMENT_CONFIG)) - LOG_ERROR("Unable to persist initial event config"); + LOG_ERROR("Can't persist initial event config"); } #endif if (backupSecurity.private_key.size > 0) { - LOG_DEBUG("Restoring backup of security config"); + LOG_DEBUG("Restore security config backup"); config.security = backupSecurity; saveToDisk(SEGMENT_CONFIG); } @@ -2583,7 +2587,7 @@ void NodeDB::loadFromDisk() } if (sum == 0) { numAdminKeys += 1; - LOG_INFO("Admin 0 key zero. Loading hard coded key from user preferences."); + LOG_INFO("Admin 0 key zero. Load hard coded key from user prefs"); memcpy(config.security.admin_key[0].bytes, userprefs_admin_key_0, 32); config.security.admin_key[0].size = 32; } @@ -2596,7 +2600,7 @@ void NodeDB::loadFromDisk() } if (sum == 0) { numAdminKeys += 1; - LOG_INFO("Admin 1 key zero. Loading hard coded key from user preferences."); + LOG_INFO("Admin 1 key zero. Load hard coded key from user prefs"); memcpy(config.security.admin_key[1].bytes, userprefs_admin_key_1, 32); config.security.admin_key[1].size = 32; } @@ -2609,14 +2613,14 @@ void NodeDB::loadFromDisk() } if (sum == 0) { numAdminKeys += 1; - LOG_INFO("Admin 2 key zero. Loading hard coded key from user preferences."); + LOG_INFO("Admin 2 key zero. Load hard coded key from user prefs"); memcpy(config.security.admin_key[2].bytes, userprefs_admin_key_2, 32); config.security.admin_key[2].size = 32; } #endif if (numAdminKeys > 0) { - LOG_INFO("Saving %d hard coded admin keys.", numAdminKeys); + LOG_INFO("Saving %d hard coded admin keys", numAdminKeys); config.security.admin_key_count = numAdminKeys; saveToDisk(SEGMENT_CONFIG); } @@ -2630,7 +2634,7 @@ void NodeDB::loadFromDisk() LOG_WARN("moduleConfig %d is old, discard", moduleConfig.version); installDefaultModuleConfig(); } else { - LOG_INFO("Loaded saved moduleConfig version %d", moduleConfig.version); + LOG_INFO("Loaded saved moduleConfig v%d", moduleConfig.version); } } @@ -2653,7 +2657,7 @@ void NodeDB::loadFromDisk() LOG_WARN("channelFile %d is old, discard", channelFile.version); installDefaultChannels(); } else { - LOG_INFO("Loaded saved channelFile version %d", channelFile.version); + LOG_INFO("Loaded saved channelFile v%d", channelFile.version); } } @@ -2705,7 +2709,7 @@ void NodeDB::loadFromDisk() if (activeBackupExists && !EncryptedStorage::isEncrypted(backupFileName)) { LOG_INFO("Migrating %s to encrypted storage", backupFileName); if (!EncryptedStorage::migrateFile(backupFileName)) { - LOG_ERROR("Unable to migrate %s to encrypted storage", backupFileName); + LOG_ERROR("Can't migrate %s to encrypted storage", backupFileName); storageCorruptThisLoad = true; } } @@ -2724,7 +2728,7 @@ void NodeDB::loadFromDisk() if (exists && !EncryptedStorage::isEncrypted(fn)) { LOG_INFO("Migrating inactive radio profile %s to encrypted storage", fn); if (!EncryptedStorage::migrateFile(fn)) { - LOG_ERROR("Unable to migrate %s to encrypted storage", fn); + LOG_ERROR("Can't migrate %s to encrypted storage", fn); storageCorruptThisLoad = true; } } @@ -2736,7 +2740,7 @@ void NodeDB::loadFromDisk() // 2.4.X - configuration migration to update new default intervals if (moduleConfig.version < 23) { - LOG_DEBUG("ModuleConfig version %d is stale, upgrading to new default intervals", moduleConfig.version); + LOG_DEBUG("ModuleConfig v%d stale, upgrade to new default intervals", moduleConfig.version); moduleConfig.version = DEVICESTATE_CUR_VER; if (moduleConfig.telemetry.device_update_interval == 900) moduleConfig.telemetry.device_update_interval = 0; @@ -2830,7 +2834,7 @@ bool NodeDB::reloadFromDisk() loadFromDisk(); if (storageCorruptThisLoad) { - LOG_ERROR("NodeDB: storage decrypt/decode failed during reload - surfacing as corrupt"); + LOG_ERROR("NodeDB: reload decrypt/decode failed - treat as corrupt"); // Leave the radio sleeping. Caller will lock storage and emit // a LOCKED(storage_corrupt) status; we must not reconfigure // the chip with the locked-default placeholder values still @@ -2875,7 +2879,7 @@ bool NodeDB::disableLockdownToPlaintext() moduleConfigFileName, deviceStateFileName, nodeDatabaseFileName}; for (const char *fn : filesToCheck) { if (!EncryptedStorage::migrateFileToPlaintext(fn)) { - LOG_ERROR("NodeDB: failed to revert %s to plaintext; aborting disable (device stays in lockdown)", fn); + LOG_ERROR("NodeDB: revert %s to plaintext failed; abort disable (stays in lockdown)", fn); return false; } } @@ -2904,7 +2908,7 @@ bool NodeDB::saveProto(const char *filename, size_t protoSize, const pb_msgdesc_ // do not try to save anything if power level is not safe. In many cases flash will be lock-protected // and all writes will fail anyway. Device should be sleeping at this point anyway. if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to saveProto() on unsafe device power level."); + LOG_ERROR("saveProto() on unsafe device power level"); return false; } @@ -2926,7 +2930,7 @@ bool NodeDB::saveProto(const char *filename, size_t protoSize, const pb_msgdesc_ pb_ostream_t stream = pb_ostream_from_buffer(pbBuf.get(), protoSize); if (!pb_encode(&stream, fields, dest_struct)) { - LOG_ERROR("Error: can't encode protobuf %s", PB_GET_ERROR(&stream)); + LOG_ERROR("Can't encode protobuf %s", PB_GET_ERROR(&stream)); return false; } @@ -2934,7 +2938,7 @@ bool NodeDB::saveProto(const char *filename, size_t protoSize, const pb_msgdesc_ bool ok = EncryptedStorage::encryptAndWrite(filename, pbBuf.get(), encodedSize, fullAtomic); if (!ok) { - LOG_ERROR("EncryptedStorage: Failed to encrypt and write %s", filename); + LOG_ERROR("EncryptedStorage: encrypt+write %s failed", filename); } return ok; } @@ -2948,7 +2952,7 @@ bool NodeDB::saveProto(const char *filename, size_t protoSize, const pb_msgdesc_ pb_ostream_t stream = {&writecb, static_cast(&f), protoSize}; if (!pb_encode(&stream, fields, dest_struct)) { - LOG_ERROR("Error: can't encode protobuf %s", PB_GET_ERROR(&stream)); + LOG_ERROR("Can't encode protobuf %s", PB_GET_ERROR(&stream)); } else { okay = true; } @@ -2956,10 +2960,10 @@ bool NodeDB::saveProto(const char *filename, size_t protoSize, const pb_msgdesc_ bool writeSucceeded = f.close(); if (!okay || !writeSucceeded) { - LOG_ERROR("Can't write prefs!"); + LOG_ERROR("Can't write prefs"); } #else - LOG_ERROR("ERROR: Filesystem not implemented"); + LOG_ERROR("Filesystem not implemented"); #endif return okay; } @@ -2970,7 +2974,7 @@ bool NodeDB::saveChannelsToDisk() // do not try to save anything if power level is not safe. In many cases flash will be lock-protected // and all writes will fail anyway. if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to saveChannelsToDisk() on unsafe device power level."); + LOG_ERROR("saveChannelsToDisk() on unsafe device power level"); return false; } @@ -2989,7 +2993,7 @@ bool NodeDB::saveDeviceStateToDisk() // do not try to save anything if power level is not safe. In many cases flash will be lock-protected // and all writes will fail anyway. Device should be sleeping at this point anyway. if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to saveDeviceStateToDisk() on unsafe device power level."); + LOG_ERROR("saveDeviceStateToDisk() on unsafe device power level"); return false; } @@ -3017,7 +3021,7 @@ bool NodeDB::saveNodeDatabaseToDisk() // do not try to save anything if power level is not safe. In many cases flash will be lock-protected // and all writes will fail anyway. Device should be sleeping at this point anyway. if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to saveNodeDatabaseToDisk() on unsafe device power level."); + LOG_ERROR("saveNodeDatabaseToDisk() on unsafe device power level"); return false; } @@ -3025,7 +3029,7 @@ bool NodeDB::saveNodeDatabaseToDisk() // would propagate through saveToDisk() and trigger fsFormat() mid-transfer. #ifdef FSCom if (xModem.isBusy()) { - LOG_DEBUG("Deferring NodeDB save: xmodem transfer in progress"); + LOG_DEBUG("Defer NodeDB save: xmodem in progress"); return true; } #endif @@ -3126,7 +3130,7 @@ bool NodeDB::saveToDiskNoRetry(int saveWhat) // do not try to save anything if power level is not safe. In many cases flash will be lock-protected // and all writes will fail anyway. Device should be sleeping at this point anyway. if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to saveToDiskNoRetry() on unsafe device power level."); + LOG_ERROR("saveToDiskNoRetry() on unsafe device power level"); return false; } @@ -3156,11 +3160,11 @@ bool NodeDB::saveToDiskNoRetry(int saveWhat) #if USERPREFS_EVENT_MODE if (eventProfileStorageUnavailable) { if (saveWhat & SEGMENT_CONFIG) { - LOG_WARN("Skipping event config write: insufficient profile storage at boot"); + LOG_WARN("Skip event config write: insufficient profile storage at boot"); saveWhat &= ~SEGMENT_CONFIG; } if (saveWhat & SEGMENT_CHANNELS) { - LOG_WARN("Skipping event channel write: insufficient profile storage at boot"); + LOG_WARN("Skip event channel write: insufficient profile storage at boot"); saveWhat &= ~SEGMENT_CHANNELS; } } @@ -3224,14 +3228,14 @@ bool NodeDB::saveToDisk(int saveWhat) // do not try to save anything if power level is not safe. In many cases flash will be lock-protected // and all writes will fail anyway. Device should be sleeping at this point anyway. if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to saveToDisk() on unsafe device power level."); + LOG_ERROR("saveToDisk() on unsafe device power level"); return false; } bool success = saveToDiskNoRetry(saveWhat); if (!success) { - LOG_ERROR("Failed to save to disk, retrying"); + LOG_ERROR("Save to disk failed, retry"); spiLock->lock(); fsFormat(); spiLock->unlock(); @@ -3267,7 +3271,7 @@ uint32_t sinceLastSeen(const meshtastic_NodeInfoLite *n) uint32_t sinceReceived(const meshtastic_MeshPacket *p) { - // rx_time may be a millis() placeholder while has_rx_time is false - don't age it as + // rx_time may be an uptime-seconds placeholder while has_rx_time is false - don't age it as // wall-clock, and don't pass it off as "just now" either. if (!p->has_rx_time) return SINCE_UNKNOWN; @@ -3433,9 +3437,9 @@ void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxS if (t.which_variant == meshtastic_Telemetry_device_metrics_tag) { if (src == RX_SRC_LOCAL) { - LOG_DEBUG("updateTelemetry LOCAL device"); + LOG_TRACE("updateTelemetry LOCAL device"); } else { - LOG_DEBUG("updateTelemetry REMOTE device node=0x%08x", nodeId); + LOG_TRACE("updateTelemetry REMOTE device node=0x%08x", nodeId); } #if !MESHTASTIC_EXCLUDE_TELEMETRYDB concurrency::LockGuard guard(&satelliteMutex); @@ -3445,9 +3449,9 @@ void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxS } else if (t.which_variant == meshtastic_Telemetry_environment_metrics_tag) { if (src == RX_SRC_LOCAL) { - LOG_DEBUG("updateTelemetry LOCAL env"); + LOG_TRACE("updateTelemetry LOCAL env"); } else { - LOG_DEBUG("updateTelemetry REMOTE env node=0x%08x", nodeId); + LOG_TRACE("updateTelemetry REMOTE env node=0x%08x", nodeId); } #if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB concurrency::LockGuard guard(&satelliteMutex); @@ -3481,7 +3485,16 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact) } } info->num = contact.node_num; + // CopyUserToNodeInfoLite assigns public_key unconditionally, and clients send add_contact before every + // DM - often from an entry that carries no key at all. A contact may still supply or update a full + // 32-byte key (that's what add_contact is for), but it must never *erase* a key we already hold, which + // would be persisted below and break subsequent DMs with PKI_SEND_FAIL_PUBLIC_KEY. + const meshtastic_NodeInfoLite_public_key_t storedKey = info->public_key; TypeConversions::CopyUserToNodeInfoLite(info, contact.user); + if (storedKey.size == 32 && info->public_key.size != 32) { + LOG_INFO("Contact 0x%08x has no key, keep the stored one", contact.node_num); + info->public_key = storedKey; + } if (contact.should_ignore) { // Block the contact and drop its rich satellite data, but keep the // public key copied above - an ignored peer keeps a usable identity @@ -3505,16 +3518,16 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact) if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) { // Special case for CLIENT_BASE: is_favorite has special meaning, and we don't want to automatically set it // without the user doing so deliberately. We don't normally expect users to use a CLIENT_BASE to send DMs or to add - // contacts, but we should make sure it doesn't auto-favorite in case they do. Instead, as a workaround, we'll set - // last_heard to now, so that the add_contact node doesn't immediately get evicted. - info->last_heard = getTime(); + // contacts, but we should make sure it doesn't auto-favorite in case they do. Instead, as a workaround, we'll + // stamp the contact as heard now, so that the add_contact node doesn't immediately get evicted. + stampContactHeardNow(info); } else { // Normal case: set is_favorite to prevent expiration. // last_heard will remain as-is (or remain 0 if this entry wasn't in the nodeDB). - // If the protected cap refuses the favorite, fall back to stamping last_heard so the + // If the protected cap refuses the favorite, fall back to a heard-now stamp so the // contact still isn't the first eviction victim. if (!setProtectedFlag(info, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true)) - info->last_heard = getTime(); + stampContactHeardNow(info); } // As the clients will begin sending the contact with DMs, we want to strictly check if the node is manually verified @@ -3537,7 +3550,7 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde // Only a signed update may change the identity of a proven signer; our own record is exempt. // Checked before getOrCreateMeshNode so a refusal cannot evict; isKnownXeddsaSigner covers the warm tier. if (nodeId != getNodeNum() && isKnownXeddsaSigner(nodeId) && !xeddsaSigned) { - LOG_WARN("Refusing unsigned identity update for node 0x%08x that previously signed", nodeId); + LOG_WARN("Refuse unsigned identity update for 0x%08x that previously signed", nodeId); return false; } @@ -3578,12 +3591,12 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde if (info->public_key.size == 32) { // if we have a key for this user already, don't overwrite with a new one // if the key doesn't match, don't update nodeDB at all. if (p.public_key.size != 32 || (memcmp(p.public_key.bytes, info->public_key.bytes, 32) != 0)) { - LOG_WARN("Public Key mismatch, dropping NodeInfo"); + LOG_WARN("Public Key mismatch, drop NodeInfo"); return false; } - LOG_INFO("Public Key set for node, not updating!"); + LOG_INFO("Public Key set, not updating"); } else if (p.public_key.size == 32) { - LOG_INFO("Update Node Pubkey!"); + LOG_INFO("Update Node Pubkey"); } #endif @@ -3618,7 +3631,7 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde saveToDisk(SEGMENT_NODEDATABASE); lastNodeDbSave = millis(); } else { - LOG_DEBUG("Defer NodeDB saveToDisk for now"); + LOG_DEBUG("Defer NodeDB saveToDisk"); } } @@ -3648,7 +3661,7 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp) return; } if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.from) { - LOG_DEBUG("Update DB node 0x%08x, rx_time=%u", mp.from, mp.rx_time); + LOG_TRACE("Update DB node 0x%08x, rx_time=%u", mp.from, mp.rx_time); // mp.from is unauthenticated, so rate-limit admission once the database is full: otherwise // invented node numbers churn it at packet rate and push real neighbours out. @@ -3667,9 +3680,13 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp) return; } - // Gate on has_rx_time, not truthiness - rx_time may hold a millis() placeholder. + // Gate on has_rx_time, not truthiness - rx_time may hold an uptime-seconds placeholder. if (mp.has_rx_time) info->last_heard = mp.rx_time; + else + // rx_time is the arrival instant in uptime seconds. It goes to the RAM sidecar, not + // last_heard, which only ever holds a real epoch or 0. + recordHeardWhileClockUntrusted(getFrom(&mp), mp.rx_time); // Gate on the packet actually having been received over our own radio, not on rx_snr being // truthy, because 0 dB is valid. TRANSPORT_LORA is set only on the real over-the-air RX path @@ -3852,7 +3869,7 @@ void NodeDB::sortMeshDB() } } } - LOG_INFO("Sort took %u milliseconds", millis() - lastSort); + LOG_INFO("Sort took %u ms", millis() - lastSort); } } @@ -4085,6 +4102,84 @@ meshtastic_Config_DeviceConfig_Role NodeDB::getNodeRole(NodeNum n) return meshtastic_Config_DeviceConfig_Role_CLIENT; } +void NodeDB::recordHeardWhileClockUntrusted(NodeNum num, uint32_t heardAtUptime) +{ + // Update in place if the node already has a stamp. + for (auto &h : heardAt) { + if (h.num == num) { + h.heardAtUptimeSecs = heardAtUptime; + return; + } + } + // Otherwise take an empty slot, or reuse the oldest stamp. + NodeHeardAt *victim = &heardAt[0]; + for (auto &h : heardAt) { + if (h.num == 0) { + victim = &h; + break; + } + if (h.heardAtUptimeSecs < victim->heardAtUptimeSecs) + victim = &h; + } + victim->num = num; + victim->heardAtUptimeSecs = heardAtUptime; +} + +bool NodeDB::getHeardAtUptimeSecs(NodeNum num, uint32_t &stamp) const +{ + for (const auto &h : heardAt) { + if (h.num == num) { + stamp = h.heardAtUptimeSecs; + return true; + } + } + return false; +} + +NodeDB::EvictionRecency NodeDB::evictionRecency(const meshtastic_NodeInfoLite *n) const +{ + uint32_t stamp = 0; + const bool heardThisBoot = getHeardAtUptimeSecs(n->num, stamp); + return {heardThisBoot ? stamp : n->last_heard, heardThisBoot}; +} + +bool NodeDB::evictionRecencyOlder(EvictionRecency candidate, EvictionRecency incumbent) +{ + if (candidate.heardThisBoot != incumbent.heardThisBoot) + return !candidate.heardThisBoot; + return candidate.value < incumbent.value; +} + +void NodeDB::stampContactHeardNow(meshtastic_NodeInfoLite *info) +{ + const uint32_t nowEpoch = getValidTime(RTCQualityFromNet); + if (nowEpoch) + info->last_heard = nowEpoch; + else + recordHeardWhileClockUntrusted(info->num, Time::getUptimeSecs()); +} + +void NodeDB::backfillHeardAt() +{ + const uint32_t nowEpoch = getValidTime(RTCQualityFromNet); + if (nowEpoch == 0) // called before the clock was actually valid - nothing to date against + return; + const uint32_t nowUptimeSecs = Time::getUptimeSecs(); + for (auto &h : heardAt) { + if (h.num == 0) + continue; + meshtastic_NodeInfoLite *info = getMeshNode(h.num); + if (info) { + // Both stamps are monotonic uptime seconds, so the elapsed term is exact at any age. + // Never move last_heard backwards: the node may since have been re-heard on a good clock. + const uint32_t elapsedSecs = nowUptimeSecs - h.heardAtUptimeSecs; + if (elapsedSecs < nowEpoch && nowEpoch - elapsedSecs > info->last_heard) + info->last_heard = nowEpoch - elapsedSecs; + } + h = {}; // evicted or converted either way, the stamp's job is done + } +} + /// Find a node in our DB, create an empty NodeInfo if missing meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n) { @@ -4092,11 +4187,12 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n) if (!lite) { if (isFull()) { - LOG_INFO("Node database full with %i nodes and %u bytes free. Erasing oldest entry", numMeshNodes, - memGet.getFreeHeap()); + LOG_INFO("Node database full: %i nodes, %u bytes free. Erase oldest", numMeshNodes, memGet.getFreeHeap()); // look for oldest node and erase it - uint32_t oldest = UINT32_MAX; - uint32_t oldestBoring = UINT32_MAX; + // Newest-possible sentinel: a zeroed init ranks older than every candidate, so nothing + // would ever be selected. Keep it maximal even though the index guards below also cover it. + EvictionRecency oldest = {UINT32_MAX, true}; + EvictionRecency oldestBoring = {UINT32_MAX, true}; int oldestIndex = -1; int oldestBoringIndex = -1; for (int i = 1; i < numMeshNodes; i++) { @@ -4104,14 +4200,19 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n) const bool isFavoriteNode = nodeInfoLiteIsFavorite(cand); const bool isIgnored = nodeInfoLiteIsIgnored(cand); const bool isVerified = nodeInfoLiteIsKeyManuallyVerified(cand); + // last_heard, except that nodes heard this boot before the clock became trusted + // rank by their RAM arrival stamp instead of the 0 in the stored field. + const EvictionRecency candRecency = evictionRecency(cand); // Simply the oldest non-favorite, non-ignored, non-verified node - if (!isFavoriteNode && !isIgnored && !isVerified && cand->last_heard < oldest) { - oldest = cand->last_heard; + if (!isFavoriteNode && !isIgnored && !isVerified && + (oldestIndex == -1 || evictionRecencyOlder(candRecency, oldest))) { + oldest = candRecency; oldestIndex = i; } // The oldest "boring" node - if (!isFavoriteNode && !isIgnored && cand->public_key.size == 0 && cand->last_heard < oldestBoring) { - oldestBoring = cand->last_heard; + if (!isFavoriteNode && !isIgnored && cand->public_key.size == 0 && + (oldestBoringIndex == -1 || evictionRecencyOlder(candRecency, oldestBoring))) { + oldestBoring = candRecency; oldestBoringIndex = i; } } @@ -4188,7 +4289,7 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n) } } #endif - LOG_INFO("Adding node to database with %i nodes and %u bytes free!", numMeshNodes, memGet.getFreeHeap()); + LOG_INFO("Add node to database: %i nodes, %u bytes free", numMeshNodes, memGet.getFreeHeap()); } return lite; @@ -4265,14 +4366,14 @@ bool NodeDB::generateCryptoKeyPair(const uint8_t *privateKey) if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) { keygenSuccess = true; } else { - LOG_ERROR("Failed to generate public key from provided private key"); + LOG_ERROR("Can't generate public key from private key"); return false; } } // Try to regenerate public key from existing private key if it's valid and not low entropy else if (config.security.private_key.size == 32 && !keyIsLowEntropy) { config.security.public_key.size = 32; - LOG_DEBUG("Regenerate PKI public key from existing private key"); + LOG_DEBUG("Regenerate PKI public key from private key"); if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) { keygenSuccess = true; } @@ -4332,7 +4433,7 @@ bool NodeDB::createNewIdentity() // still streamed to clients, and made any DM/admin aimed at it fail forever with PKI_SEND_FAIL_PUBLIC_KEY. // removeNodeByNum() drops the lite entry, its satellite stores, and the warm-tier copy. if (getMeshNode(oldNodeNum) != NULL) { - LOG_DEBUG("Old node num %u is now %u, removing stale identity", oldNodeNum, newNodeNum); + LOG_DEBUG("Old node num 0x%08x now 0x%08x, remove stale identity", oldNodeNum, newNodeNum); removeNodeByNum(oldNodeNum); } else { // Lite entry already absent: drop any orphaned satellite-store entries directly. @@ -4378,7 +4479,7 @@ bool NodeDB::backupPreferences(meshtastic_AdminMessage_BackupLocation location) if (success) { LOG_INFO("Saved backup preferences"); } else { - LOG_ERROR("Failed to save backup preferences to file"); + LOG_ERROR("Save backup prefs to file failed"); } } else if (location == meshtastic_AdminMessage_BackupLocation_SD) { // TODO: After more mainline SD card support @@ -4395,7 +4496,7 @@ bool NodeDB::restorePreferences(meshtastic_AdminMessage_BackupLocation location, spiLock->lock(); if (!FSCom.exists(backupFileName)) { spiLock->unlock(); - LOG_WARN("Could not restore. No backup file found"); + LOG_WARN("Can't restore, no backup file"); return false; } else { spiLock->unlock(); @@ -4430,12 +4531,12 @@ bool NodeDB::restorePreferences(meshtastic_AdminMessage_BackupLocation location, success = saveToDisk(restoreWhat); if (success) { - LOG_INFO("Restored preferences from backup"); + LOG_INFO("Restored prefs from backup"); } else { - LOG_ERROR("Failed to save restored preferences to flash"); + LOG_ERROR("Save restored prefs to flash failed"); } } else { - LOG_ERROR("Failed to restore preferences from backup file"); + LOG_ERROR("Restore prefs from backup failed"); } } else if (location == meshtastic_AdminMessage_BackupLocation_SD) { // TODO: After more mainline SD card support @@ -4459,7 +4560,7 @@ void recordCriticalError(meshtastic_CriticalErrorCode code, uint32_t address, co // Currently portuino is mostly used for simulation. Make sure the user notices something really bad happened #ifdef ARCH_PORTDUINO - LOG_ERROR("A critical failure occurred"); + LOG_ERROR("Critical failure"); // TODO: Determine if other critical errors should also cause an immediate exit if (code == meshtastic_CriticalErrorCode_FLASH_CORRUPTION_RECOVERABLE || code == meshtastic_CriticalErrorCode_FLASH_CORRUPTION_UNRECOVERABLE) diff --git a/src/mesh/NodeDB.h b/src/mesh/NodeDB.h index 0d45d1e1e4..e5b5a67acc 100644 --- a/src/mesh/NodeDB.h +++ b/src/mesh/NodeDB.h @@ -248,6 +248,14 @@ enum LoadFileResult { enum UserLicenseStatus { NotKnown, NotLicensed, Licensed }; +// RAM-only arrival stamp (monotonic uptime secs) for nodes heard before the wall clock was trusted, +// backfilled into last_heard as an epoch once it is. last_heard persists, so it cannot hold this. +// Bounded, linear-scan, reuse-oldest, never persisted - dies with the boot, as does its timebase. +struct NodeHeardAt { + NodeNum num = 0; ///< node this stamp describes; 0 == empty slot + uint32_t heardAtUptimeSecs = 0; ///< Time::getUptimeSecs() when last heard +}; + class NodeDB { // NodeNum provisionalNodeNum; // if we are trying to find a node num this is our current attempt @@ -308,6 +316,10 @@ class NodeDB void addFromContact(const meshtastic_SharedContact); + /// On the clock-becoming-trusted transition (see RTC.cpp): convert every RAM arrival stamp into + /// a real last_heard epoch, never backwards, then empty the table. updateFrom() takes over. + void backfillHeardAt(); + /** Update position info for this node based on received position data */ void updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSource src = RX_SRC_RADIO); @@ -638,6 +650,31 @@ class NodeDB uint32_t lastBackupAttempt = 0; // when we last tried a backup automatically or manually uint32_t lastSort = 0; // When last sorted the nodeDB + /// See NodeHeardAt. Caps how many distinct nodes can be dated once the clock arrives; a node + /// pushed out by reuse-oldest just stays "last heard: unknown", the same as before this table. + static constexpr size_t kMaxHeardAt = 32; + NodeHeardAt heardAt[kMaxHeardAt] = {}; + + /// Stamp (or re-stamp) a node's RAM arrival record; used instead of writing a non-epoch into + /// last_heard whenever the wall clock is untrusted. + void recordHeardWhileClockUntrusted(NodeNum num, uint32_t heardAtUptimeSecs); + + /// addFromContact's anti-eviction stamp: a real epoch when the clock is trusted, otherwise a + /// RAM arrival stamp that evictionRecency() honours - never a boot-relative last_heard. + void stampContactHeardNow(meshtastic_NodeInfoLite *info); + + /// Read the node's RAM arrival stamp. The boolean carries presence because uptime second 0 is valid. + bool getHeardAtUptimeSecs(NodeNum num, uint32_t &stamp) const; + + struct EvictionRecency { + uint32_t value; + bool heardThisBoot; + }; + + /// Eviction ranking with current-boot stamps newer than every persisted epoch. + EvictionRecency evictionRecency(const meshtastic_NodeInfoLite *n) const; + static bool evictionRecencyOlder(EvictionRecency candidate, EvictionRecency incumbent); + /* * Internal boolean to track sorting paused */ diff --git a/src/mesh/PacketHistory.cpp b/src/mesh/PacketHistory.cpp index aa4512a483..da745a25e7 100644 --- a/src/mesh/PacketHistory.cpp +++ b/src/mesh/PacketHistory.cpp @@ -64,13 +64,13 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd bool *wasUpgraded) { if (!initOk()) { - LOG_ERROR("Packet History - Was Seen Recently: NOT INITIALIZED!"); + LOG_ERROR("Packet History - Was Seen Recently: NOT INITIALIZED"); return false; } if (p->id == 0) { #if VERBOSE_PACKET_HISTORY - LOG_DEBUG("Packet History - Was Seen Recently: ID is 0, not a floodable message"); + LOG_DEBUG("Packet History - Was Seen Recently: ID 0, not floodable"); #endif return false; // Not a floodable message ID, so we don't care } @@ -107,8 +107,8 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd // Check for hop_limit upgrade scenario if (seenRecently && wasUpgraded && getHighestHopLimit(*found) < p->hop_limit) { - LOG_DEBUG("Packet History - Hop limit upgrade: packet 0x%08x from hop_limit=%d to hop_limit=%d", p->id, - getHighestHopLimit(*found), p->hop_limit); + LOG_TRACE("Packet History - Hop limit upgrade: packet 0x%08x hop_limit=%d -> %d", p->id, getHighestHopLimit(*found), + p->hop_limit); *wasUpgraded = true; } else if (wasUpgraded) { *wasUpgraded = false; // Initialize to false if not an upgrade @@ -234,7 +234,7 @@ void PacketHistory::hashInsert(NodeNum sender, PacketId id, uint16_t slotIdx) } bucket = (bucket + 1) & hashMask; } - LOG_ERROR("Packet History - hashInsert: table full or corrupted, rebuilding"); + LOG_ERROR("Packet History - hashInsert: table full or corrupt, rebuild"); hashRebuild(); } @@ -357,8 +357,7 @@ void PacketHistory::insert(const PacketRecord &r) it = (base + recentPacketsCapacity); } else { if (it->rxTimeMsec == 0) { - LOG_WARN("Packet History - insert: Found packet s=0x%08x id=0x%08x with rxTimeMsec = 0, slot %d/%d. Should never " - "happen!", + LOG_WARN("Packet History - insert: Found s=0x%08x id=0x%08x rxTimeMsec = 0, slot %d/%d. Should never happen", it->sender, it->id, it - base, recentPacketsCapacity); } if ((now_millis - it->rxTimeMsec) > OldtrxTimeMsec) { // 49.7 days rollover friendly @@ -373,7 +372,7 @@ void PacketHistory::insert(const PacketRecord &r) } if (tu == NULL) { - LOG_ERROR("Packet History - insert: No free slot, no matched packet, no oldest to reuse. Something leaked."); // mx + LOG_ERROR("Packet History - insert: No free/matched/oldest slot. Something leaked"); // mx // assert(false); // This should never happen, we should always have at least one packet to clear return; // Return early if we can't update the history } @@ -399,7 +398,7 @@ void PacketHistory::insert(const PacketRecord &r) } else { // debug only #if VERBOSE_PACKET_HISTORY - LOG_WARN("Packet History - insert: Reusing slot aged %.3fs < %ds with MATCHED PACKET - this is normal", + LOG_WARN("Packet History - insert: Reusing slot aged %.3fs < %ds with MATCHED PACKET - normal", OldtrxTimeMsec / 1000., RECENT_WARN_AGE / 1000); #endif } @@ -424,7 +423,7 @@ void PacketHistory::insert(const PacketRecord &r) if (r.rxTimeMsec == 0) { #if VERBOSE_PACKET_HISTORY - LOG_WARN("Packet History - insert: I will not store packet with rxTimeMsec = 0."); + LOG_WARN("Packet History - insert: Won't store packet with rxTimeMsec = 0"); #endif return; // Return early if we can't update the history } @@ -457,7 +456,7 @@ void PacketHistory::insert(const PacketRecord &r) bool PacketHistory::wasRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender, bool *wasSole) { if (!initOk()) { - LOG_ERROR("PacketHistory - wasRelayer: NOT INITIALIZED!"); + LOG_ERROR("PacketHistory - wasRelayer: NOT INITIALIZED"); return false; } @@ -527,7 +526,7 @@ void PacketHistory::checkRelayers(uint8_t relayer1, uint8_t relayer2, uint32_t i *r2WasSole = false; if (!initOk()) { - LOG_ERROR("PacketHistory - checkRelayers: NOT INITIALIZED!"); + LOG_ERROR("PacketHistory - checkRelayers: NOT INITIALIZED"); return; } @@ -545,7 +544,7 @@ void PacketHistory::checkRelayers(uint8_t relayer1, uint8_t relayer2, uint32_t i void PacketHistory::removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender) { if (!initOk()) { - LOG_ERROR("Packet History - remove Relayer: NOT INITIALIZED!"); + LOG_ERROR("Packet History - remove Relayer: NOT INITIALIZED"); return; } diff --git a/src/mesh/PhoneAPI.cpp b/src/mesh/PhoneAPI.cpp index f86d257739..45f9b2477e 100644 --- a/src/mesh/PhoneAPI.cpp +++ b/src/mesh/PhoneAPI.cpp @@ -216,11 +216,11 @@ static PhoneAuthSlot *findOrAllocSlot_LH(PhoneAPI *p) if (!s.authorized) { s.who = p; s.epoch = 0; - LOG_WARN("Lockdown: auth slot table full, evicted stale unauthorized slot for new PhoneAPI %p", p); + LOG_WARN("Lockdown: auth slots full, evicted stale unauthorized slot for new PhoneAPI %p", p); return &s; } } - LOG_WARN("Lockdown: auth slot table full of authorized sessions, refusing new PhoneAPI %p (fail-closed)", p); + LOG_WARN("Lockdown: auth slots full of authorized sessions, refuse new PhoneAPI %p (fail-closed)", p); return nullptr; } @@ -304,7 +304,7 @@ void PhoneAPI::handleStartConfig() if (config_nonce == SPECIAL_NONCE_ONLY_NODES) { // If client only wants node info, jump directly to sending nodes state = STATE_SEND_OWN_NODEINFO; - LOG_INFO("Client only wants node info, skipping other config"); + LOG_INFO("Client only wants node info, skip other config"); } else { state = STATE_SEND_MY_INFO; } @@ -457,7 +457,7 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength) ourNum != 0 && toRadioScratch.packet.which_payload_variant == meshtastic_MeshPacket_decoded_tag && toRadioScratch.packet.decoded.portnum == meshtastic_PortNum_ADMIN_APP && toRadioScratch.packet.to == ourNum; if (!isLocalAdmin) { - LOG_INFO("Lockdown: Dropping non-admin ToRadio packet from unauthorized client"); + LOG_INFO("Lockdown: Drop non-admin ToRadio packet from unauthorized client"); return false; } } @@ -475,7 +475,7 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength) case meshtastic_ToRadio_xmodemPacket_tag: #ifdef MESHTASTIC_PHONEAPI_ACCESS_CONTROL if (!getAdminAuthorized()) { - LOG_INFO("Lockdown: Dropping xmodem packet from unauthorized client"); + LOG_INFO("Lockdown: Drop xmodem packet from unauthorized client"); break; } #endif @@ -486,17 +486,16 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength) break; #if !MESHTASTIC_EXCLUDE_MQTT case meshtastic_ToRadio_mqttClientProxyMessage_tag: - LOG_DEBUG("Got MqttClientProxy message"); + LOG_TRACE("Got MqttClientProxy message"); if (state != STATE_SEND_PACKETS) { - LOG_WARN("Ignore MqttClientProxy message while completing config handshake"); + LOG_WARN("Ignore MqttClientProxy msg during config handshake"); break; } if (mqtt && moduleConfig.mqtt.proxy_to_client_enabled && moduleConfig.mqtt.enabled && (channels.anyMqttEnabled() || moduleConfig.mqtt.map_reporting_enabled)) { mqtt->onClientProxyReceive(toRadioScratch.mqttClientProxyMessage); } else { - LOG_WARN("MqttClientProxy received but proxy is not enabled, no channels have up/downlink, or map reporting " - "not enabled"); + LOG_WARN("MqttClientProxy received but proxy disabled, no up/downlink channels, or map reporting off"); } break; #endif @@ -511,11 +510,11 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength) // a queue-status reply. if (toRadioScratch.heartbeat.nonce == 1) { if (nodeInfoModule) { - LOG_INFO("Broadcasting nodeinfo ping (serial)"); + LOG_INFO("Broadcast nodeinfo ping (serial)"); nodeInfoModule->sendOurNodeInfo(NODENUM_BROADCAST, true, 0, true); } } else { - LOG_DEBUG("Got client heartbeat"); + LOG_TRACE("Got client heartbeat"); heartbeatReceived = true; } break; @@ -524,7 +523,7 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength) break; } } else { - LOG_ERROR("Error: ignore malformed toradio"); + LOG_ERROR("Ignore malformed toradio"); } return false; @@ -559,7 +558,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) fromRadioScratch.queueStatus = router->getQueueStatus(); heartbeatReceived = false; size_t numbytes = pb_encode_to_bytes(buf, meshtastic_FromRadio_size, &meshtastic_FromRadio_msg, &fromRadioScratch); - LOG_DEBUG("FromRadio=STATE_SEND_QUEUE_STATUS, numbytes=%u", numbytes); + LOG_TRACE("FromRadio=STATE_SEND_QUEUE_STATUS, numbytes=%u", (unsigned)numbytes); return numbytes; } @@ -572,7 +571,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) // Advance states as needed switch (state) { case STATE_SEND_NOTHING: - LOG_DEBUG("FromRadio=STATE_SEND_NOTHING"); + LOG_TRACE("FromRadio=STATE_SEND_NOTHING"); break; case STATE_SEND_MY_INFO: LOG_DEBUG("FromRadio=STATE_SEND_MY_INFO"); @@ -616,6 +615,9 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) auto info = TypeConversions::ConvertToNodeInfo(us); info.has_hops_away = false; info.is_favorite = true; + // NodeInfoLite dropped macaddr, so ConvertToUser() zero-fills it. + if (info.has_user) + memcpy(info.user.macaddr, owner.macaddr, sizeof(info.user.macaddr)); { concurrency::LockGuard guard(&nodeInfoMutex); nodeInfoForPhone = info; @@ -970,6 +972,14 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) } if (infoToSend.num != 0) { + // A record prefetched before the clock became trusted carries last_heard == 0 even + // once the store is backfilled, so re-read it at send time: handshake ordering + // (time-set vs node-list download) must not decide what the phone sees. + if (infoToSend.last_heard == 0 && infoToSend.num != nodeDB->getNodeNum()) { + const meshtastic_NodeInfoLite *fresh = nodeDB->getMeshNode(infoToSend.num); + if (fresh) + infoToSend.last_heard = fresh->last_heard; + } // Just in case we stored a different user.id in the past, but should never happen going forward sprintf(infoToSend.user.id, "!%08x", infoToSend.num); @@ -1000,7 +1010,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) } else { fromRadioScratch.which_payload_variant = meshtastic_FromRadio_fileInfo_tag; fromRadioScratch.fileInfo = filesManifest.at(config_state); - LOG_DEBUG("File: %s (%d) bytes", fromRadioScratch.fileInfo.file_name, fromRadioScratch.fileInfo.size_bytes); + LOG_TRACE("File: %s (%d) bytes", fromRadioScratch.fileInfo.file_name, fromRadioScratch.fileInfo.size_bytes); config_state++; } break; @@ -1013,7 +1023,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) case STATE_SEND_PACKETS: pauseBluetoothLogging = false; // Do we have a message from the mesh or packet from the local device? - LOG_DEBUG("FromRadio=STATE_SEND_PACKETS"); + LOG_TRACE("FromRadio=STATE_SEND_PACKETS"); if (queueStatusPacketForPhone) { fromRadioScratch.which_payload_variant = meshtastic_FromRadio_queueStatus_tag; fromRadioScratch.queueStatus = *queueStatusPacketForPhone; @@ -1098,7 +1108,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf) return numbytes; } - LOG_DEBUG("No FromRadio packet available"); + LOG_TRACE("No FromRadio packet available"); return 0; } @@ -1202,7 +1212,7 @@ void PhoneAPI::prefetchNodeInfos() nodeInfoQueue.push_back(info); // Log progress here (at fetch time) so readIndex is accurate and each value logs only once. if (readIndex == 2 || readIndex % 20 == 0) { - LOG_DEBUG("nodeinfo: %d/%d", readIndex, nodeDB->getNumMeshNodes()); + LOG_TRACE("nodeinfo: %d/%d", readIndex, nodeDB->getNumMeshNodes()); } added = true; } @@ -1804,7 +1814,7 @@ bool PhoneAPI::handleToRadioPacket(meshtastic_MeshPacket &p) return true; } case LocalAdminGate::DropUnauthorized: - LOG_WARN("Lockdown: dropping admin payload variant=%d from unauthorized connection", admin.which_payload_variant); + LOG_WARN("Lockdown: drop admin payload variant=%d from unauthorized connection", admin.which_payload_variant); return false; case LocalAdminGate::NotAdmin: case LocalAdminGate::AuthorizedPassThrough: @@ -1813,12 +1823,22 @@ bool PhoneAPI::handleToRadioPacket(meshtastic_MeshPacket &p) } #endif + // Reject before recording duplicate or per-port cooldown state, so a blocked + // attempt cannot throttle a valid private-channel position retry. + if (isBlockedEventCoordinatePacket(&p)) { + LOG_DEBUG("Suppress phone coordinate send on event (everyone) channel"); + meshtastic_QueueStatus qs = router->getQueueStatus(); + service->sendQueueStatusToPhone(qs, 0, p.id); + sendNotification(meshtastic_LogRecord_Level_WARNING, p.id, "Location sharing is disabled on this channel"); + return false; + } + #if defined(ARCH_PORTDUINO) // For use with the simulator, we should not ignore duplicate packets from the phone if (SimRadio::instance == nullptr) #endif if (p.id > 0 && wasSeenRecently(p.id)) { - LOG_DEBUG("Ignore packet from phone, already seen recently"); + LOG_DEBUG("Ignore phone packet, seen recently"); return false; } @@ -1878,7 +1898,7 @@ int PhoneAPI::onNotify(uint32_t newValue) // doesn't call this from idle) if (state == STATE_SEND_PACKETS) { - LOG_INFO("Tell client we have new packets %u", newValue); + LOG_INFO("Tell client new packets %u", newValue); onNowHasData(newValue); } else { LOG_DEBUG("Client not yet interested in packets (state=%d)", state); @@ -2049,7 +2069,7 @@ bool PhoneAPI::handleLockdownAuthInline(const meshtastic_LockdownAuth &la) zeroPassphrase(); return true; } - LOG_INFO("Lockdown: LOCK NOW command received from authorized connection"); + LOG_INFO("Lockdown: LOCK NOW from authorized connection"); EncryptedStorage::lockNow(); revokeAllAuth(); queueLockdownStatus(meshtastic_LockdownStatus_State_LOCKED, "", 0, 0, 0); @@ -2073,7 +2093,7 @@ bool PhoneAPI::handleLockdownAuthInline(const meshtastic_LockdownAuth &la) } if (!EncryptedStorage::isLockdownActive()) { // Already off - nothing to do; report DISABLED so the client UI settles. - LOG_INFO("Lockdown: disable requested but lockdown is not active"); + LOG_INFO("Lockdown: disable requested but not active"); queueLockdownStatus(meshtastic_LockdownStatus_State_DISABLED, "", 0, 0, 0); zeroPassphrase(); return true; @@ -2156,7 +2176,7 @@ bool PhoneAPI::handleLockdownAuthInline(const meshtastic_LockdownAuth &la) slot->pendingUnlockAfterReload = true; } lockdownReloadPending = true; - LOG_INFO("Lockdown: storage unlocked, awaiting reload before client visibility"); + LOG_INFO("Lockdown: storage unlocked, await reload before client visibility"); } } else { LOG_INFO("Lockdown: passphrase re-verify for admin authorization"); @@ -2166,7 +2186,7 @@ bool PhoneAPI::handleLockdownAuthInline(const meshtastic_LockdownAuth &la) // Storage was already unlocked - no reload needed. Authorize // and surface UNLOCKED to the client immediately. setAdminAuthorized(true); - LOG_INFO("Lockdown: passphrase verified, this connection authorized"); + LOG_INFO("Lockdown: passphrase verified, connection authorized"); } } diff --git a/src/mesh/PositionPrecision.cpp b/src/mesh/PositionPrecision.cpp index 4302531a5b..d34c660861 100644 --- a/src/mesh/PositionPrecision.cpp +++ b/src/mesh/PositionPrecision.cpp @@ -16,6 +16,10 @@ uint32_t getPositionPrecisionForChannel(const meshtastic_Channel &channel) uint32_t getPositionPrecisionForChannel(uint8_t channelIndex) { + // Event-channel privacy takes precedence over every stored precision and key policy. + if (channels.isEventChannel(channelIndex)) + return 0; + const meshtastic_Channel &ch = channels.getByIndex(channelIndex); if (ch.role == meshtastic_Channel_Role_DISABLED) return 0; diff --git a/src/mesh/ProtobufModule.h b/src/mesh/ProtobufModule.h index 1d1441c4db..b79867163c 100644 --- a/src/mesh/ProtobufModule.h +++ b/src/mesh/ProtobufModule.h @@ -94,7 +94,7 @@ template class ProtobufModule : protected SinglePortModule LOG_INFO("Received %s from=0x%08x, id=0x%08x, portnum=%d, payloadlen=%d", name, mp.from, mp.id, p.portnum, p.payload.size); } else { - LOG_ERROR("Error decoding proto module!"); + LOG_ERROR("Error decoding proto module"); // if we can't decode it, nobody can process it! return ProcessMessage::STOP; } @@ -115,7 +115,7 @@ template class ProtobufModule : protected SinglePortModule if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding proto module!"); + LOG_ERROR("Error decoding proto module"); // if we can't decode it, nobody can process it! return; } diff --git a/src/mesh/RF95Interface.cpp b/src/mesh/RF95Interface.cpp index 26a765ea87..6968b5654e 100644 --- a/src/mesh/RF95Interface.cpp +++ b/src/mesh/RF95Interface.cpp @@ -201,7 +201,7 @@ bool RF95Interface::init() return res == RADIOLIB_ERR_NONE; } -void RF95Interface::disableInterrupt() +void RF95Interface::clearRadioIsr() { lora->clearDio0Action(); } @@ -318,14 +318,14 @@ bool RF95Interface::isChannelActive() result = lora->scanChannel(); if (result == RADIOLIB_PREAMBLE_DETECTED) { - // LOG_DEBUG("Channel is busy!"); + // LOG_DEBUG("Channel is busy"); return true; } if (result != RADIOLIB_CHANNEL_FREE) LOG_ERROR("RF95 isChannelActive %s%d", radioLibErr, result); assert(result != RADIOLIB_ERR_WRONG_MODEM); - // LOG_DEBUG("Channel is free!"); + // LOG_DEBUG("Channel is free"); return false; } diff --git a/src/mesh/RF95Interface.h b/src/mesh/RF95Interface.h index 2226067646..e01dfe3768 100644 --- a/src/mesh/RF95Interface.h +++ b/src/mesh/RF95Interface.h @@ -35,14 +35,14 @@ class RF95Interface : public RadioLibInterface /** * Glue functions called from ISR land */ - virtual void disableInterrupt() override; + virtual void clearRadioIsr() override; int16_t getCurrentRSSI() override; /** * Enable a particular ISR callback glue function */ - virtual void enableInterrupt(void (*callback)()) { lora->setDio0Action(callback, RISING); } + virtual void setRadioIsr(void (*callback)()) override { lora->setDio0Action(callback, RISING); } /** can we detect a LoRa preamble on the current channel? */ virtual bool isChannelActive() override; diff --git a/src/mesh/RadioInterface.cpp b/src/mesh/RadioInterface.cpp index 208e8603d9..5c757cd849 100644 --- a/src/mesh/RadioInterface.cpp +++ b/src/mesh/RadioInterface.cpp @@ -692,7 +692,7 @@ void getRegionPresetMap(meshtastic_LoRaRegionPresetMap &map) // log once and stop. An incomplete map means clients won't constrain the // omitted regions, so this must be discoverable rather than silent. if (map.region_groups_count >= maxRegions) { - LOG_ERROR("Region preset map full at %u regions; remaining regions omitted", (unsigned)maxRegions); + LOG_ERROR("Region preset map full at %u regions; rest omitted", (unsigned)maxRegions); break; } @@ -832,11 +832,11 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(meshtastic_MeshPacket *p) // LOG_DEBUG("rx_snr of %f so setting CWsize to:%d", snr, CWsize); if (shouldRebroadcastEarlyLikeRouter(p)) { delay = random(0, 2 * CWsize) * slotTimeMsec; - LOG_DEBUG("rx_snr found in packet. Router: setting tx delay:%d", delay); + LOG_DEBUG("rx_snr in packet. Router: tx delay:%d", delay); } else { // offset the maximum delay for routers: (2 * CWmax * slotTimeMsec) delay = (2 * CWmax * slotTimeMsec) + random(0, pow_of_2(CWsize)) * slotTimeMsec; - LOG_DEBUG("rx_snr found in packet. Setting tx delay:%d", delay); + LOG_DEBUG("rx_snr in packet. Tx delay:%d", delay); } return delay; @@ -1108,7 +1108,7 @@ bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraCo // Validation must still fail so callers route into the clamp, but quietly: // the clamp will accept this config by swapping regions, so don't record a // critical error or alarm the user over a change that is about to succeed. - LOG_INFO("Preset %s implies region swap %s to %s, deferring to clamp", presetName, newRegion->name, + LOG_INFO("Preset %s implies region swap %s to %s, defer to clamp", presetName, newRegion->name, swapRegion->name); return false; } @@ -1263,7 +1263,7 @@ void RadioInterface::applyModemConfig() // If custom CR is being used already, check if the new preset is higher if (loraConfig.coding_rate >= 5 && loraConfig.coding_rate <= 8 && loraConfig.coding_rate < newcr) { cr = newcr; - LOG_INFO("Default Coding Rate is higher than custom setting, using %u", cr); + LOG_INFO("Default Coding Rate above custom setting, use %u", cr); } // If the custom CR is higher than the preset, use it else if (loraConfig.coding_rate >= 5 && loraConfig.coding_rate <= 8 && loraConfig.coding_rate > newcr) { @@ -1276,8 +1276,7 @@ void RadioInterface::applyModemConfig() } else { // if not using preset, then just use the custom settings if (validateConfigLora(loraConfig)) { } else { - LOG_WARN("Invalid LoRa config settings, cannot apply requested modem config - falling back to %s defaults", - newRegion->name); + LOG_WARN("Invalid LoRa config, can't apply modem config - fall back to %s defaults", newRegion->name); clampConfigLora(loraConfig); } // Clamp at the source so numFreqSlots below can never be 0 (a bandwidth-0 config may already be persisted) @@ -1370,9 +1369,9 @@ void RadioInterface::applyModemConfig() newRegion->freqEnd - newRegion->freqStart); LOG_INFO("numFreqSlots: %u x %.3fkHz", numFreqSlots, bw); if (newRegion->overrideSlot > 0) { - LOG_INFO("Using region explicit override slot: %d", newRegion->overrideSlot); + LOG_INFO("Region explicit override slot: %d", newRegion->overrideSlot); } else if (newRegion->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) { - LOG_INFO("Using region preset name hash for slot selection"); + LOG_INFO("Use region preset name hash for slot"); } LOG_INFO("channel_num: %d", channel_num + 1); LOG_INFO("frequency: %f", getFreq()); @@ -1410,7 +1409,7 @@ void RadioInterface::limitPower(int8_t loraMaxPower) maxPower = myRegion->powerLimit; if ((power > maxPower) && !devicestate.owner.is_licensed) { - LOG_INFO("Lower transmit power because of regulatory limits"); + LOG_INFO("Lower Tx power: regulatory limits"); power = maxPower; } @@ -1477,7 +1476,7 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p) radioBuffer.header.next_hop = p->next_hop; radioBuffer.header.relay_node = p->relay_node; if (p->hop_limit > HOP_MAX) { - LOG_WARN("hop limit %d is too high, setting to %d", p->hop_limit, HOP_RELIABLE); + LOG_WARN("hop limit %d too high, set to %d", p->hop_limit, HOP_RELIABLE); p->hop_limit = HOP_RELIABLE; } radioBuffer.header.flags = diff --git a/src/mesh/RadioLibInterface.cpp b/src/mesh/RadioLibInterface.cpp index 5a9b292cda..a826a51318 100644 --- a/src/mesh/RadioLibInterface.cpp +++ b/src/mesh/RadioLibInterface.cpp @@ -107,7 +107,7 @@ bool RadioLibInterface::canSendImmediately() // If we've been trying to send the same packet more than one minute and we haven't gotten a // TX IRQ from the radio, the radio is probably broken. if (busyTx && !Throttle::isWithinTimespanMs(lastTxStart, 60000)) { - LOG_ERROR("Hardware Failure! busyTx for more than 60s"); + LOG_ERROR("Hardware Failure! busyTx >60s"); RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_TRANSMIT_FAILED); // reboot in 5 seconds when this condition occurs. rebootAtMsec = lastTxStart + 65000; @@ -131,14 +131,14 @@ bool RadioLibInterface::receiveDetected(uint16_t irq, unsigned long syncWordHead if (!(irq & syncWordHeaderValidFlag)) { // The HEADER_VALID flag should be set by now if it was really a packet, so ignore PREAMBLE_DETECTED flag activeReceiveStart = 0; - LOG_DEBUG("Ignore false preamble detection"); + LOG_TRACE("Ignore false preamble detection"); return false; } else { uint32_t maxPacketTimeMsec = getPacketTime(meshtastic_Constants_DATA_PAYLOAD_LEN + sizeof(PacketHeader)); if (!Throttle::isWithinTimespanMs(activeReceiveStart, maxPacketTimeMsec)) { // We should have gotten an RX_DONE IRQ by now if it was really a packet, so ignore HEADER_VALID flag activeReceiveStart = 0; - LOG_DEBUG("Ignore false header detection"); + LOG_TRACE("Ignore false header detection"); return false; } } @@ -187,7 +187,7 @@ ErrorCode RadioLibInterface::send(meshtastic_MeshPacket *p) #ifndef LORA_DISABLE_SENDING printPacket("enqueue for send", p); - LOG_DEBUG("txGood=%d,txRelay=%d,rxGood=%d,rxBad=%d", txGood, txRelay, rxGood, rxBad); + LOG_TRACE("txGood=%d,txRelay=%d,rxGood=%d,rxBad=%d", txGood, txRelay, rxGood, rxBad); bool dropped = false; ErrorCode res = txQueue.enqueue(p, &dropped) ? ERRNO_OK : ERRNO_UNKNOWN; @@ -290,7 +290,7 @@ void RadioLibInterface::updateNoiseFloor() currentNoiseFloor = getAverageNoiseFloorInternal(); - LOG_DEBUG("Noise floor: %d dBm (samples: %d, latest: %d dBm)", currentNoiseFloor, getNoiseFloorSampleCountInternal(), rssi); + LOG_TRACE("Noise floor: %d dBm (samples: %d, latest: %d dBm)", currentNoiseFloor, getNoiseFloorSampleCountInternal(), rssi); } uint8_t RadioLibInterface::getNoiseFloorSampleCountInternal() const @@ -339,7 +339,7 @@ void RadioLibInterface::resetNoiseFloor() currentSampleIndex = 0; isNoiseFloorBufferFull = false; currentNoiseFloor = NOISE_FLOOR_DEFAULT; - LOG_INFO("Noise floor reset - rolling window collection will restart"); + LOG_INFO("Noise floor reset - rolling window will restart"); } bool RadioLibInterface::randomBytes(uint8_t *buffer, size_t length) @@ -445,7 +445,7 @@ void RadioLibInterface::onNotify(uint32_t notification) // The beacon's target radio config is invalid (bad preset/region, or an // unlicensed node keying up on a ham-only region). Drop the packet - never // transmit it on the current (home) config - and move on to the next queued packet. - LOG_DEBUG("Beacon: invalid TX radio config, dropping packet 0x%08x", txp->id); + LOG_DEBUG("Beacon: invalid TX radio config, drop packet 0x%08x", txp->id); meshtastic_MeshPacket *bad = txQueue.dequeue(); MeshBeaconModule::clearTargetRadioSettings(bad); packetPool.release(bad); @@ -468,7 +468,7 @@ void RadioLibInterface::onNotify(uint32_t notification) txp = txQueue.dequeue(); assert(txp); startSend(txp); - LOG_DEBUG("%d packets remain in the TX queue", txQueue.getMaxLen() - txQueue.getFree()); + LOG_TRACE("%d packets in TX queue", txQueue.getMaxLen() - txQueue.getFree()); } } } @@ -505,7 +505,7 @@ void RadioLibInterface::setTransmitDelay() startTransmitTimer(true); } else { // If there is a SNR, start a timer scaled based on that SNR. - LOG_DEBUG("rx_snr found. hop_limit:%d rx_snr:%f", p->hop_limit, p->rx_snr); + LOG_TRACE("rx_snr found. hop_limit:%d rx_snr:%f", p->hop_limit, p->rx_snr); startTransmitTimerRebroadcast(p); } } @@ -539,7 +539,7 @@ void RadioLibInterface::clampToLateRebroadcastWindow(NodeNum from, PacketId id) p->tx_after = millis() + getTxDelayMsecWeightedWorst(p->rx_snr); bool dropped = false; if (txQueue.enqueue(p, &dropped)) { - LOG_DEBUG("Move existing queued packet to the late rebroadcast window %dms from now", p->tx_after - millis()); + LOG_TRACE("Move queued packet to late rebroadcast window %ums from now", (uint32_t)(p->tx_after - millis())); } else { packetPool.release(p); } @@ -557,7 +557,7 @@ bool RadioLibInterface::removePendingTXPacket(NodeNum from, PacketId id, uint32_ { meshtastic_MeshPacket *p = txQueue.remove(from, id, true, true, hop_limit_lt); if (p) { - LOG_DEBUG("Dropping pending-TX packet 0x%08x with hop limit %d", p->id, p->hop_limit); + LOG_DEBUG("Drop pending-TX packet 0x%08x, hop limit %d", p->id, p->hop_limit); packetPool.release(p); return true; } @@ -607,7 +607,7 @@ void RadioLibInterface::handleReceiveInterrupt() // when this is called, we should be in receive mode - if we are not, just jump out instead of bombing. Possible Race // Condition? if (!isReceiving) { - LOG_ERROR("handleReceiveInterrupt called when not in rx mode, which shouldn't happen"); + LOG_ERROR("handleReceiveInterrupt called while not in rx mode"); return; } @@ -616,6 +616,13 @@ void RadioLibInterface::handleReceiveInterrupt() // read the number of actually received bytes size_t length = iface->getPacketLength(); + // Some drivers report this as a 16 bit value, so a bad readback can overrun radioBuffer in readData() + if (length > sizeof(radioBuffer)) { + LOG_ERROR("Ignore rx packet, bad length %u", (unsigned int)length); + rxBad++; + return; + } + uint32_t rxMsec = getPacketTime(length, true); #ifndef DISABLE_WELCOME_UNSET @@ -634,7 +641,7 @@ void RadioLibInterface::handleReceiveInterrupt() #endif if (state != RADIOLIB_ERR_NONE) { // Log PacketHeader similar to RadioInterface::printPacket so we can try to match RX errors to other packets in the logs. - LOG_ERROR("Ignore received packet due to error=%d (maybe id=0x%08x fr=0x%08x to=0x%08x flags=0x%02x rxSNR=%g rxRSSI=%i " + LOG_ERROR("Ignore rx packet, error=%d (maybe id=0x%08x fr=0x%08x to=0x%08x flags=0x%02x rxSNR=%g rxRSSI=%i " "nextHop=0x%x relay=0x%x)", state, radioBuffer.header.id, radioBuffer.header.from, radioBuffer.header.to, radioBuffer.header.flags, iface->getSNR(), lround(iface->getRSSI()), radioBuffer.header.next_hop, radioBuffer.header.relay_node); @@ -759,7 +766,7 @@ bool RadioLibInterface::startSend(meshtastic_MeshPacket *txp) /* NOTE: Minimize the actions before startTransmit() to keep the time between channel scan and actual transmit as low as possible to avoid collisions. */ if (disabled || !config.lora.tx_enabled) { - LOG_WARN("Drop Tx packet because LoRa Tx disabled"); + LOG_WARN("Drop Tx packet: LoRa Tx disabled"); #if !MESHTASTIC_EXCLUDE_BEACON // This packet may have already triggered a beacon radio switch in TRANSMIT_DELAY_COMPLETED; // since it never reaches completeSending() here, restore the radio so it isn't left on the diff --git a/src/mesh/RadioLibInterface.h b/src/mesh/RadioLibInterface.h index 295ccc1603..0142721789 100644 --- a/src/mesh/RadioLibInterface.h +++ b/src/mesh/RadioLibInterface.h @@ -99,6 +99,9 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified /// are _trying_ to receive a packet currently (note - we might just be waiting for one) bool isReceiving = false; + /// has the radio IRQ ever been armed? latches true and is never cleared, so ISR context only reads it + volatile bool isrEverArmed = false; + protected: // Noise floor tracking - rolling window of samples. static const uint8_t NOISE_FLOOR_SAMPLES = 20; @@ -144,13 +147,26 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified /** * Glue functions called from ISR land + * + * Skip the detach until the IRQ has been armed once: the first setStandby() runs before any + * enableInterrupt(), and ESP-IDF logs "GPIO isr service is not installed" for that call. */ - virtual void disableInterrupt() = 0; + void disableInterrupt() + { + if (!isrEverArmed) + return; + clearRadioIsr(); + } /** * Enable a particular ISR callback glue function */ - virtual void enableInterrupt(void (*)()) = 0; + void enableInterrupt(void (*callback)()) + { + // Latch before arming: the ISR can fire the moment the handler is installed. + isrEverArmed = true; + setRadioIsr(callback); + } /** * Poll as a backup to catch missed edge-triggered interrupts. @@ -300,6 +316,10 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified */ virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) = 0; + /** Chip specific arm/disarm of the radio IRQ; call enableInterrupt()/disableInterrupt() instead */ + virtual void setRadioIsr(void (*callback)()) = 0; + virtual void clearRadioIsr() = 0; + /** * Subclasses must override, implement and then call into this base class implementation */ @@ -311,23 +331,29 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified template uint32_t computePacketTime(T &lora, uint32_t pl, bool received) { if (received) { - // First get the actual coding rate and CRC status from the received packet - uint8_t rxCR; - bool hasCRC; - lora.getLoRaRxHeaderInfo(&rxCR, &hasCRC); - // Go from raw header value to denominator - if (rxCR < 5) { - rxCR += 4; - } else if (rxCR == 7) { - rxCR = 8; - } - // Received packet configuration must be the same as configured, except for coding rate and CRC DataRate_t dr = getDataRate(); - dr.lora.codingRate = rxCR; - PacketConfig_t pc = getPacketConfig(); - pc.lora.crcEnabled = hasCRC; + + uint8_t rxCR = 0; + bool hasCRC = true; + if (lora.getLoRaRxHeaderInfo(&rxCR, &hasCRC) == RADIOLIB_ERR_NONE) { + // Raw 0 is reserved and >7 is either undefined or an LR2021-only convolutional rate no + // Meshtastic peer can send. calculateTimeOnAir() would multiply by it unchecked. + if (rxCR < 1 || rxCR > 7) { + LOG_WARN("Bogus RX coding rate %d from radio, use configured %d", rxCR, dr.lora.codingRate); + } else { + // Go from raw header value to denominator + if (rxCR < 5) { + rxCR += 4; + } else if (rxCR == 7) { + rxCR = 8; + } + + dr.lora.codingRate = rxCR; + pc.lora.crcEnabled = hasCRC; + } + } return lora.calculateTimeOnAir(modemType, dr, pc, pl) / 1000; } diff --git a/src/mesh/ReliableRouter.cpp b/src/mesh/ReliableRouter.cpp index fce6b8a32e..72ef73eab8 100644 --- a/src/mesh/ReliableRouter.cpp +++ b/src/mesh/ReliableRouter.cpp @@ -16,6 +16,12 @@ */ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p) { + if (isBlockedEventCoordinatePacket(p)) { + LOG_DEBUG("Suppress reliable coordinate send on event (everyone) channel"); + packetPool.release(p); + return meshtastic_Routing_Error_NOT_AUTHORIZED; + } + const GlobalPacketId key(p); const bool retransmitting = p->want_ack; diff --git a/src/mesh/Router.cpp b/src/mesh/Router.cpp index 4b2c426938..2aa6a6c639 100644 --- a/src/mesh/Router.cpp +++ b/src/mesh/Router.cpp @@ -69,6 +69,52 @@ Allocator &packetPool = staticPool; static uint8_t bytes[MAX_LORA_PAYLOAD_LEN + 1] __attribute__((__aligned__)); +static ChannelIndex getEffectiveChannelIndex(const meshtastic_MeshPacket *p) +{ + ChannelIndex chIndex = p->channel; + if (nodeDB && isFromUs(p) && !chIndex && !p->pki_encrypted && !isBroadcast(p->to)) { + const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(p->to); + if (node) + chIndex = node->channel; + } + return chIndex; +} + +bool isBlockedEventCoordinatePacket(const meshtastic_MeshPacket *p) +{ +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL + if (p->pki_encrypted || willUsePki(p)) { + return false; + } + if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) { + return isCoordinatePortnum(p->decoded.portnum) && channels.isEventChannel(getEffectiveChannelIndex(p)); + } + return false; +#else + (void)p; + return false; +#endif +} + +bool willUsePki(const meshtastic_MeshPacket *p) +{ +#if !(MESHTASTIC_EXCLUDE_PKI) + if (p->which_payload_variant != meshtastic_MeshPacket_decoded_tag || !isFromUs(p)) + return false; + bool haveDestKey = false; + if (p->decoded.portnum == meshtastic_PortNum_KEY_VERIFICATION_APP) { + meshtastic_NodeInfoLite_public_key_t destKey = {0, {0}}; + haveDestKey = nodeDB->copyPublicKey(p->to, destKey); + if (!haveDestKey && p->pki_encrypted) + haveDestKey = crypto->getPendingPublicKey(p->to, destKey); + } + return wouldEncryptWithPKC(p, getEffectiveChannelIndex(p), haveDestKey); +#else + (void)p; + return false; +#endif +} + struct RoutingAuthCache { bool valid = false; // Deliberately NOT initialized in-class as this eats flash space. @@ -141,7 +187,6 @@ void resetRoutingAuthEvaluationCount() } } #endif - /** * Constructor * @@ -202,7 +247,7 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p) if (node && nodeInfoLiteIsFavorite(node) && nodeInfoLiteHasUser(node) && IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) { - LOG_DEBUG("Identified unique favorite relay router 0x%08x from last byte 0x%x", resolved, p->relay_node); + LOG_DEBUG("Unique favorite relay router 0x%08x from last byte 0x%x", resolved, p->relay_node); return false; // Don't decrement hop_limit } } @@ -223,7 +268,7 @@ int32_t Router::runOnce() perhapsHandleReceived(mp); } - // LOG_DEBUG("Sleep forever!"); + // LOG_DEBUG("Sleep forever"); return INT32_MAX; // Wait a long time - until we get woken for the message queue } @@ -266,14 +311,14 @@ PacketId generatePacketId() rollingPacketId &= ID_COUNTER_MASK; // Mask out the top 22 bits PacketId id = rollingPacketId | random(UINT32_MAX & 0x7fffffff) << 10; // top 22 bits - LOG_DEBUG("Partially randomized packet id %u", id); + LOG_TRACE("Partially randomized packet id 0x%08x", id); return id; } RxTimeStamp computeRxTimeStamp() { const bool haveTime = getRTCQuality() >= RTCQualityFromNet; - return {haveTime ? getValidTime(RTCQualityFromNet) : Time::getMillis(), haveTime}; + return {haveTime ? getValidTime(RTCQualityFromNet) : Time::getUptimeSecs(), haveTime}; } void stampRxTime(meshtastic_MeshPacket *p) @@ -336,7 +381,7 @@ meshtastic_QueueStatus Router::getQueueStatus() ErrorCode Router::sendLocal(meshtastic_MeshPacket *p, RxSource src) { if (p->to == 0) { - LOG_ERROR("Packet received with to: of 0!"); + LOG_ERROR("Packet received with to=0"); } // No need to deliver externally if the destination is the local node if (isToUs(p)) { @@ -360,10 +405,10 @@ ErrorCode Router::sendLocal(meshtastic_MeshPacket *p, RxSource src) // don't override if a channel was requested and no need to set it when PKI is enforced if (!p->channel && !p->pki_encrypted && !isBroadcast(p->to)) { - meshtastic_NodeInfoLite const *node = nodeDB->getMeshNode(p->to); - if (node) { - p->channel = node->channel; - LOG_DEBUG("localSend to channel %d", p->channel); + ChannelIndex chIndex = getEffectiveChannelIndex(p); + if (chIndex) { + p->channel = chIndex; + LOG_TRACE("localSend to channel %d", p->channel); } } @@ -385,7 +430,7 @@ ErrorCode Router::sendLocal(meshtastic_MeshPacket *p, RxSource src) ErrorCode Router::send(meshtastic_MeshPacket *p) { if (isToUs(p)) { - LOG_ERROR("BUG! send() called with packet destined for local node!"); + LOG_ERROR("BUG! send() with packet for local node"); packetPool.release(p); return meshtastic_Routing_Error_BAD_REQUEST; } // should have already been handled by sendLocal @@ -397,7 +442,7 @@ ErrorCode Router::send(meshtastic_MeshPacket *p) if (hourlyTxPercent > effectiveDutyCycle) { uint8_t silentMinutes = airTime->getSilentMinutes(hourlyTxPercent, effectiveDutyCycle); - LOG_WARN("Duty cycle limit exceeded. Aborting send for now, you can send again in %d mins", silentMinutes); + LOG_WARN("Duty cycle limit exceeded, abort send, retry in %d mins", silentMinutes); meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed(); if (cn) { @@ -473,9 +518,15 @@ ErrorCode Router::send(meshtastic_MeshPacket *p) fixPriority(p); // Before encryption, fix the priority if it's unset // Position precision is an originator-only privacy policy. Relays keep // p->from as the original sender, so do not rewrite their POSITION_APP payload. + if (isBlockedEventCoordinatePacket(p)) { + LOG_DEBUG("Suppress coordinate send on event (everyone) channel"); + packetPool.release(p); + return meshtastic_Routing_Error_NOT_AUTHORIZED; + } + if (isFromUs(p)) { if (!applyPositionPrecisionForChannel(*p, p->channel)) { - LOG_ERROR("Dropping malformed position packet before send"); + LOG_ERROR("Drop malformed position packet before send"); packetPool.release(p); return meshtastic_Routing_Error_BAD_REQUEST; } @@ -650,20 +701,20 @@ bool checkXeddsaReceivePolicy(meshtastic_MeshPacket *p) if (!node) return false; nodeInfoLiteSetBit(node, NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_MASK, true); - LOG_DEBUG("Verified XEdDSA signature from 0x%08x", p->from); + LOG_TRACE("Verified XEdDSA signature from 0x%08x", p->from); } else { - LOG_WARN("XEdDSA signature verification failed from 0x%08x, dropping", p->from); + LOG_WARN("XEdDSA signature verify failed from 0x%08x, drop", p->from); return false; } } else { const auto bootstrap = verifyFirstContactNodeInfo(p); if (bootstrap == NodeInfoBootstrapResult::INVALID) { - LOG_WARN("Invalid first-contact XEdDSA NodeInfo from 0x%08x, dropping", p->from); + LOG_WARN("Invalid first-contact XEdDSA NodeInfo from 0x%08x, drop", p->from); return false; } if (bootstrap == NodeInfoBootstrapResult::VERIFIED) return true; - LOG_DEBUG("No public key for 0x%08x, cannot verify XEdDSA signature", p->from); + LOG_DEBUG("No public key for 0x%08x, can't verify XEdDSA signature", p->from); if (strict) return false; } @@ -672,14 +723,13 @@ bool checkXeddsaReceivePolicy(meshtastic_MeshPacket *p) // senders emit only those two sizes (perhapsEncode sets 0 or XEDDSA_SIGNATURE_SIZE). Drop // it: a crafted partial signature would otherwise land in the unsigned branch below while // its bytes inflated the size estimate, letting a forged broadcast dodge the downgrade drop. - LOG_WARN("Malformed XEdDSA signature (%u bytes) from 0x%08x, dropping", (unsigned)p->decoded.xeddsa_signature.size, - p->from); + LOG_WARN("Malformed XEdDSA signature (%u bytes) from 0x%08x, drop", (unsigned)p->decoded.xeddsa_signature.size, p->from); return false; } else { if (p->pki_encrypted) return true; if (strict) { - LOG_WARN("Dropping unsigned packet from 0x%08x in Strict signature mode", p->from); + LOG_WARN("Drop unsigned packet from 0x%08x in Strict signature mode", p->from); return false; } if (compatible) @@ -692,7 +742,7 @@ bool checkXeddsaReceivePolicy(meshtastic_MeshPacket *p) if (!canonicalSignableSize(&p->decoded, &canonicalSize)) return true; // can't size it; never drop on a sizing failure if (canonicalSize + XEDDSA_SIGNATURE_FIELD_BYTES + MESHTASTIC_HEADER_LENGTH <= MAX_LORA_PAYLOAD_LEN) { - LOG_WARN("Dropping unsigned packet from 0x%08x that previously signed", p->from); + LOG_WARN("Drop unsigned packet from 0x%08x that previously signed", p->from); return false; } } @@ -735,11 +785,11 @@ RoutingAuthVerdict passesRoutingAuthGate(meshtastic_MeshPacket *p) return RoutingAuthVerdict::REJECT; } if (state == DecodeState::DECODE_FATAL) { - LOG_WARN("Fatal decode error, dropping packet"); + LOG_WARN("Fatal decode error, drop packet"); return RoutingAuthVerdict::REJECT; } if (state == DecodeState::DECODE_FAILURE) { - LOG_WARN("Decryptable packet failed decoding, dropping packet"); + LOG_WARN("Decryptable packet failed decoding, drop"); return RoutingAuthVerdict::REJECT; } @@ -804,7 +854,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY && !nodeInfoLiteHasUser(nodeDB->getMeshNode(p->from))) { - LOG_DEBUG("Node 0x%08x not in nodeDB-> Rebroadcast mode KNOWN_ONLY will ignore packet", p->from); + LOG_DEBUG("Node 0x%08x not in nodeDB, Rebroadcast KNOWN_ONLY ignores packet", p->from); return DecodeState::DECODE_FAILURE; } @@ -817,7 +867,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) size_t rawSize = p->encrypted.size; if (rawSize > sizeof(bytes)) { - LOG_ERROR("Packet too large to attempt decryption! (rawSize=%d > 256)", rawSize); + LOG_ERROR("Packet too large to decrypt (rawSize=%d > 256)", rawSize); return DecodeState::DECODE_FATAL; } bool decrypted = false; @@ -834,7 +884,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) licensedPkiCandidate = true; } else if (pkiCandidate) { pkiAttempted = true; - LOG_DEBUG("Attempt PKI decryption"); + LOG_TRACE("Attempt PKI decryption"); // Resolve the sender's key only for actual PKI-decrypt candidates, not every encrypted channel // packet: copyPublicKeyForDecrypt() can fall through to a linear scan of TrafficManagement's large // NodeInfo cache. It returns authoritative keys (hot/warm), or a cold-tier cache key only when it is @@ -874,7 +924,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) adminKeyFallbackRefund(); } if (decrypted) { - LOG_INFO("PKI Decryption worked!"); + LOG_INFO("PKI Decryption worked"); meshtastic_Data decodedtmp; memset(&decodedtmp, 0, sizeof(decodedtmp)); size_t payloadSize = rawSize - MESHTASTIC_PKC_OVERHEAD; @@ -888,7 +938,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) } decrypted = true; rawSize = payloadSize; // commit the overhead subtraction only on full success - LOG_INFO("Packet decrypted using PKI!"); + LOG_INFO("Packet decrypted using PKI"); p->pki_encrypted = true; memcpy(p->public_key.bytes, remotePublic.bytes, 32); p->public_key.size = 32; @@ -906,7 +956,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) } else { // AEAD already authenticated this ciphertext, so no other candidate could decode it - // the payload is simply malformed. - LOG_ERROR("PKC Decrypted, but pb_decode failed!"); + LOG_ERROR("PKC Decrypted, but pb_decode failed"); return DecodeState::DECODE_FAILURE; } } @@ -960,6 +1010,11 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) return DecodeState::DECODE_POLICY_REJECT; #endif + if (isBlockedEventCoordinatePacket(p)) { + LOG_DEBUG("Decoded coordinate packet on event channel; suppress payload logging"); + return DecodeState::DECODE_SUCCESS; + } + if (p->decoded.has_bitfield) p->decoded.want_response |= p->decoded.bitfield & BITFIELD_WANT_RESPONSE_MASK; @@ -1014,7 +1069,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p) #endif return DecodeState::DECODE_SUCCESS; } else { - LOG_WARN("No suitable channel found for decoding, hash was 0x%x!", p->channel); + LOG_WARN("No channel found for decoding, hash 0x%x", p->channel); return (matchedChannel || pkiAttempted || licensedPkiCandidate) ? DecodeState::DECODE_FAILURE : DecodeState::DECODE_OPAQUE; } @@ -1091,7 +1146,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p) if (crypto->xeddsa_sign(p->from, p->id, p->decoded.portnum, p->decoded.payload.bytes, p->decoded.payload.size, p->decoded.xeddsa_signature.bytes)) { p->decoded.xeddsa_signature.size = XEDDSA_SIGNATURE_SIZE; - LOG_DEBUG("XEdDSA signed packet 0x%08x", p->id); + LOG_TRACE("XEdDSA signed packet 0x%08x", p->id); } } #endif @@ -1118,7 +1173,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p) // If the compressed length is greater than or equal to the original size, don't use the compressed form if (compressed_len >= p->decoded.payload.size) { - LOG_DEBUG("Not using compressing message"); + LOG_DEBUG("Not compressing"); // Set the uncompressed payload variant anyway. Shouldn't hurt? // p->decoded.which_payloadVariant = Data_payload_tag; @@ -1156,13 +1211,12 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p) // We may want to retool things so we can send a PKC packet when the client specifies a key and nodenum, even if the node // is not in the local nodedb if (wouldEncryptWithPKC(p, chIndex, haveDestKey)) { - LOG_DEBUG("Use PKI!"); + LOG_DEBUG("Use PKI"); if (numbytes + MESHTASTIC_HEADER_LENGTH + MESHTASTIC_PKC_OVERHEAD > MAX_LORA_PAYLOAD_LEN) return meshtastic_Routing_Error_TOO_LARGE; // Check for a usable public key for the destination (NodeDB or a pending key-verification key) if (!haveDestKey) { - LOG_WARN("Unknown public key for destination node 0x%08x (portnum %d), refusing to send legacy DM", p->to, - p->decoded.portnum); + LOG_WARN("Unknown public key for 0x%08x (portnum %d), refuse legacy DM", p->to, p->decoded.portnum); return meshtastic_Routing_Error_PKI_SEND_FAIL_PUBLIC_KEY; } if (p->pki_encrypted && !memfll(p->public_key.bytes, 0, 32) && memcmp(p->public_key.bytes, destKey.bytes, 32) != 0) { @@ -1173,7 +1227,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p) // On failure encrypted.bytes holds no ciphertext, so continuing would put the plaintext // on the air labelled pki_encrypted. if (!crypto->encryptCurve25519(p->to, getFrom(p), destKey, p->id, numbytes, bytes, p->encrypted.bytes)) { - LOG_WARN("PKI encryption failed for destination node 0x%08x", p->to); + LOG_WARN("PKI encryption failed for 0x%08x", p->to); return meshtastic_Routing_Error_PKI_FAILED; } numbytes += MESHTASTIC_PKC_OVERHEAD; @@ -1289,7 +1343,7 @@ void Router::deliverLocal(meshtastic_MeshPacket *p, RxSource src) // broadcast). Mirrors sendToPhone()'s degrade-on-exhaustion behavior. if (copy) packetPool.release(copy); - LOG_WARN("Deferred local queue full/alloc failed, dropping loopback of 0x%08x", p->id); + LOG_WARN("Deferred local queue full/alloc failed, drop loopback of 0x%08x", p->id); #ifdef PIO_UNIT_TESTING deferredLocalDropped++; #endif @@ -1372,8 +1426,8 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) // Fatal decoding error, we can't do anything with this packet LOG_WARN(decodedState == DecodeState::DECODE_POLICY_REJECT ? "Packet rejected by signature policy" - : (decodedState == DecodeState::DECODE_FATAL ? "Fatal decode error, dropping packet" - : "Decryptable packet failed decoding, dropping packet")); + : (decodedState == DecodeState::DECODE_FATAL ? "Fatal decode error, drop packet" + : "Decryptable packet failed decoding, drop")); // A policy rejection is attacker-controlled input and must not cancel a valid pending // transmission with the same (from, id). Preserve the pre-existing fatal-decode behavior. if (decodedState == DecodeState::DECODE_FATAL) @@ -1404,7 +1458,7 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag && p->decoded.portnum == meshtastic_PortNum_NEIGHBORINFO_APP && (!moduleConfig.has_neighbor_info || !moduleConfig.neighbor_info.enabled)) { - LOG_DEBUG("Neighbor info module is disabled, ignore neighbor packet"); + LOG_DEBUG("Neighbor info module disabled, ignore packet"); cancelSending(p->from, p->id); skipHandle = true; } @@ -1416,7 +1470,7 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) p->decoded.portnum == meshtastic_PortNum_MESH_BEACON_APP && (!moduleConfig.has_mesh_beacon || !(moduleConfig.mesh_beacon.flags & meshtastic_ModuleConfig_MeshBeaconConfig_Flags_FLAG_LISTEN_ENABLED))) { - LOG_DEBUG("Beacon listening is disabled, ignore beacon packet"); + LOG_DEBUG("Beacon listening disabled, ignore packet"); cancelSending(p->from, p->id); skipHandle = true; } @@ -1438,6 +1492,16 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) cancelSending(p->from, p->id); skipHandle = true; } + +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL + // Discard coordinate-bearing packets that arrive on the event ("everyone") + // channel: don't process, store in NodeDB, or rebroadcast them. + if (!skipHandle && isBlockedEventCoordinatePacket(p)) { + LOG_DEBUG("Drop coordinate packet on event (everyone) channel"); + cancelSending(p->from, p->id); + skipHandle = true; + } +#endif } else { printPacket("packet decoding failed or skipped (no PSK?)", p); } @@ -1449,7 +1513,7 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) #if !MESHTASTIC_EXCLUDE_MQTT if (p_encrypted == nullptr) { - LOG_WARN("p_encrypted is null, skipping MQTT publish"); + LOG_WARN("p_encrypted null, skip MQTT publish"); } else { // Mark as pki_encrypted if it is not yet decoded and MQTT encryption is also enabled, hash matches and it's a DM not // to us (because we would be able to decrypt it) @@ -1469,7 +1533,7 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) if (encodeResult != meshtastic_Routing_Error_NONE) { // Encryption failed, release the new packet and fall back to sending the original encrypted packet to // MQTT - LOG_WARN("Encryption of new TR packet failed, sending original TR to MQTT"); + LOG_WARN("New TR packet encrypt failed, send original TR to MQTT"); packetPool.release(p_encrypted_new); p_encrypted_new = nullptr; } else { @@ -1479,7 +1543,7 @@ void Router::dispatchReceived(meshtastic_MeshPacket *p, RxSource src) } } else { // Allocation failed, log a warning and fall back to sending the original encrypted packet to MQTT - LOG_WARN("Failed to allocate new encrypted packet for TR, sending original TR to MQTT"); + LOG_WARN("Alloc encrypted TR packet failed, send original TR to MQTT"); } } mqtt->onSend(*p_encrypted, *p, p->channel); @@ -1504,7 +1568,7 @@ void Router::perhapsHandleReceived(meshtastic_MeshPacket *p) // assert(radioConfig.has_preferences); if (is_in_repeated(config.lora.ignore_incoming, p->from)) { clearRoutingAuthCache(); - LOG_DEBUG("Ignore msg, 0x%08x is in our ignore list", p->from); + LOG_DEBUG("Ignore msg, 0x%08x in ignore list", p->from); packetPool.release(p); return; } @@ -1554,7 +1618,7 @@ void Router::perhapsHandleReceived(meshtastic_MeshPacket *p) if (shouldFilterReceived(p)) { clearRoutingAuthCache(); - LOG_DEBUG("Incoming msg was filtered from 0x%08x", p->from); + LOG_DEBUG("Incoming msg filtered from 0x%08x", p->from); packetPool.release(p); return; } diff --git a/src/mesh/Router.h b/src/mesh/Router.h index 2a4d979c2e..d5ea73cfe9 100644 --- a/src/mesh/Router.h +++ b/src/mesh/Router.h @@ -11,8 +11,18 @@ #include "concurrency/OSThread.h" #include +inline bool isCoordinatePortnum(meshtastic_PortNum portnum) +{ + return portnum == meshtastic_PortNum_POSITION_APP || portnum == meshtastic_PortNum_WAYPOINT_APP || + portnum == meshtastic_PortNum_MAP_REPORT_APP; +} + +bool isBlockedEventCoordinatePacket(const meshtastic_MeshPacket *p); +bool willUsePki(const meshtastic_MeshPacket *p); + /// rx_time/has_rx_time for "now": a real epoch when the clock is trustworthy, else a -/// Time::getMillis() placeholder with valid=false. +/// Time::getUptimeSecs() placeholder with valid=false. Uptime seconds are monotonic, so +/// reconciliation against a later epoch is exact at any age. struct RxTimeStamp { uint32_t time; bool valid; diff --git a/src/mesh/SX126xInterface.cpp b/src/mesh/SX126xInterface.cpp index 7c46bee71c..750ebbbefb 100644 --- a/src/mesh/SX126xInterface.cpp +++ b/src/mesh/SX126xInterface.cpp @@ -77,9 +77,9 @@ template bool SX126xInterface::init() } #endif if (tcxoVoltage == 0.0) - LOG_DEBUG("SX126X_DIO3_TCXO_VOLTAGE not defined, not using DIO3 as TCXO reference voltage"); + LOG_DEBUG("SX126X_DIO3_TCXO_VOLTAGE not defined, DIO3 not used as TCXO Vref"); else - LOG_DEBUG("SX126X_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V", tcxoVoltage); + LOG_DEBUG("SX126X_DIO3_TCXO_VOLTAGE defined, DIO3 as TCXO Vref %f V", tcxoVoltage); setTransmitEnable(false); // FIXME: May want to set depending on a definition, currently all SX126x variant files use the DC-DC regulator option bool useRegulatorLDO = false; // Seems to depend on the connection to pin 9/DCC_SW - if an inductor DCDC? @@ -139,21 +139,21 @@ template bool SX126xInterface::init() // no effect #if ARCH_PORTDUINO if (res == RADIOLIB_ERR_NONE) { - LOG_DEBUG("Use MCU pin %i as RXEN and pin %i as TXEN to control RF switching", portduino_config.lora_rxen_pin.pin, + LOG_DEBUG("Use MCU pin %i as RXEN, pin %i as TXEN for RF switching", portduino_config.lora_rxen_pin.pin, portduino_config.lora_txen_pin.pin); lora.setRfSwitchPins(portduino_config.lora_rxen_pin.pin, portduino_config.lora_txen_pin.pin); } #else #ifndef SX126X_RXEN #define SX126X_RXEN RADIOLIB_NC - LOG_DEBUG("SX126X_RXEN not defined, defaulting to RADIOLIB_NC"); + LOG_DEBUG("SX126X_RXEN not defined, default RADIOLIB_NC"); #endif #ifndef SX126X_TXEN #define SX126X_TXEN RADIOLIB_NC - LOG_DEBUG("SX126X_TXEN not defined, defaulting to RADIOLIB_NC"); + LOG_DEBUG("SX126X_TXEN not defined, default RADIOLIB_NC"); #endif if (res == RADIOLIB_ERR_NONE) { - LOG_DEBUG("Use MCU pin %i as RXEN and pin %i as TXEN to control RF switching", SX126X_RXEN, SX126X_TXEN); + LOG_DEBUG("Use MCU pin %i as RXEN, pin %i as TXEN for RF switching", SX126X_RXEN, SX126X_TXEN); lora.setRfSwitchPins(SX126X_RXEN, SX126X_TXEN); } #endif @@ -162,15 +162,15 @@ template bool SX126xInterface::init() LOG_INFO("Set RX gain to boosted mode; result: %d", result); } else { uint16_t result = lora.setRxBoostedGainMode(false); - LOG_INFO("Set RX gain to power saving mode (boosted mode off); result: %d", result); + LOG_INFO("Set RX gain to power saving mode; result: %d", result); } // Undocumented SX1262 register patch recommended by Heltec/Semtech for improved RX sensitivity. // Sets bit 0 of register 0x8B5. if (module.SPIsetRegValue(0x8B5, 0x01, 0, 0) == RADIOLIB_ERR_NONE) { - LOG_INFO("Applied SX1262 register 0x8B5 patch for RX improvement"); + LOG_INFO("Applied SX1262 reg 0x8B5 RX patch"); } else { - LOG_WARN("Failed to apply SX1262 register 0x8B5 patch for RX improvement"); + LOG_WARN("Can't apply SX1262 reg 0x8B5 RX patch"); } if (res == RADIOLIB_ERR_NONE) @@ -230,7 +230,7 @@ template bool SX126xInterface::reconfigure() if (err != RADIOLIB_ERR_NONE) { // Don't abort: this power is operator config (tx_power/SX126X_MAX_POWER); a value above the // driver's max would crash the daemon before reloadConfig() persists. Flag it and keep prior power. - LOG_ERROR("SX126X setOutputPower %d dBm rejected (%s%d); keeping previous Tx power", power, radioLibErr, err); + LOG_ERROR("SX126X setOutputPower %d dBm rejected (%s%d); keep previous Tx power", power, radioLibErr, err); RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING); } @@ -250,7 +250,7 @@ template int16_t SX126xInterface::getCurrentRSSI() return (int16_t)round(rssi); } -template void SX126xInterface::enableInterrupt(void (*callback)()) +template void SX126xInterface::setRadioIsr(void (*callback)()) { #ifdef LORA_DIO1_SOFTWARE_POLL irqPollingActive = true; @@ -261,7 +261,7 @@ template void SX126xInterface::enableInterrupt(void (*callback)( #endif } -template void SX126xInterface::disableInterrupt() +template void SX126xInterface::clearRadioIsr() { #ifdef LORA_DIO1_SOFTWARE_POLL irqPollingActive = false; @@ -336,7 +336,7 @@ template void SX126xInterface::addReceiveMetadata(meshtastic_Mes mp->rx_snr = lora.getSNR(); mp->rx_rssi = lround(lora.getRSSI()); mp->has_rx_rssi = true; // rx_rssi has explicit presence - a genuine reading must be marked present to survive encoding - LOG_DEBUG("Corrected frequency offset: %f", lora.getFrequencyError()); + LOG_TRACE("Corrected frequency offset: %f", lora.getFrequencyError()); } /** We override to turn on transmitter power as needed. @@ -478,7 +478,7 @@ template void SX126xInterface::resetAGC() } if (module.hal->digitalRead(module.getGpio())) { - LOG_WARN("SX126x AGC reset: calibration did not complete within 50ms"); + LOG_WARN("SX126x AGC reset: calibration not done in 50ms"); startReceive(); return; } @@ -506,7 +506,7 @@ template void SX126xInterface::resetAGC() // Without this re-apply, every SX1262 node loses its RX boost ~60s after boot // and never recovers until reboot. See empirical evidence in the PR description. if (module.SPIsetRegValue(0x8B5, 0x01, 0, 0) != RADIOLIB_ERR_NONE) { - LOG_WARN("SX126x resetAGC: failed to re-apply 0x8B5 RX sensitivity patch"); + LOG_WARN("SX126x resetAGC: 0x8B5 RX patch re-apply failed"); } // 6. Resume receiving diff --git a/src/mesh/SX126xInterface.h b/src/mesh/SX126xInterface.h index 0bf977ba2a..9465064b8a 100644 --- a/src/mesh/SX126xInterface.h +++ b/src/mesh/SX126xInterface.h @@ -47,12 +47,12 @@ template class SX126xInterface : public RadioLibInterface /** * Glue functions called from ISR land */ - virtual void disableInterrupt() override; + virtual void clearRadioIsr() override; /** * Enable a particular ISR callback glue function */ - virtual void enableInterrupt(void (*callback)()) override; + virtual void setRadioIsr(void (*callback)()) override; #ifdef LORA_DIO1_SOFTWARE_POLL void handleSoftwareLoraIrqPoll() override; diff --git a/src/mesh/SX128xInterface.cpp b/src/mesh/SX128xInterface.cpp index 7848d51db3..bb1d890247 100644 --- a/src/mesh/SX128xInterface.cpp +++ b/src/mesh/SX128xInterface.cpp @@ -156,7 +156,7 @@ template bool SX128xInterface::reconfigure() return true; } -template void SX128xInterface::disableInterrupt() +template void SX128xInterface::clearRadioIsr() { lora.clearDio1Action(); } diff --git a/src/mesh/SX128xInterface.h b/src/mesh/SX128xInterface.h index 1205087b71..3b9015249e 100644 --- a/src/mesh/SX128xInterface.h +++ b/src/mesh/SX128xInterface.h @@ -43,12 +43,12 @@ template class SX128xInterface : public RadioLibInterface /** * Glue functions called from ISR land */ - virtual void disableInterrupt() override; + virtual void clearRadioIsr() override; /** * Enable a particular ISR callback glue function */ - virtual void enableInterrupt(void (*callback)()) { lora.setDio1Action(callback); } + virtual void setRadioIsr(void (*callback)()) override { lora.setDio1Action(callback); } /** can we detect a LoRa preamble on the current channel? */ virtual bool isChannelActive() override; diff --git a/src/mesh/Throttle.cpp b/src/mesh/Throttle.cpp index a4f8347b26..606ba737e9 100644 --- a/src/mesh/Throttle.cpp +++ b/src/mesh/Throttle.cpp @@ -1,4 +1,5 @@ #include "Throttle.h" +#include "UptimeClock.h" #include /// @brief Execute a function throttled to a minimum interval @@ -10,11 +11,11 @@ bool Throttle::execute(uint32_t *lastExecutionMs, uint32_t minumumIntervalMs, void (*throttleFunc)(void), void (*onDefer)(void)) { if (*lastExecutionMs == 0) { - *lastExecutionMs = millis(); + *lastExecutionMs = Time::getMillis(); throttleFunc(); return true; } - uint32_t now = millis(); + uint32_t now = Time::getMillis(); if ((now - *lastExecutionMs) >= minumumIntervalMs) { throttleFunc(); @@ -31,6 +32,14 @@ bool Throttle::execute(uint32_t *lastExecutionMs, uint32_t minumumIntervalMs, vo /// @param timeSpanMs The interval in milliseconds of the timespan bool Throttle::isWithinTimespanMs(uint32_t lastExecutionMs, uint32_t timeSpanMs) { - uint32_t now = millis(); + uint32_t now = Time::getMillis(); return (now - lastExecutionMs) < timeSpanMs; +} + +/// @brief Check whether an absolute deadline has arrived, correctly across the millis() wrap +/// @param deadlineMs The deadline, as a millis() value +/// See the header for the range limit and the sentinel requirement. +bool Throttle::deadlinePassed(uint32_t deadlineMs) +{ + return deadlinePassedAt(Time::getMillis(), deadlineMs); } \ No newline at end of file diff --git a/src/mesh/Throttle.h b/src/mesh/Throttle.h index 8b4bb5d305..f9d68a4143 100644 --- a/src/mesh/Throttle.h +++ b/src/mesh/Throttle.h @@ -7,4 +7,48 @@ class Throttle public: static bool execute(uint32_t *lastExecutionMs, uint32_t minumumIntervalMs, void (*func)(void), void (*onDefer)(void) = NULL); static bool isWithinTimespanMs(uint32_t lastExecutionMs, uint32_t intervalMs); + + /// Complement of isWithinTimespanMs(): true once intervalMs has passed since lastExecutionMs. + /// Boundary is inclusive (>=), mirroring isWithinTimespanMs()'s exclusive <. + /// Deliberately does not treat lastExecutionMs == 0 as "never run" - callers that use 0 as a + /// sentinel must test for it separately, so the sentinel never reaches the arithmetic. + static bool hasElapsed(uint32_t lastExecutionMs, uint32_t intervalMs) + { + return !isWithinTimespanMs(lastExecutionMs, intervalMs); + } + + /// True once an absolute deadline has arrived. Use this rather than comparing against millis() + /// directly: that inverts while the deadline sits on the far side of the 32-bit wrap, so the + /// action either fires immediately or blocks for about the interval it should have waited. + /// + /// Use this when the site stores a deadline; use hasElapsed() when it stores the time of the + /// last event, which allows the full ~49.7 day range instead of ~24.8 days ahead. + /// + /// Callers that overload the deadline with an "inactive" sentinel (0, or UINT32_MAX) MUST test + /// for that separately, first: every such value is arithmetically far in the past, so it reads + /// as passed. + /// + /// TODO(deadline-type): mistake-proof that MUST by giving a deadline its own one-field type - + /// Deadline::in(ms) / .armed() / .passed() / .disarm(). A hand-built `now + interval` could then + /// no longer land on the sentinel by accident, and "armed" would stay a question separate from + /// "passed" - the split that has to survive, because which way "inactive" falls is the caller's + /// to decide. Same size and cost as the bare uint32_t. The conversion sites, grouped by the four + /// meanings they give the sentinel today: + /// 0 = unarmed - Power.cpp rebootAtMsec/shutdownAtMsec (the cheapest pair to convert), and + /// GPS.cpp fixHoldEnds, whose arm site remaps a 0 result to 1 by hand. + /// 0 = forever - NotificationRenderer.cpp alertBannerUntil. Every read spells its own `> 0` + /// guard, so this third state wants naming rather than repeating. + /// 0 = due now - ethClient.cpp ntp_renew, forced at link-up. + /// UINT32_MAX - ExternalNotificationModule.cpp nagCycleCutoff, whose armed() also lives in a + /// second variable (isNagging) and whose arm site can land on the sentinel. + static bool deadlinePassed(uint32_t deadlineMs); + + /// deadlinePassed() against a caller-supplied "now", for a loop that snapshots the time once and + /// tests many deadlines against it. Same range limit and sentinel rules as above. + static bool deadlinePassedAt(uint32_t nowMs, uint32_t deadlineMs) + { + // Passed iff now - deadline has not wrapped past 2^31 ms; further-ahead deadlines land in + // the top half. Not an int32_t cast, which is implementation-defined beyond INT32_MAX. + return (uint32_t)(nowMs - deadlineMs) < 0x80000000u; + } }; \ No newline at end of file diff --git a/src/mesh/WarmNodeStore.cpp b/src/mesh/WarmNodeStore.cpp index d8d9dcf296..6971e6ff4a 100644 --- a/src/mesh/WarmNodeStore.cpp +++ b/src/mesh/WarmNodeStore.cpp @@ -494,7 +494,7 @@ void WarmNodeStore::load() bool WarmNodeStore::save() { if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to save WarmStore on unsafe device power level."); + LOG_ERROR("Trying to save WarmStore on unsafe device power level"); return false; } concurrency::LockGuard g(spiLock); @@ -605,7 +605,7 @@ bool WarmNodeStore::save() if (!entries) return false; if (!powerHAL_isPowerLevelSafe()) { - LOG_ERROR("Error: trying to save WarmStore on unsafe device power level."); + LOG_ERROR("Trying to save WarmStore on unsafe device power level"); return false; } diff --git a/src/mesh/api/PacketAPI.cpp b/src/mesh/api/PacketAPI.cpp index ad4d06729d..c8adda5204 100644 --- a/src/mesh/api/PacketAPI.cpp +++ b/src/mesh/api/PacketAPI.cpp @@ -92,7 +92,7 @@ bool PacketAPI::receivePacket(void) } break; default: - LOG_ERROR("Error: unhandled meshtastic_ToRadio variant: %d", mr->which_payload_variant); + LOG_ERROR("Unhandled meshtastic_ToRadio variant: %d", mr->which_payload_variant); break; } } diff --git a/src/mesh/eth/ethCert.cpp b/src/mesh/eth/ethCert.cpp index e97db916a0..b6019cd333 100644 --- a/src/mesh/eth/ethCert.cpp +++ b/src/mesh/eth/ethCert.cpp @@ -270,7 +270,7 @@ bool ensureCertForIp(IPAddress ip, EthCertMaterial &out) (unsigned)out.keyDer.size(), ipStr.c_str()); return true; } - LOG_WARN("ETH CERT: cached cert/key failed to parse (partial write?), regenerating"); + LOG_WARN("ETH CERT: cached cert/key parse failed (partial write?), regen"); out.certDer.clear(); out.keyDer.clear(); } @@ -279,7 +279,7 @@ bool ensureCertForIp(IPAddress ip, EthCertMaterial &out) } } - LOG_INFO("ETH CERT: generating ECDSA P-256 self-signed cert for IP %s...", ipStr.c_str()); + LOG_INFO("ETH CERT: gen ECDSA P-256 self-signed cert for IP %s", ipStr.c_str()); uint32_t t0 = millis(); if (!generateCert(ip, out)) { LOG_ERROR("ETH CERT: generation failed"); @@ -299,7 +299,7 @@ bool ensureCertForIp(IPAddress ip, EthCertMaterial &out) writeText(IP_PATH, ""); if (!writeBinary(CERT_PATH, out.certDer.data(), out.certDer.size()) || !writeBinary(KEY_PATH, out.keyDer.data(), out.keyDer.size()) || !writeText(IP_PATH, ipStr)) { - LOG_WARN("ETH CERT: persist failed - will regenerate next boot"); + LOG_WARN("ETH CERT: persist failed, regen next boot"); } else { LOG_INFO("ETH CERT: persisted to LittleFS"); } @@ -337,7 +337,7 @@ class EthCertThread : public concurrency::OSThread // regenerates whenever its saved IP != ip, so the cert SAN follows. bool ok = ensureCertForIp(ip, material_); if (!ok) { - LOG_ERROR("ETH CERT: pipeline FAILED - TLS server will not start"); + LOG_ERROR("ETH CERT: pipeline FAILED, no TLS server"); // Don't leave isReady() reporting true with empty material: a later TLS // teardown (e.g. a W5500 reset) would then fail initTlsContext() and stay // disabled. Clear readiness so the TLS worker waits and the next poll @@ -375,7 +375,7 @@ void initEthCertThread() if (certThread) return; certThread = new EthCertThread(); - LOG_INFO("ETH CERT: deferred worker scheduled (waits for DHCP, runs once)"); + LOG_INFO("ETH CERT: deferred worker scheduled (awaits DHCP)"); } bool isEthCertReady() diff --git a/src/mesh/eth/ethClient.cpp b/src/mesh/eth/ethClient.cpp index bf6be0b9c7..bf85eef925 100644 --- a/src/mesh/eth/ethClient.cpp +++ b/src/mesh/eth/ethClient.cpp @@ -4,6 +4,7 @@ #include "configuration.h" #include "gps/RTC.h" #include "main.h" +#include "mesh/Throttle.h" #include "mesh/api/ethServerAPI.h" #include "target_specific.h" #if HAS_ETHERNET && defined(HAS_ETHERNET_OTA) @@ -196,7 +197,9 @@ static int32_t reconnectETH() } #ifndef DISABLE_NTP - if (isEthernetAvailable() && (ntp_renew < millis())) { + // 0 here means "renew now" (forced at link-up). deadlinePassed(0) only reads as passed for the + // first half of each wrap cycle, so treat 0 as always-due rather than relying on that. + if (isEthernetAvailable() && (ntp_renew == 0 || Throttle::deadlinePassed(ntp_renew))) { LOG_INFO("Update NTP time from %s", config.network.ntp_server); if (timeClient.update()) { diff --git a/src/mesh/eth/ethOTA.cpp b/src/mesh/eth/ethOTA.cpp index 0bac5b8a29..b99ff73046 100644 --- a/src/mesh/eth/ethOTA.cpp +++ b/src/mesh/eth/ethOTA.cpp @@ -99,7 +99,7 @@ static bool authenticateClient(EthernetClient &client) // Rate-limit after failed auth - close silently so the error byte is not // misinterpreted as part of the nonce by a re-trying client. if (lastAuthFailure != 0 && (millis() - lastAuthFailure) < OTA_AUTH_COOLDOWN_MS) { - LOG_WARN("ETH OTA: Auth cooldown active, rejecting connection"); + LOG_WARN("ETH OTA: Auth cooldown, reject connection"); client.stop(); return false; } @@ -260,7 +260,7 @@ static void handleOTAClient(EthernetClient &client) return; } - LOG_INFO("ETH OTA: Update staged successfully (%u bytes). Rebooting...", hdr.firmwareSize); + LOG_INFO("ETH OTA: Update staged (%u bytes). Rebooting", hdr.firmwareSize); client.write(OTA_OK); client.flush(); delay(500); diff --git a/src/mesh/generated/meshtastic/admin.pb.cpp b/src/mesh/generated/meshtastic/admin.pb.cpp index 945840c0f4..d029daf314 100644 --- a/src/mesh/generated/meshtastic/admin.pb.cpp +++ b/src/mesh/generated/meshtastic/admin.pb.cpp @@ -30,7 +30,7 @@ PB_BIND(meshtastic_SharedContact, meshtastic_SharedContact, AUTO) PB_BIND(meshtastic_KeyVerificationAdmin, meshtastic_KeyVerificationAdmin, AUTO) -PB_BIND(meshtastic_SensorConfig, meshtastic_SensorConfig, AUTO) +PB_BIND(meshtastic_SensorConfig, meshtastic_SensorConfig, 2) PB_BIND(meshtastic_SCD4X_config, meshtastic_SCD4X_config, AUTO) @@ -39,12 +39,18 @@ PB_BIND(meshtastic_SCD4X_config, meshtastic_SCD4X_config, AUTO) PB_BIND(meshtastic_SEN5X_config, meshtastic_SEN5X_config, AUTO) +PB_BIND(meshtastic_SEN6X_config, meshtastic_SEN6X_config, AUTO) + + PB_BIND(meshtastic_SCD30_config, meshtastic_SCD30_config, AUTO) PB_BIND(meshtastic_SHTXX_config, meshtastic_SHTXX_config, AUTO) +PB_BIND(meshtastic_DS248X_config, meshtastic_DS248X_config, AUTO) + + diff --git a/src/mesh/generated/meshtastic/admin.pb.h b/src/mesh/generated/meshtastic/admin.pb.h index 4c00a568cf..9d73b85088 100644 --- a/src/mesh/generated/meshtastic/admin.pb.h +++ b/src/mesh/generated/meshtastic/admin.pb.h @@ -186,7 +186,7 @@ typedef struct _meshtastic_LockdownAuth { token at unlock time: the client-supplied boots_remaining when non-zero, otherwise the firmware default (TOKEN_DEFAULT_BOOTS). Note that boots_remaining == 0 in this message means "use firmware - default", NOT "zero boots" - a client computing the ceiling for + default", NOT "zero boots" — a client computing the ceiling for display should mirror that resolution rather than multiplying the raw request value. @@ -196,7 +196,7 @@ typedef struct _meshtastic_LockdownAuth { Uses millis() (CPU uptime), not wall-clock time, so the cap is immune to GPS spoofing, RTC backup-battery removal, and Faraday - cage isolation - none of those move the uptime counter. The only + cage isolation — none of those move the uptime counter. The only way to reset the session clock is a reboot, which costs a boot from the on-flash, HMAC-bound counter. */ uint32_t max_session_seconds; @@ -213,7 +213,7 @@ typedef struct _meshtastic_LockdownAuth { NOT reversed by this operation: APPROTECT. Once the debug port lockout has been burned (on silicon where it is effective) it is - permanent - disabling lockdown decrypts your data and removes the + permanent — disabling lockdown decrypts your data and removes the access gates, but the SWD/JTAG port stays locked for the life of the device (recoverable only via a full chip erase over a debug probe, which destroys all data). Clients should make this @@ -303,8 +303,38 @@ typedef struct _meshtastic_SEN5X_config { /* One-shot mode (true for low power - one-shot mode, false for normal - continuous mode) */ bool has_set_one_shot_mode; bool set_one_shot_mode; + /* Trigger a fan cleaning cycle */ + bool has_start_fan_cleaning; + bool start_fan_cleaning; } meshtastic_SEN5X_config; +typedef struct _meshtastic_SEN6X_config { + /* Reference temperature in degC */ + bool has_set_temperature; + float set_temperature; + /* One-shot mode (true for low power - one-shot mode, false for normal - continuous mode) */ + bool has_set_one_shot_mode; + bool set_one_shot_mode; + /* Trigger a fan cleaning cycle */ + bool has_start_fan_cleaning; + bool start_fan_cleaning; + /* Set Automatic self-calibration enabled (CO2-capable variants only: SEN63C, SEN66, SEN69C) */ + bool has_set_asc; + bool set_asc; + /* Recalibration target CO2 concentration in ppm (FRC only), CO2-capable variants only */ + bool has_set_target_co2_conc; + uint32_t set_target_co2_conc; + /* Altitude of sensor in meters above sea level. 0 - 3000m (overrides ambient pressure), CO2-capable variants only */ + bool has_set_altitude; + uint32_t set_altitude; + /* Sensor ambient pressure in Pa. 70000 - 120000 Pa (overrides altitude), CO2-capable variants only */ + bool has_set_ambient_pressure; + uint32_t set_ambient_pressure; + /* Perform a factory reset of the CO2 sensor's calibration, CO2-capable variants only */ + bool has_factory_reset; + bool factory_reset; +} meshtastic_SEN6X_config; + typedef struct _meshtastic_SCD30_config { /* Set Automatic self-calibration enabled */ bool has_set_asc; @@ -332,6 +362,12 @@ typedef struct _meshtastic_SHTXX_config { uint32_t set_accuracy; } meshtastic_SHTXX_config; +typedef struct _meshtastic_DS248X_config { + /* Main channel for temperature reporting (0-7) */ + bool has_main_temperature_channel; + uint32_t main_temperature_channel; +} meshtastic_DS248X_config; + typedef struct _meshtastic_SensorConfig { /* SCD4X CO2 Sensor configuration */ bool has_scd4x_config; @@ -345,6 +381,12 @@ typedef struct _meshtastic_SensorConfig { /* SHTXX temperature and relative humidity sensor configuration */ bool has_shtxx_config; meshtastic_SHTXX_config shtxx_config; + /* DS248X-800 temperature sensor configuration */ + bool has_ds248x_config; + meshtastic_DS248X_config ds248x_config; + /* SEN6X PM/RHT/VOC/NOx/CO2/HCHO Sensor configuration */ + bool has_sen6x_config; + meshtastic_SEN6X_config sen6x_config; } meshtastic_SensorConfig; typedef PB_BYTES_ARRAY_T(8) meshtastic_AdminMessage_session_passkey_t; @@ -544,6 +586,8 @@ extern "C" { + + /* Initializer values for message structs */ #define meshtastic_AdminMessage_init_default {0, {0}, {0, {0}}} #define meshtastic_AdminMessage_InputEvent_init_default {0, 0, 0, 0} @@ -553,11 +597,13 @@ extern "C" { #define meshtastic_NodeRemoteHardwarePinsResponse_init_default {0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}} #define meshtastic_SharedContact_init_default {0, false, meshtastic_User_init_default, 0, 0} #define meshtastic_KeyVerificationAdmin_init_default {_meshtastic_KeyVerificationAdmin_MessageType_MIN, 0, 0, false, 0} -#define meshtastic_SensorConfig_init_default {false, meshtastic_SCD4X_config_init_default, false, meshtastic_SEN5X_config_init_default, false, meshtastic_SCD30_config_init_default, false, meshtastic_SHTXX_config_init_default} +#define meshtastic_SensorConfig_init_default {false, meshtastic_SCD4X_config_init_default, false, meshtastic_SEN5X_config_init_default, false, meshtastic_SCD30_config_init_default, false, meshtastic_SHTXX_config_init_default, false, meshtastic_DS248X_config_init_default, false, meshtastic_SEN6X_config_init_default} #define meshtastic_SCD4X_config_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} -#define meshtastic_SEN5X_config_init_default {false, 0, false, 0} +#define meshtastic_SEN5X_config_init_default {false, 0, false, 0, false, 0} +#define meshtastic_SEN6X_config_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_SCD30_config_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_SHTXX_config_init_default {false, 0} +#define meshtastic_DS248X_config_init_default {false, 0} #define meshtastic_AdminMessage_init_zero {0, {0}, {0, {0}}} #define meshtastic_AdminMessage_InputEvent_init_zero {0, 0, 0, 0} #define meshtastic_AdminMessage_OTAEvent_init_zero {_meshtastic_OTAMode_MIN, {0, {0}}} @@ -566,11 +612,13 @@ extern "C" { #define meshtastic_NodeRemoteHardwarePinsResponse_init_zero {0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}} #define meshtastic_SharedContact_init_zero {0, false, meshtastic_User_init_zero, 0, 0} #define meshtastic_KeyVerificationAdmin_init_zero {_meshtastic_KeyVerificationAdmin_MessageType_MIN, 0, 0, false, 0} -#define meshtastic_SensorConfig_init_zero {false, meshtastic_SCD4X_config_init_zero, false, meshtastic_SEN5X_config_init_zero, false, meshtastic_SCD30_config_init_zero, false, meshtastic_SHTXX_config_init_zero} +#define meshtastic_SensorConfig_init_zero {false, meshtastic_SCD4X_config_init_zero, false, meshtastic_SEN5X_config_init_zero, false, meshtastic_SCD30_config_init_zero, false, meshtastic_SHTXX_config_init_zero, false, meshtastic_DS248X_config_init_zero, false, meshtastic_SEN6X_config_init_zero} #define meshtastic_SCD4X_config_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} -#define meshtastic_SEN5X_config_init_zero {false, 0, false, 0} +#define meshtastic_SEN5X_config_init_zero {false, 0, false, 0, false, 0} +#define meshtastic_SEN6X_config_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_SCD30_config_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_SHTXX_config_init_zero {false, 0} +#define meshtastic_DS248X_config_init_zero {false, 0} /* Field tags (for use in manual encoding/decoding) */ #define meshtastic_AdminMessage_InputEvent_event_code_tag 1 @@ -608,6 +656,15 @@ extern "C" { #define meshtastic_SCD4X_config_set_power_mode_tag 7 #define meshtastic_SEN5X_config_set_temperature_tag 1 #define meshtastic_SEN5X_config_set_one_shot_mode_tag 2 +#define meshtastic_SEN5X_config_start_fan_cleaning_tag 3 +#define meshtastic_SEN6X_config_set_temperature_tag 1 +#define meshtastic_SEN6X_config_set_one_shot_mode_tag 2 +#define meshtastic_SEN6X_config_start_fan_cleaning_tag 3 +#define meshtastic_SEN6X_config_set_asc_tag 4 +#define meshtastic_SEN6X_config_set_target_co2_conc_tag 5 +#define meshtastic_SEN6X_config_set_altitude_tag 6 +#define meshtastic_SEN6X_config_set_ambient_pressure_tag 7 +#define meshtastic_SEN6X_config_factory_reset_tag 8 #define meshtastic_SCD30_config_set_asc_tag 1 #define meshtastic_SCD30_config_set_target_co2_conc_tag 2 #define meshtastic_SCD30_config_set_temperature_tag 3 @@ -615,10 +672,13 @@ extern "C" { #define meshtastic_SCD30_config_set_measurement_interval_tag 5 #define meshtastic_SCD30_config_soft_reset_tag 6 #define meshtastic_SHTXX_config_set_accuracy_tag 1 +#define meshtastic_DS248X_config_main_temperature_channel_tag 1 #define meshtastic_SensorConfig_scd4x_config_tag 1 #define meshtastic_SensorConfig_sen5x_config_tag 2 #define meshtastic_SensorConfig_scd30_config_tag 3 #define meshtastic_SensorConfig_shtxx_config_tag 4 +#define meshtastic_SensorConfig_ds248x_config_tag 5 +#define meshtastic_SensorConfig_sen6x_config_tag 6 #define meshtastic_AdminMessage_get_channel_request_tag 1 #define meshtastic_AdminMessage_get_channel_response_tag 2 #define meshtastic_AdminMessage_get_owner_request_tag 3 @@ -824,13 +884,17 @@ X(a, STATIC, OPTIONAL, UINT32, security_number, 4) X(a, STATIC, OPTIONAL, MESSAGE, scd4x_config, 1) \ X(a, STATIC, OPTIONAL, MESSAGE, sen5x_config, 2) \ X(a, STATIC, OPTIONAL, MESSAGE, scd30_config, 3) \ -X(a, STATIC, OPTIONAL, MESSAGE, shtxx_config, 4) +X(a, STATIC, OPTIONAL, MESSAGE, shtxx_config, 4) \ +X(a, STATIC, OPTIONAL, MESSAGE, ds248x_config, 5) \ +X(a, STATIC, OPTIONAL, MESSAGE, sen6x_config, 6) #define meshtastic_SensorConfig_CALLBACK NULL #define meshtastic_SensorConfig_DEFAULT NULL #define meshtastic_SensorConfig_scd4x_config_MSGTYPE meshtastic_SCD4X_config #define meshtastic_SensorConfig_sen5x_config_MSGTYPE meshtastic_SEN5X_config #define meshtastic_SensorConfig_scd30_config_MSGTYPE meshtastic_SCD30_config #define meshtastic_SensorConfig_shtxx_config_MSGTYPE meshtastic_SHTXX_config +#define meshtastic_SensorConfig_ds248x_config_MSGTYPE meshtastic_DS248X_config +#define meshtastic_SensorConfig_sen6x_config_MSGTYPE meshtastic_SEN6X_config #define meshtastic_SCD4X_config_FIELDLIST(X, a) \ X(a, STATIC, OPTIONAL, BOOL, set_asc, 1) \ @@ -845,10 +909,23 @@ X(a, STATIC, OPTIONAL, BOOL, set_power_mode, 7) #define meshtastic_SEN5X_config_FIELDLIST(X, a) \ X(a, STATIC, OPTIONAL, FLOAT, set_temperature, 1) \ -X(a, STATIC, OPTIONAL, BOOL, set_one_shot_mode, 2) +X(a, STATIC, OPTIONAL, BOOL, set_one_shot_mode, 2) \ +X(a, STATIC, OPTIONAL, BOOL, start_fan_cleaning, 3) #define meshtastic_SEN5X_config_CALLBACK NULL #define meshtastic_SEN5X_config_DEFAULT NULL +#define meshtastic_SEN6X_config_FIELDLIST(X, a) \ +X(a, STATIC, OPTIONAL, FLOAT, set_temperature, 1) \ +X(a, STATIC, OPTIONAL, BOOL, set_one_shot_mode, 2) \ +X(a, STATIC, OPTIONAL, BOOL, start_fan_cleaning, 3) \ +X(a, STATIC, OPTIONAL, BOOL, set_asc, 4) \ +X(a, STATIC, OPTIONAL, UINT32, set_target_co2_conc, 5) \ +X(a, STATIC, OPTIONAL, UINT32, set_altitude, 6) \ +X(a, STATIC, OPTIONAL, UINT32, set_ambient_pressure, 7) \ +X(a, STATIC, OPTIONAL, BOOL, factory_reset, 8) +#define meshtastic_SEN6X_config_CALLBACK NULL +#define meshtastic_SEN6X_config_DEFAULT NULL + #define meshtastic_SCD30_config_FIELDLIST(X, a) \ X(a, STATIC, OPTIONAL, BOOL, set_asc, 1) \ X(a, STATIC, OPTIONAL, UINT32, set_target_co2_conc, 2) \ @@ -864,6 +941,11 @@ X(a, STATIC, OPTIONAL, UINT32, set_accuracy, 1) #define meshtastic_SHTXX_config_CALLBACK NULL #define meshtastic_SHTXX_config_DEFAULT NULL +#define meshtastic_DS248X_config_FIELDLIST(X, a) \ +X(a, STATIC, OPTIONAL, UINT32, main_temperature_channel, 1) +#define meshtastic_DS248X_config_CALLBACK NULL +#define meshtastic_DS248X_config_DEFAULT NULL + extern const pb_msgdesc_t meshtastic_AdminMessage_msg; extern const pb_msgdesc_t meshtastic_AdminMessage_InputEvent_msg; extern const pb_msgdesc_t meshtastic_AdminMessage_OTAEvent_msg; @@ -875,8 +957,10 @@ extern const pb_msgdesc_t meshtastic_KeyVerificationAdmin_msg; extern const pb_msgdesc_t meshtastic_SensorConfig_msg; extern const pb_msgdesc_t meshtastic_SCD4X_config_msg; extern const pb_msgdesc_t meshtastic_SEN5X_config_msg; +extern const pb_msgdesc_t meshtastic_SEN6X_config_msg; extern const pb_msgdesc_t meshtastic_SCD30_config_msg; extern const pb_msgdesc_t meshtastic_SHTXX_config_msg; +extern const pb_msgdesc_t meshtastic_DS248X_config_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ #define meshtastic_AdminMessage_fields &meshtastic_AdminMessage_msg @@ -890,23 +974,27 @@ extern const pb_msgdesc_t meshtastic_SHTXX_config_msg; #define meshtastic_SensorConfig_fields &meshtastic_SensorConfig_msg #define meshtastic_SCD4X_config_fields &meshtastic_SCD4X_config_msg #define meshtastic_SEN5X_config_fields &meshtastic_SEN5X_config_msg +#define meshtastic_SEN6X_config_fields &meshtastic_SEN6X_config_msg #define meshtastic_SCD30_config_fields &meshtastic_SCD30_config_msg #define meshtastic_SHTXX_config_fields &meshtastic_SHTXX_config_msg +#define meshtastic_DS248X_config_fields &meshtastic_DS248X_config_msg /* Maximum encoded size of messages (where known) */ #define MESHTASTIC_MESHTASTIC_ADMIN_PB_H_MAX_SIZE meshtastic_AdminMessage_size #define meshtastic_AdminMessage_InputEvent_size 14 #define meshtastic_AdminMessage_OTAEvent_size 36 #define meshtastic_AdminMessage_size 511 +#define meshtastic_DS248X_config_size 6 #define meshtastic_HamParameters_size 47 #define meshtastic_KeyVerificationAdmin_size 25 #define meshtastic_LockdownAuth_size 56 #define meshtastic_NodeRemoteHardwarePinsResponse_size 496 #define meshtastic_SCD30_config_size 27 #define meshtastic_SCD4X_config_size 29 -#define meshtastic_SEN5X_config_size 7 +#define meshtastic_SEN5X_config_size 9 +#define meshtastic_SEN6X_config_size 31 #define meshtastic_SHTXX_config_size 6 -#define meshtastic_SensorConfig_size 77 +#define meshtastic_SensorConfig_size 120 #define meshtastic_SharedContact_size 127 #ifdef __cplusplus diff --git a/src/mesh/generated/meshtastic/atak.pb.h b/src/mesh/generated/meshtastic/atak.pb.h index e0dab86590..6ea298f9ed 100644 --- a/src/mesh/generated/meshtastic/atak.pb.h +++ b/src/mesh/generated/meshtastic/atak.pb.h @@ -332,7 +332,7 @@ typedef enum _meshtastic_CotType { /* y-: TAKTALK room/membership broadcast. Payload carried via the TakTalkRoomData typed variant (sender_callsign, room_id, room_name, participants). The CoT type literally has a trailing dash and no - second atom - not a typo. */ + second atom — not a typo. */ meshtastic_CotType_CotType_y = 126 } meshtastic_CotType; @@ -380,7 +380,7 @@ typedef enum _meshtastic_DrawnShape_Kind { /* u-r-b-bullseye: Bullseye ring with range rings and bearing reference */ meshtastic_DrawnShape_Kind_Kind_Bullseye = 7, /* u-d-c-e: Ellipse with distinct major/minor axes (same storage as - Kind_Circle - uses major_cm/minor_cm/angle_deg - but receivers + Kind_Circle — uses major_cm/minor_cm/angle_deg — but receivers render it as a non-circular ellipse rather than a round circle). */ meshtastic_DrawnShape_Kind_Kind_Ellipse = 8, /* u-d-v: 2D vehicle outline drawn on the map. Vertices carry the @@ -400,7 +400,7 @@ typedef enum _meshtastic_DrawnShape_Kind { end of parse; builder uses it to decide which of / to emit in the reconstructed XML. */ typedef enum _meshtastic_DrawnShape_StyleMode { - /* Unspecified - receiver infers from which color fields are non-zero. */ + /* Unspecified — receiver infers from which color fields are non-zero. */ meshtastic_DrawnShape_StyleMode_StyleMode_Unspecified = 0, /* Stroke only. No in the source XML. Used for polylines, ranging lines, bullseye rings. */ @@ -417,7 +417,7 @@ typedef enum _meshtastic_DrawnShape_StyleMode { alone is ambiguous (e.g. a-u-G could be a 2525 symbol or a custom icon depending on the iconset path). */ typedef enum _meshtastic_Marker_Kind { - /* Unspecified - fall back to TAKPacketV2.cot_type_id */ + /* Unspecified — fall back to TAKPacketV2.cot_type_id */ meshtastic_Marker_Kind_Kind_Unspecified = 0, /* b-m-p-s-m: Spot map marker */ meshtastic_Marker_Kind_Kind_Spot = 1, @@ -680,10 +680,10 @@ typedef struct _meshtastic_AircraftTrack { hundred meters of the anchor has per-vertex deltas in the ±10^4 range. Under sint32+zigzag those encode as 2 bytes each (tag+varint), versus the 4 bytes that sfixed32 would always require. At 32 vertices that is ~128 - bytes of savings - the difference between fitting under the LoRa MTU or + bytes of savings — the difference between fitting under the LoRa MTU or not. Absolute coordinates (values ~10^9) would cost sint32 varint 5 bytes per field, which is why TAKPacketV2's top-level latitude_i / longitude_i - stay sfixed32 - only small values win with sint32. */ + stay sfixed32 — only small values win with sint32. */ typedef struct _meshtastic_CotGeoPoint { /* Latitude delta from TAKPacketV2.latitude_i, in 1e-7 degree units. Add to the enclosing event's latitude_i to recover the absolute latitude. */ @@ -791,7 +791,7 @@ typedef struct _meshtastic_Marker { Covers CoT type u-rb-a. The anchor position is on TAKPacketV2.latitude_i/longitude_i; the target endpoint is carried as a - CotGeoPoint - same delta-from-anchor encoding used by DrawnShape.vertices + CotGeoPoint — same delta-from-anchor encoding used by DrawnShape.vertices so a self-anchored RAB (common case) encodes in zero bytes. */ typedef struct _meshtastic_RangeAndBearing { /* Target/anchor endpoint (delta-encoded from TAKPacketV2.latitude_i/longitude_i). */ @@ -899,12 +899,12 @@ typedef struct _meshtastic_CasevacReport { same as the envelope callsign but ATAK sometimes carries a distinct ops-number here. */ pb_callback_t title; - /* Primary medline free-text - the single most clinically important line + /* Primary medline free-text — the single most clinically important line on a MEDLINE form (e.g. "2 urgent litter patients, smoke on approach"). MUST be preserved under MTU pressure as long as any casevac is sent. */ pb_callback_t medline_remarks; /* Line 3 (newer ATAK format): patient counts by precedence level. - Coexists with the enum-style `precedence` field (tag 1) - older ATAK + Coexists with the enum-style `precedence` field (tag 1) — older ATAK emits a single enum, newer ATAK emits these counts, and both can be set simultaneously. Senders populate whichever style(s) the source XML had; receivers prefer counts when non-zero. */ @@ -946,19 +946,19 @@ typedef struct _meshtastic_CasevacReport { (e.g. "Primary HLZ is soccer field"). */ pb_callback_t hlz_remarks; /* Per-patient clinical records. Each entry is one patient's ZMIST card - (Zap number / Mechanism / Injuries / Signs / Treatment). Repeatable - + (Zap number / Mechanism / Injuries / Signs / Treatment). Repeatable — a mass-casualty event can carry 1-6 entries in practice, limited by the 237 B LoRa MTU. */ pb_callback_t zmist; } meshtastic_CasevacReport; -/* Per-patient clinical summary record - one entry per patient in a CASEVAC. +/* Per-patient clinical summary record — one entry per patient in a CASEVAC. Maps directly to ATAK's child element inside . All fields are optional free-text; senders populate what they have. */ typedef struct _meshtastic_ZMistEntry { /* Patient identifier / sequence label (e.g. "ZMIST-1", "ZMIST-2"). */ pb_callback_t title; - /* Zap number - unique patient tracking ID (often a terse code like + /* Zap number — unique patient tracking ID (often a terse code like "Gunshot" or a serial). */ pb_callback_t z; /* Mechanism of injury (e.g. "Penetrating trauma", "Blast injury"). */ @@ -997,7 +997,7 @@ typedef struct _meshtastic_EmergencyAlert { creation time; the fields below carry structured metadata the raw-detail fallback currently loses. - Fields are deliberately lean - this variant is closer to the MTU ceiling + Fields are deliberately lean — this variant is closer to the MTU ceiling than the others, so every string is capped in options. */ typedef struct _meshtastic_TaskRequest { /* Short tag for the task category (e.g. "engage", "observe", "recon", @@ -1017,7 +1017,7 @@ typedef struct _meshtastic_TaskRequest { /* Weather annotation from CoT detail element. - Attaches to any TAKPacketV2 regardless of payload_variant - an Aircraft, + Attaches to any TAKPacketV2 regardless of payload_variant — an Aircraft, PLI, or Marker can all carry observed conditions at the emitting station. ATAK-CIV ships an XSD for but no dedicated handler, so the element round-trips through the generic detail pipeline; this message @@ -1026,7 +1026,7 @@ typedef struct _meshtastic_TaskRequest { Target wire cost: ~6-8 bytes compressed with a fully populated instance. Named `TAKEnvironment` (not just `Environment`) because the bare name - collides with `SwiftUI.Environment` - every SwiftUI view in a consuming + collides with `SwiftUI.Environment` — every SwiftUI view in a consuming iOS app uses the `@Environment` property wrapper, and importing the generated proto module would make `Environment` ambiguous in every one of those files. The `TAK` prefix matches the convention used by the @@ -1055,7 +1055,7 @@ typedef struct _meshtastic_TAKEnvironment { The receiving ATAK client restores those from its own defaults, same as every other CoT carried over Meshtastic today. - Attaches to any TAKPacketV2 - a PLI with a sensor on the operator's head, + Attaches to any TAKPacketV2 — a PLI with a sensor on the operator's head, an Aircraft with a FLIR turret, a Marker dropped on a UAV. Target wire cost: ~7-14 bytes compressed (dominated by model string). */ typedef struct _meshtastic_SensorFov { @@ -1065,30 +1065,30 @@ typedef struct _meshtastic_SensorFov { SensorDetailHandler default (270°) and save varint bytes over centi-deg. */ uint32_t azimuth_deg; /* Maximum range of the cone in meters. - Optional - if unset, receivers should use the ATAK-CIV default of 100m. */ + Optional — if unset, receivers should use the ATAK-CIV default of 100m. */ bool has_range_m; uint32_t range_m; /* Horizontal field of view in whole degrees (cone's angular width). ATAK-CIV default is 45°. */ uint32_t fov_horizontal_deg; /* Vertical field of view in whole degrees. ATAK-CIV default is 45°. - Optional - a value of 0 means "not set / use horizontal FOV". */ + Optional — a value of 0 means "not set / use horizontal FOV". */ uint32_t fov_vertical_deg; /* Elevation angle in whole degrees. Positive = up, negative = down. Range -90 to +90. sint32 for varint efficiency on small negatives. */ int32_t elevation_deg; /* Roll (camera tilt) in whole degrees, -180 to +180. - Optional - use 0 if the sensor doesn't track roll. */ + Optional — use 0 if the sensor doesn't track roll. */ int32_t roll_deg; /* Free-form device model identifier, e.g. "FLIR-Boson-640", "SEEK". - Optional - empty string means "unknown model" (ATAK-CIV default). */ + Optional — empty string means "unknown model" (ATAK-CIV default). */ pb_callback_t model; } meshtastic_SensorFov; /* TAKTALK chat message payload (CoT type m-t-t). TAKTALK is an ATAK plugin for voice + text team messaging. The voice - audio stream goes over UDP/RTP and is NOT carried by the mesh - only + audio stream goes over UDP/RTP and is NOT carried by the mesh — only the text envelope (this message) is. `from_voice` marks messages sent via push-to-talk speech-to-text so receivers can render a mic icon next to the text. @@ -1122,7 +1122,7 @@ typedef struct _meshtastic_TakTalkMessage { Announces a TAKTALK chatroom's friendly name and roster so peers can resolve room UUIDs (used in TakTalkMessage.chatroom_id and GeoChat.room_id) to a display name and participant list. Not a chat - message itself - these events are emitted by TAKTALK when rooms are + message itself — these events are emitted by TAKTALK when rooms are created or memberships change. */ typedef struct _meshtastic_TakTalkRoomData { /* Callsign of the device broadcasting the room state (typically the @@ -1161,7 +1161,7 @@ typedef struct _meshtastic_Marti { primary-vs-cc distinction the same way ATAK does. If dest_callsign is [TAKPacketV2.callsign] (self-addressed, unusual but - legal - e.g. ATAK echoing back to its own room), the builder still emits + legal — e.g. ATAK echoing back to its own room), the builder still emits the element so loopback shapes round-trip cleanly. */ pb_callback_t dest_callsign; } meshtastic_Marti; diff --git a/src/mesh/generated/meshtastic/deviceonly.pb.cpp b/src/mesh/generated/meshtastic/deviceonly.pb.cpp index 5580866379..ed477630f6 100644 --- a/src/mesh/generated/meshtastic/deviceonly.pb.cpp +++ b/src/mesh/generated/meshtastic/deviceonly.pb.cpp @@ -24,7 +24,7 @@ PB_BIND(meshtastic_NodePositionEntry, meshtastic_NodePositionEntry, AUTO) PB_BIND(meshtastic_NodeTelemetryEntry, meshtastic_NodeTelemetryEntry, AUTO) -PB_BIND(meshtastic_NodeEnvironmentEntry, meshtastic_NodeEnvironmentEntry, AUTO) +PB_BIND(meshtastic_NodeEnvironmentEntry, meshtastic_NodeEnvironmentEntry, 2) PB_BIND(meshtastic_NodeStatusEntry, meshtastic_NodeStatusEntry, AUTO) diff --git a/src/mesh/generated/meshtastic/deviceonly.pb.h b/src/mesh/generated/meshtastic/deviceonly.pb.h index 669792ddd8..a4757b5ca2 100644 --- a/src/mesh/generated/meshtastic/deviceonly.pb.h +++ b/src/mesh/generated/meshtastic/deviceonly.pb.h @@ -458,7 +458,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg; #define meshtastic_BackupPreferences_size 2740 #define meshtastic_ChannelFile_size 718 #define meshtastic_DeviceState_size 1944 -#define meshtastic_NodeEnvironmentEntry_size 170 +#define meshtastic_NodeEnvironmentEntry_size 218 #define meshtastic_NodeInfoLite_size 112 #define meshtastic_NodePositionEntry_size 42 #define meshtastic_NodeStatusEntry_size 89 diff --git a/src/mesh/generated/meshtastic/mesh.pb.h b/src/mesh/generated/meshtastic/mesh.pb.h index 60d817d734..7330143592 100644 --- a/src/mesh/generated/meshtastic/mesh.pb.h +++ b/src/mesh/generated/meshtastic/mesh.pb.h @@ -1112,10 +1112,8 @@ typedef struct _meshtastic_MeshPacket { meshtastic_MeshPacket_Priority priority; /* rssi of received packet. Only sent to phone for dispay purposes. Explicit presence: rssi 0 is a legitimate reading on some radios (SX126x can report exactly - 0 dBm; SX127x's formula can even go positive), so implicit-presence proto3 made an unset - value indistinguishable from a measured one. has_rx_rssi disambiguates; a replayed packet - built from history the device never restored an RSSI for should leave this field absent - rather than emitting 0. */ + 0 dBm; SX127x's formula can even go positive). has_rx_rssi disambiguates; a replayed packet + built from history should leave this field absent rather than emitting 0. */ bool has_rx_rssi; int32_t rx_rssi; /* Describe if this message is delayed */ @@ -1269,15 +1267,15 @@ typedef struct _meshtastic_LockdownStatus { /* Current lockdown state being reported. */ meshtastic_LockdownStatus_State state; /* For LOCKED: machine-readable reason. Known values: - "needs_auth" - storage already unlocked, client must auth - "token_missing" - no boot token on flash - "token_expired" - boot token wall-clock TTL elapsed - "token_boots_zero" - boot token boot-count TTL exhausted - "token_hmac_fail" - token tampered or wrong device - "token_dek_fail" - token DEK decrypt failed - "token_wrong_size" - token file corrupted - "token_bad_magic" - token file corrupted - "not_provisioned" - should generally use NEEDS_PROVISION state instead + "needs_auth" — storage already unlocked, client must auth + "token_missing" — no boot token on flash + "token_expired" — boot token wall-clock TTL elapsed + "token_boots_zero" — boot token boot-count TTL exhausted + "token_hmac_fail" — token tampered or wrong device + "token_dek_fail" — token DEK decrypt failed + "token_wrong_size" — token file corrupted + "token_bad_magic" — token file corrupted + "not_provisioned" — should generally use NEEDS_PROVISION state instead Other values may be added; clients should treat unknown values as "locked, ask for passphrase". */ char lock_reason[32]; diff --git a/src/mesh/generated/meshtastic/mesh_beacon.pb.h b/src/mesh/generated/meshtastic/mesh_beacon.pb.h index 94312eb1e9..028d8269f5 100644 --- a/src/mesh/generated/meshtastic/mesh_beacon.pb.h +++ b/src/mesh/generated/meshtastic/mesh_beacon.pb.h @@ -15,7 +15,7 @@ /* Payload for MESH_BEACON_APP packets. Periodically broadcast by nodes in beacon mode. Listeners deliver the text message to the local inbox and cache any offered - channel/preset for the client app to act on - the firmware never auto-applies them. */ + channel/preset for the client app to act on — the firmware never auto-applies them. */ typedef struct _meshtastic_MeshBeacon { /* Human-readable beacon message. Max 100 bytes enforced by firmware on send. */ char message[101]; diff --git a/src/mesh/generated/meshtastic/module_config.pb.h b/src/mesh/generated/meshtastic/module_config.pb.h index 713a911401..b04c358fc4 100644 --- a/src/mesh/generated/meshtastic/module_config.pb.h +++ b/src/mesh/generated/meshtastic/module_config.pb.h @@ -497,7 +497,7 @@ typedef struct _meshtastic_ModuleConfig_MeshBeaconConfig { /* Single-target TX channel: channel settings (name + PSK) to send beacons on. If unset, beacons go out on the primary channel. Used only when broadcast_targets is empty. NOTE: the single-target path embeds the ChannelSettings inline here, whereas a - broadcast_targets entry references a channel-table slot by channel_index instead - see + broadcast_targets entry references a channel-table slot by channel_index instead — see BroadcastTarget. The two paths are equal, first-class options; only this representation differs. */ bool has_broadcast_on_channel; meshtastic_ChannelSettings broadcast_on_channel; @@ -514,7 +514,7 @@ typedef struct _meshtastic_ModuleConfig_MeshBeaconConfig { each temporarily switching the radio to that entry's preset/region/channel. When empty, the broadcaster uses the scalar broadcast_on_preset / broadcast_on_region / broadcast_on_channel fields instead (the single-target path). - Single- and multi-target are equal, first-class options - neither is preferred or + Single- and multi-target are equal, first-class options — neither is preferred or deprecated. They differ only in how the TX channel is named: broadcast_on_channel embeds a ChannelSettings inline, while a target references an existing channel-table slot by channel_index (see BroadcastTarget). */ diff --git a/src/mesh/generated/meshtastic/telemetry.pb.cpp b/src/mesh/generated/meshtastic/telemetry.pb.cpp index bc21b9dcbe..64cc0422f0 100644 --- a/src/mesh/generated/meshtastic/telemetry.pb.cpp +++ b/src/mesh/generated/meshtastic/telemetry.pb.cpp @@ -9,7 +9,7 @@ PB_BIND(meshtastic_DeviceMetrics, meshtastic_DeviceMetrics, AUTO) -PB_BIND(meshtastic_EnvironmentMetrics, meshtastic_EnvironmentMetrics, AUTO) +PB_BIND(meshtastic_EnvironmentMetrics, meshtastic_EnvironmentMetrics, 2) PB_BIND(meshtastic_PowerMetrics, meshtastic_PowerMetrics, AUTO) @@ -39,6 +39,9 @@ PB_BIND(meshtastic_Nau7802Config, meshtastic_Nau7802Config, AUTO) PB_BIND(meshtastic_SEN5XState, meshtastic_SEN5XState, AUTO) +PB_BIND(meshtastic_SEN6XState, meshtastic_SEN6XState, AUTO) + + diff --git a/src/mesh/generated/meshtastic/telemetry.pb.h b/src/mesh/generated/meshtastic/telemetry.pb.h index 36f9305612..8c01688433 100644 --- a/src/mesh/generated/meshtastic/telemetry.pb.h +++ b/src/mesh/generated/meshtastic/telemetry.pb.h @@ -123,7 +123,9 @@ typedef enum _meshtastic_TelemetrySensorType { /* SPA06 pressure and temperature */ meshtastic_TelemetrySensorType_SPA06 = 54, /* HM330X PM SENSOR */ - meshtastic_TelemetrySensorType_HM330X = 55 + meshtastic_TelemetrySensorType_HM330X = 55, + /* Sensirion SEN6X PM/RHT/VOC/NOx/CO2/HCHO sensor family (SEN62, SEN63C, SEN65, SEN66, SEN68, SEN69C) */ + meshtastic_TelemetrySensorType_SEN6X = 56 } meshtastic_TelemetrySensorType; /* Struct definitions */ @@ -216,9 +218,54 @@ typedef struct _meshtastic_EnvironmentMetrics { /* Soil temperature measured (*C) */ bool has_soil_temperature; float soil_temperature; - /* One-wire temperature (*C) */ - pb_size_t one_wire_temperature_count; - float one_wire_temperature[8]; + /* Multi-channel ADC Voltage Channel 0 (V) */ + bool has_adc_voltage_ch0; + float adc_voltage_ch0; + /* Multi-channel ADC Voltage Channel 1 (V) */ + bool has_adc_voltage_ch1; + float adc_voltage_ch1; + /* Multi-channel ADC Voltage Channel 2 (V) */ + bool has_adc_voltage_ch2; + float adc_voltage_ch2; + /* Multi-channel ADC Voltage Channel 3 (V) */ + bool has_adc_voltage_ch3; + float adc_voltage_ch3; + /* Multi-channel ADC Voltage Channel 4 (V) */ + bool has_adc_voltage_ch4; + float adc_voltage_ch4; + /* Multi-channel ADC Voltage Channel 5 (V) */ + bool has_adc_voltage_ch5; + float adc_voltage_ch5; + /* Multi-channel ADC Voltage Channel 6 (V) */ + bool has_adc_voltage_ch6; + float adc_voltage_ch6; + /* Multi-channel ADC Voltage Channel 7 (V) */ + bool has_adc_voltage_ch7; + float adc_voltage_ch7; + /* Multi-channel One-Wire Temperature Channel 0 (*C) */ + bool has_one_wire_temperature_ch0; + float one_wire_temperature_ch0; + /* Multi-channel One-Wire Temperature Channel 1 (*C) */ + bool has_one_wire_temperature_ch1; + float one_wire_temperature_ch1; + /* Multi-channel One-Wire Temperature Channel 2 (*C) */ + bool has_one_wire_temperature_ch2; + float one_wire_temperature_ch2; + /* Multi-channel One-Wire Temperature Channel 3 (*C) */ + bool has_one_wire_temperature_ch3; + float one_wire_temperature_ch3; + /* Multi-channel One-Wire Temperature Channel 4 (*C) */ + bool has_one_wire_temperature_ch4; + float one_wire_temperature_ch4; + /* Multi-channel One-Wire Temperature Channel 5 (*C) */ + bool has_one_wire_temperature_ch5; + float one_wire_temperature_ch5; + /* Multi-channel One-Wire Temperature Channel 6 (*C) */ + bool has_one_wire_temperature_ch6; + float one_wire_temperature_ch6; + /* Multi-channel One-Wire Temperature Channel 7 (*C) */ + bool has_one_wire_temperature_ch7; + float one_wire_temperature_ch7; } meshtastic_EnvironmentMetrics; /* Power Metrics (voltage / current / etc) */ @@ -241,34 +288,34 @@ typedef struct _meshtastic_PowerMetrics { /* Current (Ch3) */ bool has_ch3_current; float ch3_current; - /* Voltage (Ch4) */ + /* Voltage (Ch4) - TODO Remove */ bool has_ch4_voltage; float ch4_voltage; - /* Current (Ch4) */ + /* Current (Ch4) - TODO Remove */ bool has_ch4_current; float ch4_current; - /* Voltage (Ch5) */ + /* Voltage (Ch5) - TODO Remove */ bool has_ch5_voltage; float ch5_voltage; - /* Current (Ch5) */ + /* Current (Ch5) - TODO Remove */ bool has_ch5_current; float ch5_current; - /* Voltage (Ch6) */ + /* Voltage (Ch6) - TODO Remove */ bool has_ch6_voltage; float ch6_voltage; - /* Current (Ch6) */ + /* Current (Ch6) - TODO Remove */ bool has_ch6_current; float ch6_current; - /* Voltage (Ch7) */ + /* Voltage (Ch7) - TODO Remove */ bool has_ch7_voltage; float ch7_voltage; - /* Current (Ch7) */ + /* Current (Ch7) - TODO Remove */ bool has_ch7_current; float ch7_current; - /* Voltage (Ch8) */ + /* Voltage (Ch8) - TODO Remove */ bool has_ch8_voltage; float ch8_voltage; - /* Current (Ch8) */ + /* Current (Ch8) - TODO Remove */ bool has_ch8_current; float ch8_current; } meshtastic_PowerMetrics; @@ -350,6 +397,12 @@ typedef struct _meshtastic_AirQualityMetrics { /* Typical Particle Size in um */ bool has_particles_tps; float particles_tps; + /* Raw PM sensor device status/error register bitmask, as defined by the sensor's own datasheet + (currently populated by the SEN6X family: bit 4 fan error, bit 6 RH&T error, bit 7 gas/VOC-NOx + error, bit 9 CO2 error (SEN66), bit 10 HCHO error, bit 11 PM error, bit 12 CO2 error (SEN63C/SEN69C), + bit 21 fan speed warning) */ + bool has_pm_status_flags; + uint32_t pm_status_flags; } meshtastic_AirQualityMetrics; /* Local device mesh statistics */ @@ -478,7 +531,7 @@ typedef struct _meshtastic_Nau7802Config { float calibrationFactor; } meshtastic_Nau7802Config; -/* SEN5X State, for saving to flash */ +/* SEN5X State, for saving to flash (to be merged with SEN6XState) */ typedef struct _meshtastic_SEN5XState { /* Last cleaning time for SEN5X */ uint32_t last_cleaning_time; @@ -497,6 +550,25 @@ typedef struct _meshtastic_SEN5XState { uint64_t voc_state_array; } meshtastic_SEN5XState; +/* SEN6X State, for saving to flash */ +typedef struct _meshtastic_SEN6XState { + /* Last cleaning time for SEN6X */ + uint32_t last_cleaning_time; + /* Last cleaning time for SEN6X - valid flag */ + bool last_cleaning_valid; + /* Config flag for one-shot mode (see admin.proto) */ + bool one_shot_mode; + /* Last VOC state time, for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C) */ + bool has_voc_state_time; + uint32_t voc_state_time; + /* Last VOC state validity flag, for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C) */ + bool has_voc_state_valid; + bool voc_state_valid; + /* VOC state array (8x uint8t), for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C) */ + bool has_voc_state_array; + uint64_t voc_state_array; +} meshtastic_SEN6XState; + #ifdef __cplusplus extern "C" { @@ -504,8 +576,9 @@ extern "C" { /* Helper constants for enums */ #define _meshtastic_TelemetrySensorType_MIN meshtastic_TelemetrySensorType_SENSOR_UNSET -#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_HM330X -#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_HM330X+1)) +#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_SEN6X +#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_SEN6X+1)) + @@ -521,9 +594,9 @@ extern "C" { /* Initializer values for message structs */ #define meshtastic_DeviceMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0} -#define meshtastic_EnvironmentMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}} +#define meshtastic_EnvironmentMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_PowerMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} -#define meshtastic_AirQualityMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} +#define meshtastic_AirQualityMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_LocalStats_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} #define meshtastic_TrafficManagementStats_init_default {0, 0, 0, 0, 0, 0, 0} #define meshtastic_HealthMetrics_init_default {false, 0, false, 0, false, 0} @@ -531,10 +604,11 @@ extern "C" { #define meshtastic_Telemetry_init_default {0, 0, {meshtastic_DeviceMetrics_init_default}} #define meshtastic_Nau7802Config_init_default {0, 0} #define meshtastic_SEN5XState_init_default {0, 0, 0, false, 0, false, 0, false, 0} +#define meshtastic_SEN6XState_init_default {0, 0, 0, false, 0, false, 0, false, 0} #define meshtastic_DeviceMetrics_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0} -#define meshtastic_EnvironmentMetrics_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}} +#define meshtastic_EnvironmentMetrics_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_PowerMetrics_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} -#define meshtastic_AirQualityMetrics_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} +#define meshtastic_AirQualityMetrics_init_zero {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0} #define meshtastic_LocalStats_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} #define meshtastic_TrafficManagementStats_init_zero {0, 0, 0, 0, 0, 0, 0} #define meshtastic_HealthMetrics_init_zero {false, 0, false, 0, false, 0} @@ -542,6 +616,7 @@ extern "C" { #define meshtastic_Telemetry_init_zero {0, 0, {meshtastic_DeviceMetrics_init_zero}} #define meshtastic_Nau7802Config_init_zero {0, 0} #define meshtastic_SEN5XState_init_zero {0, 0, 0, false, 0, false, 0, false, 0} +#define meshtastic_SEN6XState_init_zero {0, 0, 0, false, 0, false, 0, false, 0} /* Field tags (for use in manual encoding/decoding) */ #define meshtastic_DeviceMetrics_battery_level_tag 1 @@ -571,7 +646,22 @@ extern "C" { #define meshtastic_EnvironmentMetrics_rainfall_24h_tag 20 #define meshtastic_EnvironmentMetrics_soil_moisture_tag 21 #define meshtastic_EnvironmentMetrics_soil_temperature_tag 22 -#define meshtastic_EnvironmentMetrics_one_wire_temperature_tag 23 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch0_tag 24 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch1_tag 25 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch2_tag 26 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch3_tag 27 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch4_tag 28 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch5_tag 29 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch6_tag 30 +#define meshtastic_EnvironmentMetrics_adc_voltage_ch7_tag 31 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch0_tag 32 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch1_tag 33 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch2_tag 34 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch3_tag 35 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch4_tag 36 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch5_tag 37 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch6_tag 38 +#define meshtastic_EnvironmentMetrics_one_wire_temperature_ch7_tag 39 #define meshtastic_PowerMetrics_ch1_voltage_tag 1 #define meshtastic_PowerMetrics_ch1_current_tag 2 #define meshtastic_PowerMetrics_ch2_voltage_tag 3 @@ -613,6 +703,7 @@ extern "C" { #define meshtastic_AirQualityMetrics_pm_voc_idx_tag 23 #define meshtastic_AirQualityMetrics_pm_nox_idx_tag 24 #define meshtastic_AirQualityMetrics_particles_tps_tag 25 +#define meshtastic_AirQualityMetrics_pm_status_flags_tag 26 #define meshtastic_LocalStats_uptime_seconds_tag 1 #define meshtastic_LocalStats_channel_utilization_tag 2 #define meshtastic_LocalStats_air_util_tx_tag 3 @@ -664,6 +755,12 @@ extern "C" { #define meshtastic_SEN5XState_voc_state_time_tag 4 #define meshtastic_SEN5XState_voc_state_valid_tag 5 #define meshtastic_SEN5XState_voc_state_array_tag 6 +#define meshtastic_SEN6XState_last_cleaning_time_tag 1 +#define meshtastic_SEN6XState_last_cleaning_valid_tag 2 +#define meshtastic_SEN6XState_one_shot_mode_tag 3 +#define meshtastic_SEN6XState_voc_state_time_tag 4 +#define meshtastic_SEN6XState_voc_state_valid_tag 5 +#define meshtastic_SEN6XState_voc_state_array_tag 6 /* Struct field encoding specification for nanopb */ #define meshtastic_DeviceMetrics_FIELDLIST(X, a) \ @@ -698,7 +795,22 @@ X(a, STATIC, OPTIONAL, FLOAT, rainfall_1h, 19) \ X(a, STATIC, OPTIONAL, FLOAT, rainfall_24h, 20) \ X(a, STATIC, OPTIONAL, UINT32, soil_moisture, 21) \ X(a, STATIC, OPTIONAL, FLOAT, soil_temperature, 22) \ -X(a, STATIC, REPEATED, FLOAT, one_wire_temperature, 23) +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch0, 24) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch1, 25) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch2, 26) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch3, 27) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch4, 28) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch5, 29) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch6, 30) \ +X(a, STATIC, OPTIONAL, FLOAT, adc_voltage_ch7, 31) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch0, 32) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch1, 33) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch2, 34) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch3, 35) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch4, 36) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch5, 37) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch6, 38) \ +X(a, STATIC, OPTIONAL, FLOAT, one_wire_temperature_ch7, 39) #define meshtastic_EnvironmentMetrics_CALLBACK NULL #define meshtastic_EnvironmentMetrics_DEFAULT NULL @@ -747,7 +859,8 @@ X(a, STATIC, OPTIONAL, FLOAT, pm_temperature, 21) \ X(a, STATIC, OPTIONAL, FLOAT, pm_humidity, 22) \ X(a, STATIC, OPTIONAL, FLOAT, pm_voc_idx, 23) \ X(a, STATIC, OPTIONAL, FLOAT, pm_nox_idx, 24) \ -X(a, STATIC, OPTIONAL, FLOAT, particles_tps, 25) +X(a, STATIC, OPTIONAL, FLOAT, particles_tps, 25) \ +X(a, STATIC, OPTIONAL, UINT32, pm_status_flags, 26) #define meshtastic_AirQualityMetrics_CALLBACK NULL #define meshtastic_AirQualityMetrics_DEFAULT NULL @@ -838,6 +951,16 @@ X(a, STATIC, OPTIONAL, FIXED64, voc_state_array, 6) #define meshtastic_SEN5XState_CALLBACK NULL #define meshtastic_SEN5XState_DEFAULT NULL +#define meshtastic_SEN6XState_FIELDLIST(X, a) \ +X(a, STATIC, SINGULAR, UINT32, last_cleaning_time, 1) \ +X(a, STATIC, SINGULAR, BOOL, last_cleaning_valid, 2) \ +X(a, STATIC, SINGULAR, BOOL, one_shot_mode, 3) \ +X(a, STATIC, OPTIONAL, UINT32, voc_state_time, 4) \ +X(a, STATIC, OPTIONAL, BOOL, voc_state_valid, 5) \ +X(a, STATIC, OPTIONAL, FIXED64, voc_state_array, 6) +#define meshtastic_SEN6XState_CALLBACK NULL +#define meshtastic_SEN6XState_DEFAULT NULL + extern const pb_msgdesc_t meshtastic_DeviceMetrics_msg; extern const pb_msgdesc_t meshtastic_EnvironmentMetrics_msg; extern const pb_msgdesc_t meshtastic_PowerMetrics_msg; @@ -849,6 +972,7 @@ extern const pb_msgdesc_t meshtastic_HostMetrics_msg; extern const pb_msgdesc_t meshtastic_Telemetry_msg; extern const pb_msgdesc_t meshtastic_Nau7802Config_msg; extern const pb_msgdesc_t meshtastic_SEN5XState_msg; +extern const pb_msgdesc_t meshtastic_SEN6XState_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ #define meshtastic_DeviceMetrics_fields &meshtastic_DeviceMetrics_msg @@ -862,18 +986,20 @@ extern const pb_msgdesc_t meshtastic_SEN5XState_msg; #define meshtastic_Telemetry_fields &meshtastic_Telemetry_msg #define meshtastic_Nau7802Config_fields &meshtastic_Nau7802Config_msg #define meshtastic_SEN5XState_fields &meshtastic_SEN5XState_msg +#define meshtastic_SEN6XState_fields &meshtastic_SEN6XState_msg /* Maximum encoded size of messages (where known) */ #define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size -#define meshtastic_AirQualityMetrics_size 150 +#define meshtastic_AirQualityMetrics_size 157 #define meshtastic_DeviceMetrics_size 27 -#define meshtastic_EnvironmentMetrics_size 161 +#define meshtastic_EnvironmentMetrics_size 209 #define meshtastic_HealthMetrics_size 11 #define meshtastic_HostMetrics_size 264 #define meshtastic_LocalStats_size 87 #define meshtastic_Nau7802Config_size 16 #define meshtastic_PowerMetrics_size 81 #define meshtastic_SEN5XState_size 27 +#define meshtastic_SEN6XState_size 27 #define meshtastic_Telemetry_size 272 #define meshtastic_TrafficManagementStats_size 42 diff --git a/src/mesh/http/WebServer.cpp b/src/mesh/http/WebServer.cpp index 5e42aa389d..84ea8fea48 100644 --- a/src/mesh/http/WebServer.cpp +++ b/src/mesh/http/WebServer.cpp @@ -102,7 +102,7 @@ static void taskCreateCert(void *parameter) size_t certLen = prefs.getBytesLength("cert"); if (pkLen && certLen) { - LOG_INFO("Existing SSL Certificate found!"); + LOG_INFO("Existing SSL Certificate found"); uint8_t *pkBuffer = new uint8_t[pkLen]; prefs.getBytes("PK", pkBuffer, pkLen); @@ -180,7 +180,7 @@ void createSSLCert() runLoop = true; } } - LOG_INFO("SSL Cert Ready!"); + LOG_INFO("SSL Cert Ready"); } } diff --git a/src/mesh/mesh-pb-constants.h b/src/mesh/mesh-pb-constants.h index 1c376818af..aa41c16952 100644 --- a/src/mesh/mesh-pb-constants.h +++ b/src/mesh/mesh-pb-constants.h @@ -26,7 +26,7 @@ // FIXME - max_count is actually 32 but we save/load this as one long string of preencoded MeshPacket bytes - not a big array in // RAM #define MAX_RX_TOPHONE (member_size(DeviceState, receive_queue) / member_size(DeviceState, receive_queue[0])) #ifndef MAX_RX_TOPHONE -#if defined(ARCH_ESP32) && !(defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)) +#if defined(ARCH_STM32WL) || (defined(ARCH_ESP32) && !(defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3))) #define MAX_RX_TOPHONE 8 #elif defined(NRF52840_XXAA) // Each slot is a ~340 B MeshPacket in the static pool (Router.cpp MAX_PACKETS_STATIC), so 32 slots @@ -34,10 +34,8 @@ // the 8 classic ESP32 has shipped with for years; drops start when a stalled phone/serial client has // 16 packets queued. #define MAX_RX_TOPHONE 16 -#elif MESHTASTIC_MEM_CLASS >= MEM_CLASS_MEDIUM || defined(ARCH_RP2040) || defined(CONFIG_IDF_TARGET_ESP32C3) || \ - defined(ARCH_STM32WL) -// RP2040/RP2350, ESP32-C3 and STM32WL keep their historical 32 (no field pressure to cut them; -// STM32WL's pool is dynamic, so the constant only bounds in-flight packets there). +#elif MESHTASTIC_MEM_CLASS >= MEM_CLASS_MEDIUM || defined(ARCH_RP2040) || defined(CONFIG_IDF_TARGET_ESP32C3) +// RP2040/RP2350 and ESP32-C3 keep their historical 32. #define MAX_RX_TOPHONE 32 #else #define MAX_RX_TOPHONE 16 // unclassified small parts: fail safe-small @@ -131,8 +129,12 @@ static inline int get_max_num_nodes() /// full mesh, floored at 100. Shared by PacketHistory's constructor clamp and /// the boot-cache budget assert below so the two cannot drift. #ifndef PACKETHISTORY_MAX +#if defined(ARCH_STM32WL) +#define PACKETHISTORY_MAX (MAX_NUM_NODES * 2) // 20 entries for 10-node STM32WL +#else #define PACKETHISTORY_MAX (MAX_NUM_NODES * 2 > 100 ? (uint32_t)(MAX_NUM_NODES * 2) : (uint32_t)100) #endif +#endif /// Per-map cap (position/telemetry/environment/status): only the freshest /// MAX_SATELLITE_NODES nodes keep satellite payloads, the rest just the diff --git a/src/mesh/raspihttp/PiWebServer.cpp b/src/mesh/raspihttp/PiWebServer.cpp index e5f96aa928..9158a30611 100644 --- a/src/mesh/raspihttp/PiWebServer.cpp +++ b/src/mesh/raspihttp/PiWebServer.cpp @@ -198,7 +198,7 @@ int callback_static_file(const struct _u_request *request, struct _u_response *r content_type = u_map_get_case(&configWeb.mime_types, get_filename_ext(file_requested)); if (content_type == NULL) { content_type = u_map_get(&configWeb.mime_types, "*"); - LOG_DEBUG("Static File Server - Unknown mime type for extension %s ", get_filename_ext(file_requested)); + LOG_DEBUG("Static File Server - Unknown mime type for ext %s ", get_filename_ext(file_requested)); } u_map_put(response->map_header, "Content-Type", content_type); u_map_copy_into(response->map_header, &configWeb.map_header); @@ -230,7 +230,7 @@ int callback_static_file(const struct _u_request *request, struct _u_response *r free(real_path); // realpath uses malloc return U_CALLBACK_CONTINUE; } else { - LOG_DEBUG("Static File Server - Error, user_data is NULL or inconsistent"); + LOG_DEBUG("Static File Server - user_data NULL or inconsistent"); return U_CALLBACK_ERROR; } } @@ -303,7 +303,7 @@ int handleAPIv1FromRadio(const struct _u_request *req, struct _u_response *res, ulfius_set_string_body_response(res, 200, tmpa); // LOG_DEBUG("\n----webAPI response all:----"); // LOG_DEBUG(tmpa); - // LOG_DEBUG(""); + // LOG_DEBUG("."); } // Otherwise, just return one protobuf } else { @@ -312,7 +312,7 @@ int handleAPIv1FromRadio(const struct _u_request *req, struct _u_response *res, ulfius_set_binary_body_response(res, 200, tmpa, len); // LOG_DEBUG("\n----webAPI response:"); // LOG_DEBUG(tmpa); - // LOG_DEBUG(""); + // LOG_DEBUG("."); } // LOG_DEBUG("end radio->web", len); @@ -381,7 +381,7 @@ char *read_file_into_string(const char *filename) // reserve mem for file + 1 byte char *buffer = (char *)malloc(filesize + 1); if (buffer == NULL) { - LOG_ERROR("Malloc of mem failed for file : %s ", filename); + LOG_ERROR("Malloc failed for file : %s ", filename); fclose(file); return NULL; } @@ -406,13 +406,13 @@ int PiWebServerThread::CheckSSLandLoad() // read certificate cert_pem = read_file_into_string(CERT_PATH); if (cert_pem == NULL) { - LOG_ERROR("ERROR SSL Certificate File can't be loaded or is missing"); + LOG_ERROR("SSL Certificate File can't be loaded or missing"); return 1; } // read private key key_pem = read_file_into_string(KEY_PATH); if (key_pem == NULL) { - LOG_ERROR("ERROR file private_key can't be loaded or is missing"); + LOG_ERROR("File private_key can't be loaded or missing"); return 2; } @@ -479,13 +479,13 @@ PiWebServerThread::PiWebServerThread() webservport = portduino_config.webserverport; LOG_INFO("Use webserver port from yaml config %i ", webservport); } else { - LOG_INFO("Webserver port in yaml config set to 0, defaulting to port 9443"); + LOG_INFO("Webserver port in yaml config 0, default to 9443"); webservport = 9443; } // Web Content Service Instance if (ulfius_init_instance(&instanceWeb, webservport, NULL, DEFAULT_REALM) != U_OK) { - LOG_ERROR("Webserver couldn't be started, abort execution"); + LOG_ERROR("Webserver start failed, abort"); } else { LOG_INFO("Webserver started"); @@ -534,7 +534,7 @@ PiWebServerThread::PiWebServerThread() LOG_INFO("Web Server framework started on port: %i ", webservport); LOG_INFO("Web Server root %s", (char *)webrootpath.c_str()); } else { - LOG_ERROR("Error starting Web Server framework, error number: %d", retssl); + LOG_ERROR("Web Server framework start failed, err: %d", retssl); } } } diff --git a/src/mesh/wifi/WiFiAPClient.cpp b/src/mesh/wifi/WiFiAPClient.cpp index d84bbfeb75..c7fc1b25fb 100644 --- a/src/mesh/wifi/WiFiAPClient.cpp +++ b/src/mesh/wifi/WiFiAPClient.cpp @@ -98,21 +98,40 @@ static int32_t ethNetworkConnectedPoll() } #endif +#if defined(USE_WS5500) || defined(USE_CH390D) +// Needs the netif, so only valid after ETH.begin(). Failures fall back to DHCP +static void applyEthStaticIp() +{ + if (config.network.address_mode != meshtastic_Config_NetworkConfig_AddressMode_STATIC) + return; + + if (config.network.ipv4_config.ip == 0) + LOG_WARN("Static address mode but no IP configured, using DHCP"); + else if (!ETH.config(config.network.ipv4_config.ip, config.network.ipv4_config.gateway, config.network.ipv4_config.subnet, + config.network.ipv4_config.dns)) + LOG_ERROR("Failed to apply static IP to Ethernet, using DHCP"); +} +#endif + #ifdef USE_WS5500 // Startup Ethernet bool initEthernet() { - if ((config.network.eth_enabled) && (ETH.begin(ETH_PHY_W5500, 1, ETH_CS_PIN, ETH_INT_PIN, ETH_RST_PIN, SPI3_HOST, - ETH_SCLK_PIN, ETH_MISO_PIN, ETH_MOSI_PIN))) { - WiFi.onEvent(WiFiEvent); -#if !MESHTASTIC_EXCLUDE_WEBSERVER - createSSLCert(); // For WebServer -#endif - new concurrency::Periodic("EthConnect", ethNetworkConnectedPoll); - return true; - } + if (!config.network.eth_enabled) + return false; - return false; + // Register before begin(): static config can fire ETH_GOT_IP immediately + WiFi.onEvent(WiFiEvent); + + if (!ETH.begin(ETH_PHY_W5500, 1, ETH_CS_PIN, ETH_INT_PIN, ETH_RST_PIN, SPI3_HOST, ETH_SCLK_PIN, ETH_MISO_PIN, ETH_MOSI_PIN)) + return false; + + applyEthStaticIp(); +#if !MESHTASTIC_EXCLUDE_WEBSERVER + createSSLCert(); // For WebServer +#endif + new concurrency::Periodic("EthConnect", ethNetworkConnectedPoll); + return true; } #endif @@ -120,6 +139,9 @@ bool initEthernet() // Startup Ethernet bool initEthernet() { + if (!config.network.eth_enabled) + return false; + // Configure CH390 ch390_config_t ch390_conf = CH390_DEFAULT_CONFIG(); ch390_conf.spi_host = SPI3_HOST; @@ -134,16 +156,19 @@ bool initEthernet() ch390_conf.reset_gpio = -1; #endif ch390_conf.spi_clock_mhz = 20; - if ((config.network.eth_enabled) && (ETH.begin(ch390_conf))) { - WiFi.onEvent(WiFiEvent); -#if !MESHTASTIC_EXCLUDE_WEBSERVER - createSSLCert(); // For WebServer -#endif - new concurrency::Periodic("EthConnect", ethNetworkConnectedPoll); - return true; - } - return false; + // Register before begin(): static config can fire ETH_GOT_IP immediately + WiFi.onEvent(WiFiEvent); + + if (!ETH.begin(ch390_conf)) + return false; + + applyEthStaticIp(); +#if !MESHTASTIC_EXCLUDE_WEBSERVER + createSSLCert(); // For WebServer +#endif + new concurrency::Periodic("EthConnect", ethNetworkConnectedPoll); + return true; } #endif @@ -155,7 +180,7 @@ static void onNetworkConnected() // start mdns if (!MDNS.begin("Meshtastic")) { - LOG_ERROR("Error setting up mDNS responder!"); + LOG_ERROR("mDNS setup failed"); } else { LOG_INFO("mDNS Host: Meshtastic.local"); MDNS.addService("meshtastic", "tcp", SERVER_API_DEFAULT_PORT); @@ -270,7 +295,7 @@ static int32_t reconnectWiFi() if (WiFi.isConnected() && (!Throttle::isWithinTimespanMs(lastrun_ntp, 43200000) || (lastrun_ntp == 0))) { // every 12 hours LOG_DEBUG("Update NTP time from %s", config.network.ntp_server); if (timeClient.update()) { - LOG_DEBUG("NTP Request Success - Setting RTCQualityNTP if needed"); + LOG_DEBUG("NTP success - set RTCQualityNTP if needed"); struct timeval tv; tv.tv_sec = timeClient.getEpochTime(); @@ -477,7 +502,7 @@ static void WiFiEvent(WiFiEvent_t event) } break; case ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE: - LOG_INFO("Authentication mode of access point has changed"); + LOG_INFO("AP auth mode changed"); break; case ARDUINO_EVENT_WIFI_STA_GOT_IP: LOG_INFO("Obtained IP address: %s", WiFi.localIP().toString().c_str()); @@ -493,7 +518,7 @@ static void WiFiEvent(WiFiEvent_t event) #endif break; case ARDUINO_EVENT_WIFI_STA_LOST_IP: - LOG_INFO("Lost IP address and IP address is reset to 0"); + LOG_INFO("Lost IP address, reset to 0"); #if HAS_UDP_MULTICAST if (udpHandler) { udpHandler->stop(); @@ -507,19 +532,19 @@ static void WiFiEvent(WiFiEvent_t event) } break; case ARDUINO_EVENT_WPS_ER_SUCCESS: - LOG_INFO("WiFi Protected Setup (WPS): succeeded in enrollee mode"); + LOG_INFO("WPS: succeeded in enrollee mode"); break; case ARDUINO_EVENT_WPS_ER_FAILED: - LOG_INFO("WiFi Protected Setup (WPS): failed in enrollee mode"); + LOG_INFO("WPS: failed in enrollee mode"); break; case ARDUINO_EVENT_WPS_ER_TIMEOUT: - LOG_INFO("WiFi Protected Setup (WPS): timeout in enrollee mode"); + LOG_INFO("WPS: timeout in enrollee mode"); break; case ARDUINO_EVENT_WPS_ER_PIN: - LOG_INFO("WiFi Protected Setup (WPS): pin code in enrollee mode"); + LOG_INFO("WPS: pin code in enrollee mode"); break; case ARDUINO_EVENT_WPS_ER_PBC_OVERLAP: - LOG_INFO("WiFi Protected Setup (WPS): push button overlap in enrollee mode"); + LOG_INFO("WPS: push button overlap in enrollee mode"); break; case ARDUINO_EVENT_WIFI_AP_START: LOG_INFO("WiFi access point started"); diff --git a/src/modules/AdminModule.cpp b/src/modules/AdminModule.cpp index 410ce8fed2..80bb799036 100644 --- a/src/modules/AdminModule.cpp +++ b/src/modules/AdminModule.cpp @@ -151,7 +151,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta LOG_INFO("Ignore admin response from 0x%08x, no outstanding request", mp.from); return handled; } - LOG_DEBUG("Allow admin response message"); + LOG_TRACE("Allow admin response message"); } else if (mp.from == 0) { // Local admin from a BLE/USB/TCP client. from == 0 cannot arrive from the // mesh: RF drops packets without a sender (RadioLibInterface) and MQTT treats @@ -170,13 +170,13 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta // apply: refuse all plain local admin and require PKC instead. #ifndef MESHTASTIC_PHONEAPI_ACCESS_CONTROL if (config.security.is_managed) { - LOG_INFO("Ignore local admin payload because is_managed"); + LOG_INFO("Ignore local admin payload: is_managed"); return handled; } #endif } else if (strcasecmp(ch->settings.name, Channels::adminChannel) == 0) { if (!config.security.admin_channel_enabled) { - LOG_INFO("Ignore admin channel, legacy admin is disabled"); + LOG_INFO("Ignore admin channel, legacy admin disabled"); myReply = allocErrorResponse(meshtastic_Routing_Error_NOT_AUTHORIZED, &mp); return handled; } @@ -206,10 +206,10 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) { // Special case for CLIENT_BASE: is_favorite has special meaning, and we don't want to automatically set it // without the user doing so deliberately. - LOG_INFO("PKC admin valid, but not auto-favoriting node %x because role==CLIENT_BASE", mp.from); + LOG_INFO("PKC admin valid, not auto-favoriting node 0x%08x: role==CLIENT_BASE", mp.from); } else { if (nodeDB->setProtectedFlag(remoteNode, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true)) { - LOG_INFO("PKC admin valid. Auto-favoriting node %x", mp.from); + LOG_INFO("PKC admin valid. Auto-favoriting node 0x%08x", mp.from); } else { LOG_WARN("PKC admin valid, but auto-favorite refused for node %x (protected-node cap)", mp.from); } @@ -217,7 +217,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta } } else { myReply = allocErrorResponse(meshtastic_Routing_Error_ADMIN_PUBLIC_KEY_UNAUTHORIZED, &mp); - LOG_INFO("Received PKC admin payload, but the sender public key does not match the admin authorized key!"); + LOG_INFO("PKC admin payload: sender public key doesn't match admin authorized key"); return handled; } } else { @@ -232,7 +232,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta // any message that changes state, we want to check the passkey for if (mp.from != 0 && !messageIsRequest(r) && !messageIsResponse(r)) { if (!checkPassKey(r)) { - LOG_WARN("Admin message without session_key!"); + LOG_WARN("Admin message without session_key"); myReply = allocErrorResponse(meshtastic_Routing_Error_ADMIN_BAD_SESSION_KEY, &mp); return handled; } @@ -249,7 +249,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta // but if it ever does (e.g. injected via a non-PhoneAPI path), drop // it silently rather than leaking a partial response. case meshtastic_AdminMessage_lockdown_auth_tag: - LOG_WARN("AdminModule: lockdown_auth reached Router/AdminModule path; ignoring (should be handled in PhoneAPI)"); + LOG_WARN("AdminModule: lockdown_auth reached Router/AdminModule path; ignoring (PhoneAPI handles)"); return handled; #endif // MESHTASTIC_ENCRYPTED_STORAGE @@ -293,7 +293,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta while (*start && isspace((unsigned char)*start)) start++; if (*start == '\0') { - LOG_WARN("Rejected long_name: must contain at least 1 non-whitespace character"); + LOG_WARN("Rejected long_name: needs 1+ non-whitespace char"); myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp); break; } @@ -303,7 +303,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta while (*start && isspace((unsigned char)*start)) start++; if (*start == '\0') { - LOG_WARN("Rejected short_name: must contain at least 1 non-whitespace character"); + LOG_WARN("Rejected short_name: needs 1+ non-whitespace char"); myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp); break; } @@ -336,7 +336,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } - LOG_WARN("Radio hardware does not support 2.4 GHz; rejecting LORA_24 region"); + LOG_WARN("No 2.4 GHz radio support; rejecting LORA_24 region"); myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp); break; } @@ -479,14 +479,14 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_begin_edit_settings_tag: { - LOG_INFO("Begin transaction for editing settings"); + LOG_INFO("Begin settings edit transaction"); hasOpenEditTransaction = true; editTransactionActivityMs = millis(); break; } case meshtastic_AdminMessage_commit_edit_settings_tag: { disableBluetooth(); - LOG_INFO("Commit transaction for edited settings"); + LOG_INFO("Commit settings edit transaction"); hasOpenEditTransaction = false; deferredEditSegments = 0; saveChanges(SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS | SEGMENT_NODEDATABASE); @@ -499,7 +499,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_get_module_config_response_tag: { - LOG_INFO("Client received a get_module_config response"); + LOG_INFO("Client got get_module_config response"); // which_payload_variant is the ModuleConfig oneof tag, so compare against that tag, not the // AdminMessage ModuleConfigType enum (whose REMOTEHARDWARE value is a different number). if (fromOthers && r->get_module_config_response.which_payload_variant == meshtastic_ModuleConfig_remote_hardware_tag) { @@ -508,17 +508,17 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_remove_by_nodenum_tag: { - LOG_INFO("Client received remove_nodenum command"); + LOG_INFO("Client got remove_nodenum"); nodeDB->removeNodeByNum(r->remove_by_nodenum); break; } case meshtastic_AdminMessage_add_contact_tag: { - LOG_INFO("Client received add_contact command"); + LOG_INFO("Client got add_contact"); nodeDB->addFromContact(r->add_contact); break; } case meshtastic_AdminMessage_set_favorite_node_tag: { - LOG_INFO("Client received set_favorite_node command"); + LOG_INFO("Client got set_favorite_node"); meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->set_favorite_node); if (node != NULL) { if (nodeDB->setProtectedFlag(node, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true)) { @@ -534,7 +534,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_remove_favorite_node_tag: { - LOG_INFO("Client received remove_favorite_node command"); + LOG_INFO("Client got remove_favorite_node"); meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->remove_favorite_node); if (node != NULL) { nodeInfoLiteSetBit(node, NODEINFO_BITFIELD_IS_FAVORITE_MASK, false); @@ -545,7 +545,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_set_ignored_node_tag: { - LOG_INFO("Client received set_ignored_node command"); + LOG_INFO("Client got set_ignored_node"); // Unlike the sibling node-targeted admin commands, create the entry if // it's absent so the block sticks for a node we've not heard from yet // (e.g. one a remote admin asks us to block) with no NodeInfo or key. @@ -570,7 +570,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_remove_ignored_node_tag: { - LOG_INFO("Client received remove_ignored_node command"); + LOG_INFO("Client got remove_ignored_node"); meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->remove_ignored_node); if (node != NULL) { nodeInfoLiteSetBit(node, NODEINFO_BITFIELD_IS_IGNORED_MASK, false); @@ -579,7 +579,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_toggle_muted_node_tag: { - LOG_INFO("Client received toggle_muted_node command"); + LOG_INFO("Client got toggle_muted_node"); meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->toggle_muted_node); if (node != NULL) { nodeInfoLiteSetBit(node, NODEINFO_BITFIELD_IS_MUTED_MASK, !nodeInfoLiteIsMuted(node)); @@ -589,7 +589,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta } case meshtastic_AdminMessage_set_fixed_position_tag: { - LOG_INFO("Client received set_fixed_position command"); + LOG_INFO("Client got set_fixed_position"); const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum()); // Route the fixed position through updatePosition so it lands in the // satellite map (or, on builds with PositionDB excluded, just sets @@ -607,14 +607,14 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_remove_fixed_position_tag: { - LOG_INFO("Client received remove_fixed_position command"); + LOG_INFO("Client got remove_fixed_position"); nodeDB->clearLocalPosition(); config.position.fixed_position = false; saveChanges(SEGMENT_NODEDATABASE | SEGMENT_CONFIG, false); break; } case meshtastic_AdminMessage_set_time_only_tag: { - LOG_INFO("Client received set_time_only command"); + LOG_INFO("Client got set_time_only"); struct timeval tv; tv.tv_sec = r->set_time_only; tv.tv_usec = 0; @@ -623,7 +623,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_enter_dfu_mode_request_tag: { - LOG_INFO("Client requesting to enter DFU mode"); + LOG_INFO("Client requests DFU mode"); #if HAS_SCREEN IF_SCREEN(screen->showSimpleBanner("Device is rebooting\ninto DFU mode.", 0)); #endif @@ -633,21 +633,21 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_delete_file_request_tag: { - LOG_DEBUG("Client requesting to delete file: %s", r->delete_file_request); + LOG_DEBUG("Client requests delete file: %s", r->delete_file_request); #ifdef FSCom spiLock->lock(); if (FSCom.remove(r->delete_file_request)) { - LOG_DEBUG("Successfully deleted file"); + LOG_DEBUG("Deleted file"); } else { - LOG_DEBUG("Failed to delete file"); + LOG_DEBUG("File delete failed"); } spiLock->unlock(); #endif break; } case meshtastic_AdminMessage_backup_preferences_tag: { - LOG_INFO("Client requesting to backup preferences"); + LOG_INFO("Client requests preferences backup"); if (nodeDB->backupPreferences(r->backup_preferences)) { myReply = allocErrorResponse(meshtastic_Routing_Error_NONE, &mp); } else { @@ -656,11 +656,11 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_restore_preferences_tag: { - LOG_INFO("Client requesting to restore preferences"); + LOG_INFO("Client requests preferences restore"); if (nodeDB->restorePreferences(r->backup_preferences, SEGMENT_DEVICESTATE | SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_CHANNELS)) { myReply = allocErrorResponse(meshtastic_Routing_Error_NONE, &mp); - LOG_DEBUG("Rebooting after successful restore of preferences"); + LOG_DEBUG("Rebooting after preferences restore"); reboot(1000); disableBluetooth(); } else { @@ -669,7 +669,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_remove_backup_preferences_tag: { - LOG_INFO("Client requesting to remove backup preferences"); + LOG_INFO("Client requests preferences backup removal"); #ifdef FSCom if (r->remove_backup_preferences == meshtastic_AdminMessage_BackupLocation_FLASH) { spiLock->lock(); @@ -683,7 +683,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta break; } case meshtastic_AdminMessage_send_input_event_tag: { - LOG_INFO("Client requesting to send input event"); + LOG_INFO("Client requests send input event"); handleSendInputEvent(r->send_input_event); break; } @@ -721,10 +721,10 @@ void AdminModule::handleViaModuleApi(const meshtastic_MeshPacket &mp, meshtastic setPassKey(&res); myReply = allocDataProtobuf(res); } else if (mp.decoded.want_response) { - LOG_DEBUG("Module API did not respond to admin message. req.variant=%d", r->which_payload_variant); + LOG_DEBUG("Module API didn't respond to admin msg. req.variant=%d", r->which_payload_variant); } else if (handleResult != AdminMessageHandleResult::HANDLED) { // Probably a message sent by us or sent to our local node. FIXME, we should avoid scanning these messages - LOG_DEBUG("Module API did not handle admin message %d", r->which_payload_variant); + LOG_DEBUG("Module API didn't handle admin msg %d", r->which_payload_variant); } } @@ -912,7 +912,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) changes |= SEGMENT_NODEDATABASE | SEGMENT_DEVICESTATE; // Some role defaults affect owner } if (config.device.node_info_broadcast_secs < min_node_info_broadcast_secs) { - LOG_DEBUG("Tried to set node_info_broadcast_secs too low, setting to %d", min_node_info_broadcast_secs); + LOG_DEBUG("node_info_broadcast_secs too low, set to %d", min_node_info_broadcast_secs); config.device.node_info_broadcast_secs = min_node_info_broadcast_secs; } // Router Client and Repeater deprecated; Set it to client @@ -965,7 +965,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) config.power = c.payload_variant.power; if (c.payload_variant.power.on_battery_shutdown_after_secs > 0 && c.payload_variant.power.on_battery_shutdown_after_secs < 30) { - LOG_WARN("Tried to set on_battery_shutdown_after_secs too low, set to min 30 seconds"); + LOG_WARN("on_battery_shutdown_after_secs too low, set to min 30 sec"); config.power.on_battery_shutdown_after_secs = 30; } break; @@ -1007,12 +1007,12 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) config.has_lora = true; if (validatedLora.coding_rate != clampCodingRate(validatedLora.coding_rate)) { - LOG_WARN("Invalid coding_rate %d, setting to %d", validatedLora.coding_rate, LORA_CR_DEFAULT); + LOG_WARN("Invalid coding_rate %d, set to %d", validatedLora.coding_rate, LORA_CR_DEFAULT); validatedLora.coding_rate = LORA_CR_DEFAULT; } if (validatedLora.spread_factor != clampSpreadFactor(validatedLora.spread_factor)) { - LOG_WARN("Invalid spread_factor %d, setting to %d", validatedLora.spread_factor, LORA_SF_DEFAULT); + LOG_WARN("Invalid spread_factor %d, set to %d", validatedLora.spread_factor, LORA_SF_DEFAULT); validatedLora.spread_factor = LORA_SF_DEFAULT; } @@ -1023,7 +1023,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) // preset mode bandwidth 0 is expected (the preset supplies it), so leave it untouched. const uint16_t clampedBandwidth = clampBandwidthCode(validatedLora.bandwidth); if (!validatedLora.use_preset && validatedLora.bandwidth != clampedBandwidth) { - LOG_WARN("Invalid bandwidth %d, setting to %d", validatedLora.bandwidth, clampedBandwidth); + LOG_WARN("Invalid bandwidth %d, set to %d", validatedLora.bandwidth, clampedBandwidth); validatedLora.bandwidth = clampedBandwidth; } @@ -1085,13 +1085,13 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) validatedLora.region = swapRegion->code; } if (!swapRegion || !RadioInterface::validateConfigLora(validatedLora)) { - LOG_WARN("Invalid LoRa config received from another node, rejecting changes"); + LOG_WARN("Invalid LoRa config from another node, rejecting changes"); // Rejecting means rejecting everything: a partial restore of region/preset // could still apply other fields the validation already deemed invalid. validatedLora = oldLoraConfig; } } else { - LOG_WARN("Invalid LoRa config received from client, using corrected values"); + LOG_WARN("Invalid LoRa config from client, using corrected values"); RadioInterface::clampConfigLora(validatedLora); } // A preset locked to a sibling EU region swaps the region during the clamp; @@ -1138,7 +1138,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) loraFEMInterface.setLNAEnable(validatedLora.fem_lna_mode != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED); } else if (validatedLora.fem_lna_mode != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT) { // Hardware FEM does not support LNA control; normalize stored config to match actual capability - LOG_WARN("FEM LNA mode configured but current FEM does not support LNA control; normalizing to NOT_PRESENT"); + LOG_WARN("FEM LNA mode set but FEM lacks LNA control; normalizing to NOT_PRESENT"); validatedLora.fem_lna_mode = meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT; } #endif @@ -1173,7 +1173,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) // partial/legacy client, not an identity reset (that goes through factory_reset). Done outside the // PKI guard so non-PKI builds keep their key bytes too. if (incoming.private_key.size != 32 && config.security.private_key.size == 32) { - LOG_WARN("Security set omitted private key; preserving existing identity keypair"); + LOG_WARN("Security set omitted private key; keeping identity keypair"); incoming.private_key = config.security.private_key; incoming.public_key = config.security.public_key; } @@ -1181,7 +1181,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers) // recourse but a physical connection. Clearing admin keys still works via a SET that leaves the private // key alone and sends an empty list. if (isBareKeypairRotation(incoming, config.security)) { - LOG_INFO("Security set is a bare keypair rotation; preserving remaining security config"); + LOG_INFO("Security set is bare keypair rotation; keeping other security config"); meshtastic_Config_SecurityConfig rotated = config.security; rotated.public_key = incoming.public_key; // usually empty; derived from the private key below rotated.private_key = incoming.private_key; @@ -1249,7 +1249,7 @@ bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c) switch (c.which_payload_variant) { case meshtastic_ModuleConfig_mqtt_tag: #if MESHTASTIC_EXCLUDE_MQTT - LOG_WARN("Set module config: MESHTASTIC_EXCLUDE_MQTT is defined. Not setting MQTT config"); + LOG_WARN("Set module config: MESHTASTIC_EXCLUDE_MQTT defined, skip MQTT config"); return false; #else LOG_INFO("Set module config: MQTT"); @@ -1319,7 +1319,7 @@ bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c) moduleConfig.has_neighbor_info = true; moduleConfig.neighbor_info = c.payload_variant.neighbor_info; if (moduleConfig.neighbor_info.update_interval < min_neighbor_info_broadcast_secs) { - LOG_DEBUG("Tried to set update_interval too low, setting to %d", default_neighbor_info_broadcast_secs); + LOG_DEBUG("update_interval too low, set to %d", default_neighbor_info_broadcast_secs); moduleConfig.neighbor_info.update_interval = default_neighbor_info_broadcast_secs; } break; @@ -1902,7 +1902,7 @@ void AdminModule::saveChanges(int saveWhat, bool shouldReboot) LOG_INFO("Save changes to disk"); service->reloadConfig(saveWhat); // Calls saveToDisk among other things } else { - LOG_INFO("Delay save of changes to disk until the open transaction is committed"); + LOG_INFO("Delay disk save until open transaction commits"); editTransactionActivityMs = millis(); // still in use, so not the abandoned kind we time out deferredEditSegments |= saveWhat; } @@ -1929,7 +1929,7 @@ void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p) while (*start && isspace((unsigned char)*start)) start++; if (*start == '\0') { - LOG_WARN("Rejected ham %s: must contain at least 1 non-whitespace character", fieldNames[i]); + LOG_WARN("Rejected ham %s: needs 1+ non-whitespace char", fieldNames[i]); return; } } @@ -2116,7 +2116,7 @@ void AdminModule::noteOutgoingAdminRequest(const meshtastic_MeshPacket &p) memcpy(slot->key, destKey.bytes, 32); else memset(slot->key, 0, 32); - LOG_DEBUG("Admin request sent to 0x%08x, expecting its response", p.to); + LOG_DEBUG("Admin request sent to 0x%08x, expect response", p.to); } bool AdminModule::responseIsSolicited(const meshtastic_MeshPacket &mp, pb_size_t responseVariant, pb_size_t moduleConfigTag) @@ -2168,7 +2168,7 @@ bool AdminModule::messageIsRequest(const meshtastic_AdminMessage *r) void AdminModule::handleSendInputEvent(const meshtastic_AdminMessage_InputEvent &inputEvent) { - LOG_DEBUG("Processing input event: event_code=%u, kb_char=%u, touch_x=%u, touch_y=%u", inputEvent.event_code, + LOG_TRACE("Processing input event: event_code=%u, kb_char=%u, touch_x=%u, touch_y=%u", inputEvent.event_code, inputEvent.kb_char, inputEvent.touch_x, inputEvent.touch_y); // Create InputEvent for injection. @@ -2195,7 +2195,7 @@ void AdminModule::handleSendInputEvent(const meshtastic_AdminMessage_InputEvent if (inputBroker) { inputBroker->injectInputEvent(&event); } else { - LOG_ERROR("InputBroker not available for event injection"); + LOG_ERROR("No InputBroker for event injection"); } #endif } diff --git a/src/modules/CannedMessageModule.cpp b/src/modules/CannedMessageModule.cpp index 00aa786b2c..0013012751 100644 --- a/src/modules/CannedMessageModule.cpp +++ b/src/modules/CannedMessageModule.cpp @@ -71,7 +71,7 @@ CannedMessageModule::CannedMessageModule() { this->loadProtoForModule(); if ((this->splitConfiguredMessages() <= 0) && (cardkb_found.address == 0x00) && !INPUTBROKER_MATRIX_TYPE) { - LOG_INFO("CannedMessageModule: No messages are configured. Module is disabled"); + LOG_INFO("CannedMessage: none configured, disabled"); this->updateState(CANNED_MESSAGE_RUN_STATE_DISABLED); disable(); } else { @@ -112,7 +112,7 @@ void CannedMessageModule::LaunchWithDestination(NodeNum newDest, uint8_t newChan e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; notifyObservers(&e); - LOG_DEBUG("[CannedMessage] LaunchWithDestination dest=0x%08x ch=%d", dest, channel); + LOG_TRACE("[CannedMessage] LaunchWithDestination dest=0x%08x ch=%d", dest, channel); } void CannedMessageModule::LaunchFreetextWithDestination(NodeNum newDest, uint8_t newChannel) @@ -135,7 +135,7 @@ void CannedMessageModule::LaunchFreetextWithDestination(NodeNum newDest, uint8_t e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; notifyObservers(&e); - LOG_DEBUG("[CannedMessage] LaunchFreetextWithDestination dest=0x%08x ch=%d", dest, channel); + LOG_TRACE("[CannedMessage] LaunchFreetextWithDestination dest=0x%08x ch=%d", dest, channel); } static bool returnToCannedList = false; @@ -294,7 +294,7 @@ void CannedMessageModule::updateDestinationSelectionList() scrollIndex = 0; // Show first result at the top destIndex = 0; // Highlight the first entry if (nodesChanged && runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) { - LOG_INFO("Nodes changed, forcing UI refresh."); + LOG_INFO("Nodes changed, forcing UI refresh"); screen->forceDisplay(); } } @@ -891,8 +891,8 @@ bool CannedMessageModule::handleFreeTextInput(const InputEvent *event) // Confirm select (Enter) bool isSelect = isSelectEvent(event); if (isSelect) { - LOG_DEBUG("[SELECT] handleFreeTextInput: runState=%d, dest=%u, channel=%d, freetext='%s'", (int)runState, dest, channel, - freetext.c_str()); + LOG_TRACE("[SELECT] handleFreeTextInput: runState=%d, dest=0x%08x, channel=%d, freetext='%s'", (int)runState, dest, + channel, freetext.c_str()); if (dest == 0) dest = NODENUM_BROADCAST; // Defensive: If channel isn't valid, pick the first available channel @@ -1108,10 +1108,10 @@ void CannedMessageModule::sendText(NodeNum dest, ChannelIndex channel, const cha if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER && config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE && config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) { - LOG_INFO("Proactively adding %x as favorite node", dest); + LOG_INFO("Proactively adding 0x%08x as favorite node", dest); nodeDB->set_favorite(true, dest); } else { - LOG_DEBUG("Not favoriting node %x because role is router-like", dest); + LOG_DEBUG("Not favoriting node 0x%08x: router-like role", dest); } } sm.ackStatus = AckStatus::NONE; @@ -1163,12 +1163,12 @@ int32_t CannedMessageModule::runOnce() if (this->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE && this->payload == CANNED_MESSAGE_RUN_STATE_FREETEXT) { // Virtual keyboard message sending case - text was not empty if (this->freetext.length() > 0) { - LOG_INFO("Processing delayed virtual keyboard send: '%s'", this->freetext.c_str()); + LOG_INFO("Delayed vkbd send: '%s'", this->freetext.c_str()); sendText(this->dest, this->channel, this->freetext.c_str(), true); // Clean up virtual keyboard after sending if (graphics::NotificationRenderer::virtualKeyboard) { - LOG_INFO("Cleaning up virtual keyboard after message send"); + LOG_INFO("Vkbd cleanup after send"); graphics::OnScreenKeyboardModule::instance().stop(false); graphics::NotificationRenderer::resetBanner(); } @@ -1178,7 +1178,7 @@ int32_t CannedMessageModule::runOnce() this->payload = 0; } else { // Empty message, just go inactive - LOG_INFO("Empty freetext detected in delayed processing, returning to inactive state"); + LOG_INFO("Empty freetext, back to inactive"); this->updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE); } @@ -1221,7 +1221,7 @@ int32_t CannedMessageModule::runOnce() // Clean up virtual keyboard if it exists during timeout if (graphics::NotificationRenderer::virtualKeyboard) { - LOG_INFO("Cleaning up virtual keyboard due to module timeout"); + LOG_INFO("Vkbd cleanup on timeout"); graphics::OnScreenKeyboardModule::instance().stop(false); graphics::NotificationRenderer::resetBanner(); } @@ -1230,7 +1230,7 @@ int32_t CannedMessageModule::runOnce() } else if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_SELECT) { if (this->payload == 0) { // [Exit] button pressed - return to inactive state - LOG_INFO("Processing [Exit] action - returning to inactive state"); + LOG_INFO("Exit action, back to inactive"); this->updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE); } else if (this->payload == CANNED_MESSAGE_RUN_STATE_FREETEXT) { if (this->freetext.length() > 0) { @@ -2336,7 +2336,6 @@ AdminMessageHandleResult CannedMessageModule::handleAdminMessageForModule(const void CannedMessageModule::handleGetCannedMessageModuleMessages(const meshtastic_MeshPacket &req, meshtastic_AdminMessage *response) { - LOG_DEBUG("*** handleGetCannedMessageModuleMessages"); if (req.decoded.want_response) { response->which_payload_variant = meshtastic_AdminMessage_get_canned_message_module_messages_response_tag; strncpy(response->get_canned_message_module_messages_response, cannedMessageModuleConfig.messages, @@ -2351,7 +2350,7 @@ void CannedMessageModule::handleSetCannedMessageModuleMessages(const char *from_ if (*from_msg) { changed |= strcmp(cannedMessageModuleConfig.messages, from_msg); strncpy(cannedMessageModuleConfig.messages, from_msg, sizeof(cannedMessageModuleConfig.messages)); - LOG_DEBUG("*** from_msg.text:%s", from_msg); + LOG_TRACE("*** from_msg.text:%s", from_msg); } if (changed) { diff --git a/src/modules/DropzoneModule.cpp b/src/modules/DropzoneModule.cpp index 16bd838496..100b87662c 100644 --- a/src/modules/DropzoneModule.cpp +++ b/src/modules/DropzoneModule.cpp @@ -12,6 +12,7 @@ #include "modules/Telemetry/Sensor/DFRobotLarkSensor.h" #include "modules/Telemetry/UnitConversions.h" +#include "mesh/Throttle.h" #include DropzoneModule *dropzoneModule; @@ -19,7 +20,7 @@ DropzoneModule *dropzoneModule; int32_t DropzoneModule::runOnce() { // Send on a 5 second delay from receiving the matching request - if (startSendConditions != 0 && (startSendConditions + 5000U) < millis()) { + if (startSendConditions != 0 && Throttle::hasElapsed(startSendConditions, 5000U)) { service->sendToMesh(sendConditions(), RX_SRC_LOCAL); startSendConditions = 0; } diff --git a/src/modules/ExternalNotificationModule.cpp b/src/modules/ExternalNotificationModule.cpp index 98feda782c..420697689f 100644 --- a/src/modules/ExternalNotificationModule.cpp +++ b/src/modules/ExternalNotificationModule.cpp @@ -21,6 +21,7 @@ #include "configuration.h" #include "gps/RTC.h" #include "main.h" +#include "mesh/Throttle.h" #include "mesh/generated/meshtastic/rtttl.pb.h" #include @@ -85,7 +86,10 @@ int32_t ExternalNotificationModule::runOnce() #if defined(HAS_I2S_SPEAKER_NRF52) isRtttlPlaying = isRtttlPlaying || nrf52RtttlPlayer.isPlaying(); #endif - if ((nagCycleCutoff < millis()) && !isRtttlPlaying) { + // isNagging is the armed flag; nagCycleCutoff holds a real deadline only while it is set + // (UINT32_MAX once stopped, 1 at boot), so short-circuit before the comparison. + const bool nagWindowExpired = !isNagging || Throttle::deadlinePassed(nagCycleCutoff); + if (nagWindowExpired && !isRtttlPlaying) { // Turn off external notification immediately when timeout is reached, regardless of song state nagCycleCutoff = UINT32_MAX; ExternalNotificationModule::stopNow(); @@ -97,14 +101,15 @@ int32_t ExternalNotificationModule::runOnce() if (isNagging) { delay = (moduleConfig.external_notification.output_ms ? moduleConfig.external_notification.output_ms : EXT_NOTIFICATION_MODULE_OUTPUT_MS); - if (externalTurnedOn[0] + delay < millis()) { + // externalTurnedOn[] is when each output was last toggled, so these are intervals. + if (Throttle::hasElapsed(externalTurnedOn[0], delay)) { setExternalState(0, !getExternal(0)); } - if (externalTurnedOn[1] + delay < millis()) { + if (Throttle::hasElapsed(externalTurnedOn[1], delay)) { setExternalState(1, !getExternal(1)); } // Only toggle buzzer output if not using PWM mode (to avoid conflict with RTTTL) - if (!moduleConfig.external_notification.use_pwm && externalTurnedOn[2] + delay < millis()) { + if (!moduleConfig.external_notification.use_pwm && Throttle::hasElapsed(externalTurnedOn[2], delay)) { LOG_DEBUG("EXTERNAL 2 %d compared to %d", externalTurnedOn[2] + moduleConfig.external_notification.output_ms, millis()); setExternalState(2, !getExternal(2)); @@ -146,7 +151,7 @@ int32_t ExternalNotificationModule::runOnce() if (moduleConfig.external_notification.use_i2s_as_buzzer) { if (audioThread->isPlaying()) { // Continue playing - } else if (isNagging && (nagCycleCutoff >= millis())) { + } else if (isNagging && !Throttle::deadlinePassed(nagCycleCutoff)) { audioThread->beginRttl(rtttlConfig.ringtone, strlen_P(rtttlConfig.ringtone)); } // we need fast updates to play the RTTTL @@ -158,7 +163,7 @@ int32_t ExternalNotificationModule::runOnce() if (canBuzz() && buzzerShouldAlert) { if (nrf52RtttlPlayer.isPlaying()) { nrf52RtttlPlayer.play(); - } else if (isNagging && (nagCycleCutoff >= millis())) { + } else if (isNagging && !Throttle::deadlinePassed(nagCycleCutoff)) { nrf52RtttlPlayer.begin(rtttlConfig.ringtone); } delay = EXT_NOTIFICATION_FAST_THREAD_MS; @@ -168,7 +173,7 @@ int32_t ExternalNotificationModule::runOnce() if (moduleConfig.external_notification.use_pwm && config.device.buzzer_gpio && canBuzz() && buzzerShouldAlert) { if (rtttl::isPlaying()) { rtttl::play(); - } else if (isNagging && (nagCycleCutoff >= millis())) { + } else if (isNagging && !Throttle::deadlinePassed(nagCycleCutoff)) { // start the song again if we have time left rtttl::begin(config.device.buzzer_gpio, rtttlConfig.ringtone); } @@ -476,7 +481,7 @@ ProcessMessage ExternalNotificationModule::handleReceived(const meshtastic_MeshP if (buzzerShouldAlert) { LOG_INFO("externalNotificationModule - Buzzer alert"); if (buzzerModeIsDirectOnly && !isDmToUs && !containsBell) { - LOG_INFO("Message buzzer was suppressed because buzzer mode DIRECT_MSG_ONLY"); + LOG_INFO("Buzzer suppressed: mode DIRECT_MSG_ONLY"); } else { // Buzz if buzzer mode is not in DIRECT_MSG_ONLY or is DM to us if (moduleConfig.external_notification.use_i2s_as_buzzer) { diff --git a/src/modules/HopScalingModule.cpp b/src/modules/HopScalingModule.cpp index 1045e4f021..758715f971 100644 --- a/src/modules/HopScalingModule.cpp +++ b/src/modules/HopScalingModule.cpp @@ -182,7 +182,7 @@ void HopScalingModule::samplePacketForHistogram(uint32_t nodeId, uint8_t hopCoun this->count++; } else { LOG_WARN("[HOPSCALE] Histogram full at samp=1/%u (DENOM_MAX=%u); dropping node hash=0x%04x; hop recommendation may be " - "skewed!!!", + "skewed!!", samplingDenominator, DENOM_MAX, hash); } } diff --git a/src/modules/KeyVerificationModule.cpp b/src/modules/KeyVerificationModule.cpp index f0a1dc8fb0..eb6c496413 100644 --- a/src/modules/KeyVerificationModule.cpp +++ b/src/modules/KeyVerificationModule.cpp @@ -116,7 +116,7 @@ bool KeyVerificationModule::handleReceivedProtobuf(const meshtastic_MeshPacket & memset(message, 0, sizeof(message)); sprintf(message, "Verification: \n"); generateVerificationCode(message + 15); - LOG_INFO("Hash1 matches!"); + LOG_INFO("Hash1 matches"); static const char *optionsArray[] = {"Reject", "Accept"}; // Don't try to put the array definition in the macro. Does not work with curly braces. IF_SCREEN(graphics::BannerOverlayOptions options; options.message = message; options.durationMs = 30000; diff --git a/src/modules/MeshBeaconModule.cpp b/src/modules/MeshBeaconModule.cpp index cc5c6e807b..a747621838 100644 --- a/src/modules/MeshBeaconModule.cpp +++ b/src/modules/MeshBeaconModule.cpp @@ -198,7 +198,7 @@ bool MeshBeaconModule::reconfigureForBeaconTX(RadioInterface *iface, meshtastic_ // transmit on it; the radio driver drops the packet outright (see RadioLibInterface, // beaconTxConfigInvalid) rather than letting it fall through onto the current config. if (beaconTxConfigInvalid(p)) { - LOG_DEBUG("Beacon: target preset %d/region %d invalid (or ham mismatch), not switching", targetPreset, targetRegion); + LOG_DEBUG("Beacon: target preset %d/region %d invalid (or ham mismatch), skip", targetPreset, targetRegion); return false; } @@ -228,7 +228,7 @@ bool MeshBeaconModule::reconfigureForBeaconTX(RadioInterface *iface, meshtastic_ } else if ((!p || !getTargetRadioSettings(p, nullptr, nullptr)) && radioSwitched) { - LOG_INFO("Beacon: restoring radio config after beacon TX"); + LOG_INFO("Beacon: restore radio config after TX"); config.lora.modem_preset = originalModemPreset; config.lora.channel_num = originalLoraChannel; config.lora.region = originalRegion; @@ -315,7 +315,7 @@ void MeshBeaconBroadcastModule::sendBeacon() (bcfg.broadcast_offer_region != meshtastic_Config_LoRaConfig_RegionCode_UNSET); if (!hasText && !hasRadioContent) { - LOG_DEBUG("Beacon: nothing to send (empty message, no offer), skipping"); + LOG_DEBUG("Beacon: empty msg, no offer, skip"); return; } @@ -375,7 +375,7 @@ void MeshBeaconBroadcastModule::sendBeacon() offerOnly.offer_region = bcfg.broadcast_offer_region; offerSize = (pb_size_t)pb_encode_to_bytes(offerBuf, sizeof(offerBuf), &meshtastic_MeshBeacon_msg, &offerOnly); if (offerSize == 0) - LOG_WARN("Beacon: offer encode failed, skipping offer packet(s)"); + LOG_WARN("Beacon: offer encode failed, skip"); } if (sendCombined && payloadCacheDirty) rebuildCache(); @@ -429,8 +429,7 @@ void MeshBeaconBroadcastModule::sendBeacon() tgt.slot = config.lora.channel_num; if (bt.has_channel_index) { if (bt.channel_index >= (uint32_t)channels.getNumChannels()) { - LOG_WARN("Beacon: target %d channel_index %u out of range, using default channel for preset", ti, - bt.channel_index); + LOG_WARN("Beacon: target %d channel_index %u out of range, use preset default", ti, bt.channel_index); } else { const meshtastic_ChannelSettings &cs = channels.getByIndex(bt.channel_index).settings; if (cs.name[0] != '\0' || cs.psk.size > 0) { @@ -438,8 +437,7 @@ void MeshBeaconBroadcastModule::sendBeacon() tgt.channel = cs; tgt.slot = cs.channel_num; } else { - LOG_DEBUG("Beacon: target %d channel_index %u is a blank slot, using default channel for preset", ti, - bt.channel_index); + LOG_DEBUG("Beacon: target %d channel_index %u blank, use preset default", ti, bt.channel_index); } } } @@ -463,7 +461,7 @@ void MeshBeaconBroadcastModule::sendBeacon() } } if (duplicate) { - LOG_DEBUG("Beacon: target %d duplicates an earlier target's radio config, skipping", ti); + LOG_DEBUG("Beacon: target %d dup radio config, skip", ti); continue; } sent[sentCount] = tgt; @@ -487,7 +485,7 @@ void MeshBeaconBroadcastModule::sendBeacon() if (sendOfferOnly && offerSize > 0) { meshtastic_MeshPacket *pA = allocDataPacket(); if (!pA) { - LOG_WARN("Beacon: failed to allocate split-A packet (target %d)", ti); + LOG_WARN("Beacon: split-A alloc failed (target %d)", ti); return; } memcpy(pA->decoded.payload.bytes, offerBuf, offerSize); @@ -501,7 +499,7 @@ void MeshBeaconBroadcastModule::sendBeacon() if (sendTextOnly) { meshtastic_MeshPacket *pB = allocDataPacket(); if (!pB) { - LOG_WARN("Beacon: failed to allocate split-B packet (target %d)", ti); + LOG_WARN("Beacon: split-B alloc failed (target %d)", ti); return; } pb_size_t msgLen = (pb_size_t)strnlen(bcfg.broadcast_message, sizeof(bcfg.broadcast_message) - 1); diff --git a/src/modules/NeighborInfoModule.cpp b/src/modules/NeighborInfoModule.cpp index f42194a81f..a05b09b0fa 100644 --- a/src/modules/NeighborInfoModule.cpp +++ b/src/modules/NeighborInfoModule.cpp @@ -14,11 +14,11 @@ NOTE: For debugging only */ void NeighborInfoModule::printNeighborInfo(const char *header, const meshtastic_NeighborInfo *np) { - LOG_DEBUG("%s NEIGHBORINFO PACKET from Node 0x%08x to Node 0x%08x (last sent by 0x%08x)", header, np->node_id, + LOG_TRACE("%s NEIGHBORINFO PACKET from Node 0x%08x to Node 0x%08x (last sent by 0x%08x)", header, np->node_id, nodeDB->getNodeNum(), np->last_sent_by_id); - LOG_DEBUG("Packet contains %d neighbors", np->neighbors_count); + LOG_TRACE("Packet contains %d neighbors", np->neighbors_count); for (int i = 0; i < np->neighbors_count; i++) { - LOG_DEBUG("Neighbor %d: node_id=0x%08x, snr=%.2f", i, np->neighbors[i].node_id, np->neighbors[i].snr); + LOG_TRACE("Neighbor %d: node_id=0x%08x, snr=%.2f", i, np->neighbors[i].node_id, np->neighbors[i].snr); } } @@ -28,9 +28,9 @@ NOTE: for debugging only */ void NeighborInfoModule::printNodeDBNeighbors() { - LOG_DEBUG("Our NodeDB contains %d neighbors", neighbors.size()); + LOG_TRACE("Our NodeDB contains %u neighbors", (unsigned)neighbors.size()); for (size_t i = 0; i < neighbors.size(); i++) { - LOG_DEBUG("Node %d: node_id=0x%08x, snr=%.2f", i, neighbors[i].node_id, neighbors[i].snr); + LOG_TRACE("Node %u: node_id=0x%08x, snr=%.2f", (unsigned)i, neighbors[i].node_id, neighbors[i].snr); } } @@ -138,7 +138,7 @@ int32_t NeighborInfoModule::runOnce() meshtastic_MeshPacket *NeighborInfoModule::allocReply() { - LOG_INFO("NeighborInfoRequested."); + LOG_INFO("NeighborInfoRequested"); if (lastSentReply && Throttle::isWithinTimespanMs(lastSentReply, 3 * 60 * 1000)) { LOG_DEBUG("Skip Neighbors reply since we sent a reply <3min ago"); ignoreRequest = true; // Mark it as ignored for MeshModule @@ -162,18 +162,18 @@ Pass it to an upper client; do not persist this data on the mesh */ bool NeighborInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np) { - LOG_DEBUG("NeighborInfo: handleReceivedProtobuf"); + LOG_TRACE("NeighborInfo: handleReceivedProtobuf"); if (np) { printNeighborInfo("RECEIVED", np); // Ignore dummy/interceptable packets: single neighbor with nodeId 0 and snr 0 if (np->neighbors_count != 1 || np->neighbors[0].node_id != 0 || np->neighbors[0].snr != 0.0f) { - LOG_DEBUG(" Updating neighbours"); + LOG_TRACE(" Updating neighbours"); updateNeighbors(mp, np); } else { LOG_DEBUG(" Ignoring dummy neighbor info packet (single neighbor with nodeId 0, snr 0)"); } } else if (getHopsAway(mp) == 0) { - LOG_DEBUG("Get or create neighbor: %u with snr %f", mp.from, mp.rx_snr); + LOG_TRACE("Get or create neighbor: 0x%08x with snr %f", mp.from, mp.rx_snr); // If the hopLimit is the same as hopStart, then it is a neighbor getOrCreateNeighbor(mp.from, mp.from, 0, mp.rx_snr); // Set the broadcast interval to 0, as we don't know it @@ -202,7 +202,6 @@ void NeighborInfoModule::resetNeighbors() void NeighborInfoModule::updateNeighbors(const meshtastic_MeshPacket &mp, const meshtastic_NeighborInfo *np) { - LOG_DEBUG("updateNeighbors"); // The last sent ID will be 0 if the packet is from the phone, which we don't // count as an edge. So we assume that if it's zero, then this packet is from // our node. diff --git a/src/modules/NodeInfoModule.cpp b/src/modules/NodeInfoModule.cpp index 226dfda271..7c4096959c 100644 --- a/src/modules/NodeInfoModule.cpp +++ b/src/modules/NodeInfoModule.cpp @@ -34,22 +34,19 @@ bool NodeInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes // Suppress replies to senders we've replied to recently (12H window) if (mp.decoded.want_response && !isFromUs(&mp)) { const NodeNum sender = getFrom(&mp); - // A local dedup window, not a wall-clock reading - uptime avoids RTC-quality jumps and - // replayed packets' stale rx_time perturbing it. - const uint32_t now = (uint32_t)(Time::getMillis64() / 1000); + // A local dedup window, not a wall-clock reading - uptime avoids RTC jumps and replayed + // packets' stale rx_time perturbing it. Seconds, not millis - this is a wide window. + const uint32_t nowSecs = Time::getUptimeSecs(); auto it = lastNodeInfoSeen.find(sender); - if (it != lastNodeInfoSeen.end()) { - uint32_t sinceLast = now >= it->second ? now - it->second : 0; - if (sinceLast < NodeInfoReplySuppressSeconds) { - suppressReplyForCurrentRequest = true; - } + if (it != lastNodeInfoSeen.end() && (uint32_t)(nowSecs - it->second) < NodeInfoReplySuppressSeconds) { + suppressReplyForCurrentRequest = true; } - lastNodeInfoSeen[sender] = now; + lastNodeInfoSeen[sender] = nowSecs; pruneLastNodeInfoCache(); } if (p.is_licensed != owner.is_licensed) { - LOG_WARN("Invalid nodeInfo detected, is_licensed mismatch!"); + LOG_WARN("Invalid nodeInfo detected, is_licensed mismatch"); return true; } NodeNum sourceNum = getFrom(&mp); @@ -193,19 +190,26 @@ void NodeInfoModule::pruneLastNodeInfoCache() return; const size_t maxEntries = nodeDB->meshNodes->size(); + const uint32_t nowSecs = Time::getUptimeSecs(); + // Drop entries for nodes we no longer know, and any stamp already past the suppression window: + // it can only decide "don't suppress", so keeping it buys nothing. for (auto it = lastNodeInfoSeen.begin(); it != lastNodeInfoSeen.end();) { - if (!nodeDB->getMeshNode(it->first)) { + if (!nodeDB->getMeshNode(it->first) || (uint32_t)(nowSecs - it->second) >= NodeInfoReplySuppressSeconds) { it = lastNodeInfoSeen.erase(it); } else { ++it; } } + // Evict by largest elapsed time rather than smallest stamp, so the victim is still the oldest + // entry if the uptime counter ever wraps underneath us. while (!lastNodeInfoSeen.empty() && lastNodeInfoSeen.size() > maxEntries) { - auto oldestIt = std::min_element(lastNodeInfoSeen.begin(), lastNodeInfoSeen.end(), - [](const std::pair &lhs, - const std::pair &rhs) { return lhs.second < rhs.second; }); + auto oldestIt = std::max_element( + lastNodeInfoSeen.begin(), lastNodeInfoSeen.end(), + [nowSecs](const std::pair &lhs, const std::pair &rhs) { + return (uint32_t)(nowSecs - lhs.second) < (uint32_t)(nowSecs - rhs.second); + }); lastNodeInfoSeen.erase(oldestIt); } } diff --git a/src/modules/NodeInfoModule.h b/src/modules/NodeInfoModule.h index 9b3b66caed..8653c71ebc 100644 --- a/src/modules/NodeInfoModule.h +++ b/src/modules/NodeInfoModule.h @@ -50,6 +50,8 @@ class NodeInfoModule : public ProtobufModule, private concurren private: bool shorterTimeout = false; bool suppressReplyForCurrentRequest = false; + /// Sender -> uptime seconds (Time::getUptimeSecs()) at our last reply. Seconds, not millis: + /// the suppression window is hours wide. See handleReceivedProtobuf(). std::map lastNodeInfoSeen; void pruneLastNodeInfoCache(); diff --git a/src/modules/PositionModule.cpp b/src/modules/PositionModule.cpp index 9497861fcc..9ee985b156 100644 --- a/src/modules/PositionModule.cpp +++ b/src/modules/PositionModule.cpp @@ -10,6 +10,7 @@ #include "TypeConversions.h" #include "airtime.h" #include "configuration.h" +#include "gps/GPSLog.h" #include "gps/GeoCoord.h" #include "gps/RTC.h" #include "main.h" @@ -68,7 +69,7 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes if (isFromUs(&mp)) { isLocal = true; if (config.position.fixed_position) { - LOG_DEBUG("Ignore incoming position update from myself except for time, because position.fixed_position is true"); + LOG_DEBUG("Ignore own position update except time: position.fixed_position true"); #ifdef T_WATCH_S3 // Since we return early if position.fixed_position is true, set the T-Watch's RTC to the time received from the @@ -81,13 +82,13 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes nodeDB->setLocalPosition(p, true); return false; } else { - LOG_DEBUG("Incoming update from MYSELF"); + LOG_TRACE("Incoming update from MYSELF"); nodeDB->setLocalPosition(p); } } // Log packet size and data fields - LOG_DEBUG("POSITION node=0x%08x l=%d lat=%d lon=%d msl=%d hae=%d geo=%d pdop=%d hdop=%d vdop=%d siv=%d fxq=%d fxt=%d pts=%d " + LOG_TRACE("POSITION node=0x%08x l=%d lat=%d lon=%d msl=%d hae=%d geo=%d pdop=%d hdop=%d vdop=%d siv=%d fxq=%d fxt=%d pts=%d " "time=%d", getFrom(&mp), mp.decoded.payload.size, p.latitude_i, p.longitude_i, p.altitude, p.altitude_hae, p.altitude_geoidal_separation, p.PDOP, p.HDOP, p.VDOP, p.sats_in_view, p.fix_quality, p.fix_type, p.timestamp, @@ -117,7 +118,7 @@ void PositionModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic // Phone position packets need to be truncated to the channel precision if (isFromUs(&mp)) { if (precision == 0) - LOG_DEBUG("Strip phone position due to channel precision 0"); + LOG_DEBUG("Strip phone position: channel precision 0"); else if (precision < 32) LOG_DEBUG("Truncate phone position to channel precision %i", precision); applyPositionPrecision(*p, precision); @@ -129,11 +130,11 @@ void PositionModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic void PositionModule::trySetRtc(meshtastic_Position p, bool isLocal, bool forceUpdate) { if (hasQualityTimesource() && !isLocal) { - LOG_DEBUG("Ignore time from mesh because we have a GPS, RTC, or Phone/NTP time source in the past day"); + LOG_DEBUG("Ignore time from mesh: GPS/RTC/Phone/NTP time source in past day"); return; } if (!isLocal && p.location_source < meshtastic_Position_LocSource_LOC_INTERNAL) { - LOG_DEBUG("Ignore time from mesh because it has a unknown or manual source"); + LOG_DEBUG("Ignore time from mesh: unknown or manual source"); return; } struct timeval tv; @@ -170,7 +171,7 @@ bool PositionModule::hasGPS() meshtastic_MeshPacket *PositionModule::allocPositionPacket(uint32_t atPrecision) { if (atPrecision == 0) { - LOG_DEBUG("Skip location send because precision is set to 0!"); + LOG_DEBUG("Skip location send: precision 0"); return nullptr; } @@ -191,7 +192,7 @@ meshtastic_MeshPacket *PositionModule::allocPositionPacket(uint32_t atPrecision) localPosition.seq_number++; if (localPosition.latitude_i == 0 && localPosition.longitude_i == 0) { - LOG_WARN("Skip position send because lat/lon are zero!"); + LOG_WARN("Skip position send: lat/lon zero"); return nullptr; } @@ -276,7 +277,7 @@ meshtastic_MeshPacket *PositionModule::allocReply() { if (config.device.role != meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND && lastSentReply && Throttle::isWithinTimespanMs(lastSentReply, 3 * 60 * 1000)) { - LOG_DEBUG("Skip Position reply since we sent a reply <3min ago"); + LOG_DEBUG("Skip Position reply: sent one <3min ago"); ignoreRequest = true; // Mark it as ignored for MeshModule return nullptr; } @@ -349,7 +350,7 @@ meshtastic_MeshPacket *PositionModule::allocAtakPli() size_t proto_size = pb_encode_to_bytes(protobuf_bytes, sizeof(protobuf_bytes), &meshtastic_TAKPacketV2_msg, &takPacket); if (proto_size == 0) { - LOG_ERROR("Failed to encode TAK V2 PLI packet"); + LOG_ERROR("TAK V2 PLI packet encode failed"); packetPool.release(mp); return nullptr; } @@ -363,7 +364,7 @@ meshtastic_MeshPacket *PositionModule::allocAtakPli() memcpy(mp->decoded.payload.bytes + 1, protobuf_bytes, proto_size); mp->decoded.payload.size = proto_size + 1; - LOG_DEBUG("TAK V2 PLI payload: %zu bytes (1 flags + %zu protobuf)", mp->decoded.payload.size, proto_size); + LOG_TRACE("TAK V2 PLI payload: %zu bytes (1 flags + %zu protobuf)", mp->decoded.payload.size, proto_size); return mp; } @@ -380,7 +381,7 @@ void PositionModule::sendOurPosition() return; } } - LOG_INFO("Skip pos@%x:6 broadcast; position sharing is opt-in and disabled on all channels", localPosition.timestamp); + LOG_INFO("Skip pos@%x:6 broadcast; position sharing disabled on all channels", localPosition.timestamp); } // Position broadcasts are opt-in per channel in 2.8, but our own position still plays to the @@ -506,7 +507,7 @@ int32_t PositionModule::runOnce() if (sleepOnNextExecution == true) { sleepOnNextExecution = false; uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs); - LOG_DEBUG("Sleep for %ims, then awaking to send position again", nightyNightMs); + LOG_DEBUG("Sleep %ims, then wake to send position", nightyNightMs); doDeepSleep(nightyNightMs, false, false); } @@ -557,9 +558,7 @@ int32_t PositionModule::runOnce() if (lastGpsSend == 0 || msSinceLastSend >= effectiveIntervalMs) { if (waitingForFreshPosition) { -#ifdef GPS_DEBUG - LOG_DEBUG("Skip initial position send; no fresh position since boot"); -#endif + LOG_DEBUG_GPS("Skip initial position send; no fresh position since boot"); } else if (nodeDB->hasValidPosition(node)) { lastGpsSend = now; @@ -591,11 +590,7 @@ int32_t PositionModule::runOnce() if (smartPosition.hasTraveledOverThreshold && Throttle::execute( &lastGpsSend, minimumTimeThreshold, []() { positionModule->sendOurPosition(); }, - []() { -#ifdef GPS_DEBUG - LOG_DEBUG("Skip send smart broadcast due to time throttling"); -#endif - })) { + []() { LOG_DEBUG_GPS("Skip smart broadcast: time throttled"); })) { LOG_DEBUG("Sent smart pos@%x:6 to mesh (distanceTraveled=%fm, minDistanceThreshold=%im, timeElapsed=%ims, " "minTimeInterval=%ims)", @@ -701,11 +696,7 @@ void PositionModule::handleNewPosition() if (smartPosition.hasTraveledOverThreshold && Throttle::execute( &lastGpsSend, minimumTimeThreshold, []() { positionModule->sendOurPosition(); }, - []() { -#ifdef GPS_DEBUG - LOG_DEBUG("Skip send smart broadcast due to time throttling"); -#endif - })) { + []() { LOG_DEBUG_GPS("Skip smart broadcast: time throttled"); })) { LOG_DEBUG("Sent smart pos@%x:6 to mesh (distanceTraveled=%fm, minDistanceThreshold=%im, timeElapsed=%ims, " "minTimeInterval=%ims)", localPosition.timestamp, smartPosition.distanceTraveled, smartPosition.distanceThreshold, msSinceLastSend, diff --git a/src/modules/PowerStressModule.cpp b/src/modules/PowerStressModule.cpp index b818e88950..aca32cd694 100644 --- a/src/modules/PowerStressModule.cpp +++ b/src/modules/PowerStressModule.cpp @@ -125,7 +125,7 @@ int32_t PowerStressModule::runOnce() // FIXME - implement break; default: - LOG_ERROR("PowerStress operation %d not yet implemented!", p.cmd); + LOG_ERROR("PowerStress operation %d not yet implemented", p.cmd); sleep_msec = 0; // Don't do whatever sleep was requested... break; } diff --git a/src/modules/RangeTestModule.cpp b/src/modules/RangeTestModule.cpp index 2ca5891317..46475a3ae2 100644 --- a/src/modules/RangeTestModule.cpp +++ b/src/modules/RangeTestModule.cpp @@ -57,7 +57,7 @@ int32_t RangeTestModule::runOnce() if (moduleConfig.range_test.clear_on_reboot) { // User wants to delete previous range test(s) - LOG_INFO("Range Test Module - Clearing out previous test file"); + LOG_INFO("Range Test Module - Clear previous test file"); rangeTestModuleRadio->removeFile(); } if (moduleConfig.range_test.sender) { @@ -73,7 +73,7 @@ int32_t RangeTestModule::runOnce() if (moduleConfig.range_test.sender) { // If sender - LOG_INFO("Range Test Module - Sending heartbeat every %d ms", (senderHeartbeat)); + LOG_INFO("Range Test Module - Heartbeat every %d ms", (senderHeartbeat)); LOG_INFO("gpsStatus->getLatitude() %d", gpsStatus->getLatitude()); LOG_INFO("gpsStatus->getLongitude() %d", gpsStatus->getLongitude()); @@ -99,7 +99,7 @@ int32_t RangeTestModule::runOnce() } } } else { - LOG_INFO("Range Test Module - Disabled"); + LOG_INFO("Range Test Module Disabled"); } #endif @@ -216,12 +216,12 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp) */ concurrency::LockGuard g(spiLock); if (!FSBegin()) { - LOG_DEBUG("An Error has occurred while mounting the filesystem"); + LOG_DEBUG("Filesystem mount error"); return 0; } if (FSCom.totalBytes() - FSCom.usedBytes() < 51200) { - LOG_DEBUG("Filesystem doesn't have enough free space. Aborting write"); + LOG_DEBUG("Filesystem low on free space. Abort write"); return 0; } @@ -233,14 +233,14 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp) File fileToWrite = FSCom.open("/static/rangetest.csv", FILE_WRITE); if (!fileToWrite) { - LOG_ERROR("There was an error opening the file for writing"); + LOG_ERROR("Error opening file for writing"); return 0; } // Print the CSV header if (fileToWrite.println("time,from,sender name,sender lat,sender long,rx lat,rx long,rx elevation,rx " "snr,distance,hop limit,payload,rx rssi")) { - LOG_INFO("File was written"); + LOG_INFO("File written"); } else { LOG_ERROR("File write failed"); } @@ -252,7 +252,7 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp) File fileToAppend = FSCom.open("/static/rangetest.csv", FILE_APPEND); if (!fileToAppend) { - LOG_ERROR("There was an error opening the file for appending"); + LOG_ERROR("Error opening file for appending"); return 0; } @@ -319,7 +319,7 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp) return 1; #else - LOG_ERROR("Failed to store range test results - feature only available for ESP32"); + LOG_ERROR("Can't store range test results - ESP32 only"); return 0; #endif @@ -329,27 +329,27 @@ bool RangeTestModuleRadio::removeFile() { #ifdef ARCH_ESP32 if (!FSBegin()) { - LOG_DEBUG("An Error has occurred while mounting the filesystem"); + LOG_DEBUG("Filesystem mount error"); return 0; } if (!FSCom.exists("/static/rangetest.csv")) { - LOG_DEBUG("No range tests found."); + LOG_DEBUG("No range tests found"); return 0; } - LOG_INFO("Deleting previous range test."); + LOG_INFO("Deleting previous range test"); bool result = FSCom.remove("/static/rangetest.csv"); if (!result) { - LOG_ERROR("Failed to delete range test."); + LOG_ERROR("Failed to delete range test"); return 0; } - LOG_INFO("Range test removed."); + LOG_INFO("Range test removed"); return 1; #else - LOG_ERROR("Failed to remove range test results - feature only available for ESP32"); + LOG_ERROR("Can't remove range test results - ESP32 only"); return 0; #endif diff --git a/src/modules/RemoteHardwareModule.cpp b/src/modules/RemoteHardwareModule.cpp index bd5e156554..220925f984 100644 --- a/src/modules/RemoteHardwareModule.cpp +++ b/src/modules/RemoteHardwareModule.cpp @@ -144,7 +144,7 @@ int32_t RemoteHardwareModule::runOnce() if (curVal != previousWatch) { previousWatch = curVal; - LOG_INFO("Broadcast GPIOS 0x%llx changed!", curVal); + LOG_INFO("Broadcast GPIOS 0x%llx changed", curVal); // Something changed! Tell the world with a broadcast message meshtastic_HardwareMessage r = meshtastic_HardwareMessage_init_default; diff --git a/src/modules/StatusLEDModule.cpp b/src/modules/StatusLEDModule.cpp index 5c6f849423..3a09fb8628 100644 --- a/src/modules/StatusLEDModule.cpp +++ b/src/modules/StatusLEDModule.cpp @@ -2,6 +2,7 @@ #include "MeshService.h" #include "configuration.h" #include "mesh/RadioInterface.h" +#include "mesh/Throttle.h" #include /* @@ -118,7 +119,7 @@ int32_t StatusLEDModule::runOnce() } else if (power_state == charged) { CHARGE_LED_state = LED_STATE_ON; } else if (power_state == critical) { - if (POWER_LED_starttime + 30000 < millis() && !doing_fast_blink) { + if (Throttle::hasElapsed(POWER_LED_starttime, 30000) && !doing_fast_blink) { doing_fast_blink = true; POWER_LED_starttime = millis(); } @@ -126,7 +127,7 @@ int32_t StatusLEDModule::runOnce() PAIRING_LED_state = LED_STATE_OFF; CHARGE_LED_state = !CHARGE_LED_state; my_interval = 250; - if (POWER_LED_starttime + 2000 < millis()) { + if (Throttle::hasElapsed(POWER_LED_starttime, 2000)) { doing_fast_blink = false; CHARGE_LED_state = LED_STATE_OFF; } @@ -165,7 +166,7 @@ int32_t StatusLEDModule::runOnce() } #endif #ifdef LED_PAIRING - if (!config.bluetooth.enabled || PAIRING_LED_starttime + 30 * 1000 < millis() || doing_fast_blink) { + if (!config.bluetooth.enabled || Throttle::hasElapsed(PAIRING_LED_starttime, 30 * 1000) || doing_fast_blink) { PAIRING_LED_state = LED_STATE_OFF; } else if (ble_state == unpaired) { if (slowTrack) { @@ -190,7 +191,7 @@ int32_t StatusLEDModule::runOnce() bool chargeIndicatorLED2 = LED_STATE_OFF; bool chargeIndicatorLED3 = LED_STATE_OFF; bool chargeIndicatorLED4 = LED_STATE_OFF; - if (lastUserbuttonTime + 10 * 1000 > millis() || CHARGE_LED_state == LED_STATE_ON) { + if (Throttle::isWithinTimespanMs(lastUserbuttonTime, 10 * 1000) || CHARGE_LED_state == LED_STATE_ON) { // should this be off at very low percentages? chargeIndicatorLED1 = LED_STATE_ON; if (powerStatus && powerStatus->getBatteryChargePercent() >= 25) diff --git a/src/modules/StoreForwardModule.cpp b/src/modules/StoreForwardModule.cpp index bd023716a1..ec0011f4cf 100644 --- a/src/modules/StoreForwardModule.cpp +++ b/src/modules/StoreForwardModule.cpp @@ -421,7 +421,7 @@ ProcessMessage StoreForwardModule::handleReceived(const meshtastic_MeshPacket &m } } else { storeForwardModule->historyAdd(mp); - LOG_INFO("S&F stored. Message history contains %u records now", this->packetHistoryTotalCount); + LOG_INFO("S&F stored, history has %u records", this->packetHistoryTotalCount); } } else if (!isFromUs(&mp) && mp.decoded.portnum == meshtastic_PortNum_STORE_FORWARD_APP) { auto &p = mp.decoded; @@ -431,7 +431,7 @@ ProcessMessage StoreForwardModule::handleReceived(const meshtastic_MeshPacket &m if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_StoreAndForward_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding proto module!"); + LOG_ERROR("Error decoding proto module"); // if we can't decode it, nobody can process it! return ProcessMessage::STOP; } @@ -567,8 +567,8 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, // These fields only have informational purpose on a client. Fill them to consume later. if (p->which_variant == meshtastic_StoreAndForward_history_tag) { this->historyReturnWindow = p->variant.history.window / 60000; - LOG_INFO("Router Response HISTORY - Sending %d messages from last %d minutes", - p->variant.history.history_messages, this->historyReturnWindow); + LOG_INFO("HISTORY response: %d msgs from last %d min", p->variant.history.history_messages, + this->historyReturnWindow); } } break; diff --git a/src/modules/Telemetry/AirQualityTelemetry.cpp b/src/modules/Telemetry/AirQualityTelemetry.cpp index dc4612c703..b67a18327f 100644 --- a/src/modules/Telemetry/AirQualityTelemetry.cpp +++ b/src/modules/Telemetry/AirQualityTelemetry.cpp @@ -46,7 +46,7 @@ void AirQualityTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner) return; } - LOG_INFO("Air Quality Telemetry adding I2C devices..."); + LOG_INFO("Air Quality Telemetry adding I2C devices"); /* Uncomment the preferences below if you want to use the module @@ -81,7 +81,7 @@ void AirQualityTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner) if (!firstTime) { // Re-scan for late comming sensors - LOG_INFO("Re-scanning supported sensors..."); + LOG_INFO("Re-scanning supported sensors"); for (const auto &[address, type] : supportedSensors) { @@ -130,7 +130,7 @@ int32_t AirQualityTelemetryModule::runOnce() sleepOnNextExecution = false; uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.air_quality_interval, default_telemetry_broadcast_interval_secs); - LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.", nightyNightMs); + LOG_DEBUG("Sleep %ims until next send", nightyNightMs); doDeepSleep(nightyNightMs, true, false); } @@ -187,10 +187,10 @@ int32_t AirQualityTelemetryModule::runOnce() // - We can publish the data on the mesh shortly // - Or we can send it to the phone // TODO: This will need to be refurbished once we implement separate intervals - LOG_INFO("Waking up sensors..."); + LOG_INFO("Waking sensors"); for (TelemetrySensor *sensor : sensors) { if (!sensor->canSleep()) { - LOG_DEBUG("%s sensor doesn't have sleep feature. Skipping", sensor->sensorName); + LOG_DEBUG("%s: no sleep support, skip", sensor->sensorName); continue; } @@ -207,7 +207,11 @@ int32_t AirQualityTelemetryModule::runOnce() } if (!sensor->isActive()) { - LOG_DEBUG("Waking up: %s", sensor->sensorName); + LOG_DEBUG("Waking %s", sensor->sensorName); + if (awakeAheadOfTimeMs == 0) + startAirQualityTelemetryCycle = millis(); + awakeAheadOfTimeMs = max(awakeAheadOfTimeMs, sensor->wakeUpTimeMs()); + // TODO multiple sensors with different wake up times collide return sensor->wakeUp(); } @@ -219,19 +223,35 @@ int32_t AirQualityTelemetryModule::runOnce() } bool telemetryDue = (lastTelemetry == 0) || !Throttle::isWithinTimespanMs(lastTelemetry, telemetryIntervalMs); - bool phoneDue = (lastSentToPhone == 0) || !Throttle::isWithinTimespanMs(lastSentToPhone, sendToPhoneIntervalMs); if (telemetryDue && telemetryAllowed) { - sendTelemetry(); - - if (transmitHistory) { - transmitHistory->setLastSentToMesh(TX_HISTORY_KEY_AIR_QUALITY_TELEMETRY); + if (sendTelemetry()) { + if (transmitHistory) { + transmitHistory->setLastSentToMesh(TX_HISTORY_KEY_AIR_QUALITY_TELEMETRY); + } + // Correct the awake time, trimming to 0 + const unsigned long elapsed = millis() - startAirQualityTelemetryCycle; + awakeAheadOfTimeMs = elapsed >= awakeAheadOfTimeMs ? 0 : awakeAheadOfTimeMs - elapsed; + // LOG_DEBUG("Time to publish. Correcting ahead of time by: %d", awakeAheadOfTimeMs); + } else { + awakeAheadOfTimeMs = 0; } } else if (phoneDue && phoneAllowed) { // Mesh transmission isn't due yet, but we can still update the phone. - sendTelemetry(NODENUM_BROADCAST, true); - lastSentToPhone = millis(); + if (sendTelemetry(NODENUM_BROADCAST, true)) { + lastSentToPhone = millis(); + // Correct the awake time, trimming to 0 + const unsigned long elapsed = millis() - startAirQualityTelemetryCycle; + awakeAheadOfTimeMs = elapsed >= awakeAheadOfTimeMs ? 0 : awakeAheadOfTimeMs - elapsed; + // LOG_DEBUG("Time to publish. Correcting ahead of time by: %d", awakeAheadOfTimeMs); + } else { + awakeAheadOfTimeMs = 0; + } + } else { + // if for some reason we end up here after waking up, but not able to send, then reset + // the counter + awakeAheadOfTimeMs = 0; } // Send to sleep sensors that can be to save power @@ -253,7 +273,13 @@ int32_t AirQualityTelemetryModule::runOnce() // mistime the pending deep sleep return FIVE_SECONDS_MS; } - return min(sendToPhoneIntervalMs, result); + + // Update next interval if we were ahead + uint32_t correctedIntervalMs = sendToPhoneIntervalMs + awakeAheadOfTimeMs; + awakeAheadOfTimeMs = 0; + startAirQualityTelemetryCycle = 0; + LOG_DEBUG("Corrected interval in ms: %u", correctedIntervalMs); + return min(correctedIntervalMs, result); } bool AirQualityTelemetryModule::wantUIFrame() @@ -429,7 +455,7 @@ meshtastic_MeshPacket *AirQualityTelemetryModule::allocReply() if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding AirQualityTelemetry module!"); + LOG_ERROR("Error decoding AirQualityTelemetry module"); return NULL; } // Check for a request for air quality metrics @@ -529,7 +555,7 @@ bool AirQualityTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly) // until the next telemetry interval and drains its battery if (!phoneOnly && isPowerSavingSensor()) { if (!validTelemetry) - LOG_WARN("Air quality telemetry unavailable this cycle, sleep without sending"); + LOG_WARN("AQ telemetry unavailable, sleep without send"); sleepOnNextExecution = true; preflightSleepDeferrals = 0; LOG_DEBUG("Start next execution in 5s, then sleep"); diff --git a/src/modules/Telemetry/AirQualityTelemetry.h b/src/modules/Telemetry/AirQualityTelemetry.h index 4cc5af420b..7a7bfff5a5 100644 --- a/src/modules/Telemetry/AirQualityTelemetry.h +++ b/src/modules/Telemetry/AirQualityTelemetry.h @@ -66,6 +66,8 @@ class AirQualityTelemetryModule : private concurrency::OSThread, private: bool firstTime = true; + int32_t awakeAheadOfTimeMs = 0; + int32_t startAirQualityTelemetryCycle = 0; meshtastic_MeshPacket *lastMeasurementPacket; uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute // uint32_t sendToPhoneIntervalMs = 1000; // Send to phone every minute diff --git a/src/modules/Telemetry/DeviceTelemetry.cpp b/src/modules/Telemetry/DeviceTelemetry.cpp index 7ae6ac615e..e3ef3f0950 100644 --- a/src/modules/Telemetry/DeviceTelemetry.cpp +++ b/src/modules/Telemetry/DeviceTelemetry.cpp @@ -6,7 +6,9 @@ #include "PowerFSM.h" #include "RadioLibInterface.h" #include "Router.h" +#include "Throttle.h" #include "TransmitHistory.h" +#include "UptimeClock.h" #include "configuration.h" #include "gps/RTC.h" #include "main.h" @@ -21,13 +23,12 @@ static constexpr uint16_t TX_HISTORY_KEY_DEVICE_TELEMETRY = 0x8001; int32_t DeviceTelemetryModule::runOnce() { - refreshUptime(); uint32_t lastTelemetry = transmitHistory ? transmitHistory->getLastSentToMeshMillis(TX_HISTORY_KEY_DEVICE_TELEMETRY) : 0; bool isImpoliteRole = isSensorOrRouterRole(); - if (((lastTelemetry == 0) || - ((uptimeLastMs - lastTelemetry) >= Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.device_update_interval, - default_telemetry_broadcast_interval_secs, - numOnlineNodes, TrafficType::TELEMETRY))) && + if (((lastTelemetry == 0) || Throttle::hasElapsed(lastTelemetry, Default::getConfiguredOrDefaultMsScaled( + moduleConfig.telemetry.device_update_interval, + default_telemetry_broadcast_interval_secs, + numOnlineNodes, TrafficType::TELEMETRY))) && airTime->isTxAllowedChannelUtil(!isImpoliteRole) && airTime->isTxAllowedAirUtil() && config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN && moduleConfig.telemetry.device_telemetry_enabled) { @@ -38,9 +39,9 @@ int32_t DeviceTelemetryModule::runOnce() // Just send to phone when it's not our time to send to mesh yet // Only send while queue is empty (phone assumed connected) sendTelemetry(NODENUM_BROADCAST, true); - if (lastSentStatsToPhone == 0 || (uptimeLastMs - lastSentStatsToPhone) >= sendStatsToPhoneIntervalMs) { + if (lastSentStatsToPhone == 0 || Throttle::hasElapsed(lastSentStatsToPhone, sendStatsToPhoneIntervalMs)) { sendLocalStatsToPhone(); - lastSentStatsToPhone = uptimeLastMs; + lastSentStatsToPhone = Time::getMillis(); } } return sendToPhoneIntervalMs; @@ -76,7 +77,7 @@ meshtastic_MeshPacket *DeviceTelemetryModule::allocReply() if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding DeviceTelemetry module!"); + LOG_ERROR("Error decoding DeviceTelemetry module"); return NULL; } // Check for a request for device metrics @@ -114,7 +115,7 @@ meshtastic_Telemetry DeviceTelemetryModule::getDeviceTelemetry() t.variant.device_metrics.has_voltage = true; t.variant.device_metrics.voltage = batteryMv / 1000.0f; } - t.variant.device_metrics.uptime_seconds = getUptimeSeconds(); + t.variant.device_metrics.uptime_seconds = Time::getUptimeSecs(); return t; } @@ -124,7 +125,7 @@ meshtastic_Telemetry DeviceTelemetryModule::getLocalStatsTelemetry() telemetry.which_variant = meshtastic_Telemetry_local_stats_tag; telemetry.variant.local_stats = meshtastic_LocalStats_init_zero; telemetry.time = getTime(); - telemetry.variant.local_stats.uptime_seconds = getUptimeSeconds(); + telemetry.variant.local_stats.uptime_seconds = Time::getUptimeSecs(); telemetry.variant.local_stats.channel_utilization = airTime->channelUtilizationPercent(); telemetry.variant.local_stats.air_util_tx = airTime->utilizationTXPercent(); telemetry.variant.local_stats.num_online_nodes = numOnlineNodes; diff --git a/src/modules/Telemetry/DeviceTelemetry.h b/src/modules/Telemetry/DeviceTelemetry.h index f37afee701..c2d2762f33 100644 --- a/src/modules/Telemetry/DeviceTelemetry.h +++ b/src/modules/Telemetry/DeviceTelemetry.h @@ -18,8 +18,6 @@ class DeviceTelemetryModule : private concurrency::OSThread, : concurrency::OSThread("DeviceTelemetry"), ProtobufModule("DeviceTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg) { - uptimeWrapCount = 0; - uptimeLastMs = millis(); nodeStatusObserver.observe(&nodeStatus->onNewStatus); setIntervalFromNow(setStartDelay()); // Wait until NodeInfo is sent } @@ -37,12 +35,6 @@ class DeviceTelemetryModule : private concurrency::OSThread, */ bool sendTelemetry(NodeNum dest = NODENUM_BROADCAST, bool phoneOnly = false); - /** - * Get the uptime in seconds - * Loses some accuracy after 49 days, but that's fine - */ - uint32_t getUptimeSeconds() { return (0xFFFFFFFF / 1000) * uptimeWrapCount + (uptimeLastMs / 1000); } - private: meshtastic_Telemetry getDeviceTelemetry(); meshtastic_Telemetry getLocalStatsTelemetry(); @@ -51,17 +43,4 @@ class DeviceTelemetryModule : private concurrency::OSThread, uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute uint32_t sendStatsToPhoneIntervalMs = 15 * SECONDS_IN_MINUTE * 1000; // Send stats to phone every 15 minutes uint32_t lastSentStatsToPhone = 0; - - void refreshUptime() - { - auto now = millis(); - // If we wrapped around (~49 days), increment the wrap count - if (now < uptimeLastMs) - uptimeWrapCount++; - - uptimeLastMs = now; - } - - uint32_t uptimeWrapCount; - uint32_t uptimeLastMs; }; \ No newline at end of file diff --git a/src/modules/Telemetry/EnvironmentTelemetry.cpp b/src/modules/Telemetry/EnvironmentTelemetry.cpp index 7ca82daee8..9a6076b281 100644 --- a/src/modules/Telemetry/EnvironmentTelemetry.cpp +++ b/src/modules/Telemetry/EnvironmentTelemetry.cpp @@ -257,7 +257,7 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner) if (!moduleConfig.telemetry.environment_measurement_enabled && !ENVIRONMENTAL_TELEMETRY_MODULE_ENABLE) { return; } - LOG_INFO("Environment Telemetry adding I2C devices..."); + LOG_INFO("Environment Telemetry adding I2C devices"); /* Uncomment the preferences below if you want to use the module @@ -366,7 +366,7 @@ int32_t EnvironmentTelemetryModule::runOnce() sleepOnNextExecution = false; uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval, default_telemetry_broadcast_interval_secs); - LOG_DEBUG("Sleep for %ims, then awake to send metrics again", nightyNightMs); + LOG_DEBUG("Sleep %ims until next send", nightyNightMs); doDeepSleep(nightyNightMs, true, false); } @@ -735,7 +735,7 @@ meshtastic_MeshPacket *EnvironmentTelemetryModule::allocReply() if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding EnvironmentTelemetry module!"); + LOG_ERROR("Error decoding EnvironmentTelemetry module"); return NULL; } // Check for a request for environment metrics @@ -813,7 +813,7 @@ bool EnvironmentTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly) // otherwise it stays awake until the next telemetry interval and drains its battery if (!phoneOnly && isPowerSavingSensor()) { if (!validTelemetry) - LOG_WARN("Environment telemetry unavailable this cycle, sleep without sending"); + LOG_WARN("Env telemetry unavailable, sleep without send"); sleepOnNextExecution = true; preflightSleepDeferrals = 0; LOG_DEBUG("Start next execution in 5s, then sleep"); diff --git a/src/modules/Telemetry/HealthTelemetry.cpp b/src/modules/Telemetry/HealthTelemetry.cpp index dc6d2e8d0e..6ec316e701 100644 --- a/src/modules/Telemetry/HealthTelemetry.cpp +++ b/src/modules/Telemetry/HealthTelemetry.cpp @@ -127,7 +127,7 @@ void HealthTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState * const meshtastic_Data &p = lastMeasurementPacket->decoded; if (!pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &lastMeasurement)) { display->drawString(x, y, "Measurement Error"); - LOG_ERROR("Unable to decode last packet"); + LOG_ERROR("Can't decode last packet"); return; } @@ -223,7 +223,7 @@ meshtastic_MeshPacket *HealthTelemetryModule::allocReply() if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding HealthTelemetry module!"); + LOG_ERROR("Error decoding HealthTelemetry module"); return NULL; } // Check for a request for health metrics diff --git a/src/modules/Telemetry/HostMetrics.cpp b/src/modules/Telemetry/HostMetrics.cpp index a9490bc10d..0f9f4d2e8c 100644 --- a/src/modules/Telemetry/HostMetrics.cpp +++ b/src/modules/Telemetry/HostMetrics.cpp @@ -51,7 +51,7 @@ meshtastic_MeshPacket *HostMetricsModule::allocReply() if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_HostMetrics_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding HostMetrics module!"); + LOG_ERROR("Can't decode HostMetrics module"); return NULL; } // Check for a request for device metrics diff --git a/src/modules/Telemetry/HostMetrics.h b/src/modules/Telemetry/HostMetrics.h index 99ee631c15..a352a5afa3 100644 --- a/src/modules/Telemetry/HostMetrics.h +++ b/src/modules/Telemetry/HostMetrics.h @@ -12,8 +12,6 @@ class HostMetricsModule : private concurrency::OSThread, public ProtobufModuleonNewStatus); setIntervalFromNow(setStartDelay()); // Wait until NodeInfo is sent } @@ -35,6 +33,4 @@ class HostMetricsModule : private concurrency::OSThread, public ProtobufModuledecoded; if (!pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &lastMeasurement)) { display->drawString(x, graphics::getTextPositions(display)[line++], "Measurement Error"); - LOG_ERROR("Unable to decode last packet"); + LOG_ERROR("Can't decode last packet"); return; } @@ -247,7 +247,7 @@ meshtastic_MeshPacket *PowerTelemetryModule::allocReply() if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) { decoded = &scratch; } else { - LOG_ERROR("Error decoding PowerTelemetry module!"); + LOG_ERROR("Error decoding PowerTelemetry module"); return NULL; } // Check for a request for power metrics @@ -312,7 +312,7 @@ bool PowerTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly) LOG_WARN("Power telemetry unavailable this cycle, sleep without sending"); sleepOnNextExecution = true; preflightSleepDeferrals = 0; - LOG_DEBUG("Start next execution in 5s then sleep"); + LOG_DEBUG("Start next execution in 5s, then sleep"); setIntervalFromNow(FIVE_SECONDS_MS); } return validTelemetry; diff --git a/src/modules/Telemetry/Sensor/BME680Sensor.cpp b/src/modules/Telemetry/Sensor/BME680Sensor.cpp index c202028e18..107601267e 100644 --- a/src/modules/Telemetry/Sensor/BME680Sensor.cpp +++ b/src/modules/Telemetry/Sensor/BME680Sensor.cpp @@ -7,6 +7,8 @@ #include "FSCommon.h" #include "SPILock.h" #include "TelemetrySensor.h" +#include "UptimeClock.h" +#include "mesh/Throttle.h" #if __has_include() #include @@ -136,13 +138,13 @@ void BME680Sensor::loadState() file.read((uint8_t *)&bsecState, BSEC_MAX_STATE_BLOB_SIZE); file.close(); bme680.setState(bsecState); - LOG_INFO("%s state read from %s", sensorName, bsecConfigFileName); + LOG_INFO("%s: state read from %s", sensorName, bsecConfigFileName); } else { LOG_INFO("No %s state found (File: %s)", sensorName, bsecConfigFileName); } spiLock->unlock(); #else - LOG_ERROR("ERROR: Filesystem not implemented"); + LOG_ERROR("Filesystem not implemented"); #endif } @@ -163,7 +165,8 @@ void BME680Sensor::updateState() } } else { /* Update every STATE_SAVE_PERIOD minutes */ - if ((stateUpdateCounter * STATE_SAVE_PERIOD) < millis()) { + // Interval since the last save; counter * period overflows uint32 past ~198 saves. + if (Throttle::hasElapsed(lastStateSaveMs, STATE_SAVE_PERIOD)) { LOG_DEBUG("%s state update every %d minutes", sensorName, STATE_SAVE_PERIOD / 60000); update = true; stateUpdateCounter++; @@ -177,17 +180,19 @@ void BME680Sensor::updateState() } auto file = FSCom.open(bsecConfigFileName, FILE_O_WRITE); if (file) { - LOG_INFO("%s state write to %s", sensorName, bsecConfigFileName); + LOG_INFO("%s: state write to %s", sensorName, bsecConfigFileName); file.write((uint8_t *)&bsecState, BSEC_MAX_STATE_BLOB_SIZE); file.flush(); file.close(); + // Checkpoint on success only, so a failed write is retried at the next interval. + lastStateSaveMs = Time::getMillis(); } else { LOG_INFO("Can't write %s state (File: %s)", sensorName, bsecConfigFileName); } } spiLock->unlock(); #else - LOG_ERROR("ERROR: Filesystem not implemented"); + LOG_ERROR("Filesystem not implemented"); #endif } diff --git a/src/modules/Telemetry/Sensor/BME680Sensor.h b/src/modules/Telemetry/Sensor/BME680Sensor.h index 1134f04d9d..b8c0bd8109 100644 --- a/src/modules/Telemetry/Sensor/BME680Sensor.h +++ b/src/modules/Telemetry/Sensor/BME680Sensor.h @@ -39,6 +39,7 @@ class BME680Sensor : public TelemetrySensor uint8_t bsecState[BSEC_MAX_STATE_BLOB_SIZE] = {0}; uint8_t accuracy = 0; uint16_t stateUpdateCounter = 0; + uint32_t lastStateSaveMs = 0; // when the state blob was last written, for the save interval bsecSensor sensorList[9] = {BSEC_OUTPUT_IAQ, BSEC_OUTPUT_RAW_TEMPERATURE, BSEC_OUTPUT_RAW_PRESSURE, diff --git a/src/modules/Telemetry/Sensor/DS248XSensor.cpp b/src/modules/Telemetry/Sensor/DS248XSensor.cpp index c98d2d0e36..d0e1385528 100644 --- a/src/modules/Telemetry/Sensor/DS248XSensor.cpp +++ b/src/modules/Telemetry/Sensor/DS248XSensor.cpp @@ -63,8 +63,6 @@ bool DS248XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) #ifdef DS248X_I2C_CLOCK_SPEED reClockI2C.setup(_bus, _port); - - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, DS248X_I2C_CLOCK_SPEED); reClockI2C.setClock(DS248X_I2C_CLOCK_SPEED); #endif /* DS248X_I2C_CLOCK_SPEED */ @@ -78,7 +76,6 @@ bool DS248XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) // Try to init One-Wire with 3 retries. This detects ROMs consistently // on the second one. uint8_t numRetries = 3; - uint8_t rom[8]{}; for (uint8_t retry = 1; retry <= numRetries; retry++) { bool initError = false; @@ -149,7 +146,7 @@ bool DS248XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) printROM(ds248xData.rom); } } else { - LOG_WARN("%s: Could not determine variant (%u/%u)", sensorName, retry, numRetries); + LOG_WARN("%s: Can't determine variant (%u/%u)", sensorName, retry, numRetries); initError = true; } @@ -162,12 +159,14 @@ bool DS248XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) } if (!initError) { - LOG_INFO("%s: Started one-wire (%u/%u)", sensorName, retry, numRetries); status = true; // We want to keep searching for ROMs on the DS248X_DS2482_800 // and always do the three passes if (_variant == ds248x_variant_t::DS248X_DS2484) { + LOG_INFO("%s: Started one-wire (%u/%u)", sensorName, retry, numRetries); break; + } else { + LOG_INFO("%s: One-wire startup cycle (%u/%u)", sensorName, retry, numRetries); } } // TODO Potentially not needed, but taken from Adafruit's library example @@ -175,7 +174,6 @@ bool DS248XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) } #ifdef DS248X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* DS248X_I2C_CLOCK_SPEED */ @@ -192,7 +190,6 @@ bool DS248XSensor::isValidROM(const uint8_t *rom) float DS248XSensor::readTemperatureROM(const uint8_t *rom) { #ifdef DS248X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: attempting to reclock speed to %uHz", sensorName, DS248X_I2C_CLOCK_SPEED); reClockI2C.setClock(DS248X_I2C_CLOCK_SPEED); #endif /* DS248X_I2C_CLOCK_SPEED */ @@ -223,7 +220,6 @@ float DS248XSensor::readTemperatureROM(const uint8_t *rom) } #ifdef DS248X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* DS248X_I2C_CLOCK_SPEED */ @@ -282,18 +278,112 @@ bool DS248XSensor::getMetrics(meshtastic_Telemetry *measurement) return true; } } else if (_variant == ds248x_variant_t::DS248X_DS2482_800) { - // Only ch0 is reported, and each populated channel blocks 750ms on its conversion - // TODO Support more than one temperature via repeated (3.0) - // TODO Select which channel can be reported as main temperature - if (readTemperatureChannel(0)) { - measurement->variant.environment_metrics.temperature = ds2482800Data.ds248xData[0].temperature; - measurement->variant.environment_metrics.has_temperature = true; - LOG_DEBUG("Got %s readings: temperature=%.2f", sensorName, measurement->variant.environment_metrics.temperature); - return true; + // If using DS248X_DS2482_800, we read all channels + uint8_t channelCount = 0; + + // Note, the reason why we are using an unpacked version of this message + // (instead of repeated) it's to save space. With repeated, we have to send all + // channels (even if null) or otherwise we don't know where each channel is + // being reported + for (uint8_t channel = 0; channel < 8; channel++) { + if (readTemperatureChannel(channel)) { + channelCount += 1; + + if (channel == mainTemperatureChannel) { + measurement->variant.environment_metrics.has_temperature = true; + measurement->variant.environment_metrics.temperature = ds2482800Data.ds248xData[channel].temperature; + } + + switch (channel) { + case 0: + measurement->variant.environment_metrics.has_one_wire_temperature_ch0 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch0 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 1: + measurement->variant.environment_metrics.has_one_wire_temperature_ch1 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch1 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 2: + measurement->variant.environment_metrics.has_one_wire_temperature_ch2 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch2 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 3: + measurement->variant.environment_metrics.has_one_wire_temperature_ch3 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch3 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 4: + measurement->variant.environment_metrics.has_one_wire_temperature_ch4 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch4 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 5: + measurement->variant.environment_metrics.has_one_wire_temperature_ch5 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch5 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 6: + measurement->variant.environment_metrics.has_one_wire_temperature_ch6 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch6 = + ds2482800Data.ds248xData[channel].temperature; + break; + case 7: + measurement->variant.environment_metrics.has_one_wire_temperature_ch7 = true; + measurement->variant.environment_metrics.one_wire_temperature_ch7 = + ds2482800Data.ds248xData[channel].temperature; + break; + } + + LOG_DEBUG("Got %s readings: temperature_ch%u=%.2f", sensorName, channel, + ds2482800Data.ds248xData[channel].temperature); + } } - return false; + return channelCount > 0; } return false; } +void DS248XSensor::setMainTemperature(uint8_t channel) +{ + if (channel > 7) { + LOG_ERROR("%s: Requested channel (%u) not available", sensorName, channel); + return; + } + + LOG_INFO("%s: Setting requested channel (%u) as main temperature", sensorName, channel); + mainTemperatureChannel = channel; + return; +} + +AdminMessageHandleResult DS248XSensor::handleAdminMessage(const meshtastic_MeshPacket &mp, meshtastic_AdminMessage *request, + meshtastic_AdminMessage *response) +{ + AdminMessageHandleResult result; + result = AdminMessageHandleResult::NOT_HANDLED; + + switch (request->which_payload_variant) { + case meshtastic_AdminMessage_sensor_config_tag: + if (!request->sensor_config.has_ds248x_config) { + result = AdminMessageHandleResult::NOT_HANDLED; + break; + } + + // Check for main temperature channel request + if (request->sensor_config.ds248x_config.has_main_temperature_channel) { + this->setMainTemperature(request->sensor_config.ds248x_config.main_temperature_channel); + } + + result = AdminMessageHandleResult::HANDLED; + break; + + default: + result = AdminMessageHandleResult::NOT_HANDLED; + } + + return result; +} + #endif \ No newline at end of file diff --git a/src/modules/Telemetry/Sensor/DS248XSensor.h b/src/modules/Telemetry/Sensor/DS248XSensor.h index bfe18a0350..f1215149c0 100644 --- a/src/modules/Telemetry/Sensor/DS248XSensor.h +++ b/src/modules/Telemetry/Sensor/DS248XSensor.h @@ -66,6 +66,7 @@ class DS248XSensor : public TelemetrySensor ds248x_variant_t _variant = DS248X_UNKNOWN; _DS248XData ds248xData{}; _DS2482800Data ds2482800Data{}; + uint8_t mainTemperatureChannel = 0; #ifdef DS248X_I2C_CLOCK_SPEED ReClockI2C reClockI2C; #endif @@ -73,12 +74,16 @@ class DS248XSensor : public TelemetrySensor bool isValidROM(const uint8_t *rom); float readTemperatureROM(const uint8_t *rom); bool readTemperatureChannel(uint8_t channel); + void setMainTemperature(uint8_t channel); public: DS248XSensor(); ds248x_variant_t detectVariant(); virtual bool getMetrics(meshtastic_Telemetry *measurement) override; virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override; + + AdminMessageHandleResult handleAdminMessage(const meshtastic_MeshPacket &mp, meshtastic_AdminMessage *request, + meshtastic_AdminMessage *response) override; }; #endif \ No newline at end of file diff --git a/src/modules/Telemetry/Sensor/HM330XSensor.cpp b/src/modules/Telemetry/Sensor/HM330XSensor.cpp index 1d44cd133f..20b2a5e660 100644 --- a/src/modules/Telemetry/Sensor/HM330XSensor.cpp +++ b/src/modules/Telemetry/Sensor/HM330XSensor.cpp @@ -17,14 +17,11 @@ bool HM330XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) #ifdef HM330X_I2C_CLOCK_SPEED _port = dev->address.port; reClockI2C.setup(_bus, _port); - - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, HM330X_I2C_CLOCK_SPEED); reClockI2C.setClock(HM330X_I2C_CLOCK_SPEED); #endif /* HM330X_I2C_CLOCK_SPEED */ if (hm330x.init(_bus) != HM330XErrorCode::NO_ERROR) { #ifdef HM330X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* HM330X_I2C_CLOCK_SPEED */ LOG_WARN("%s error in sensor init", sensorName); @@ -32,7 +29,6 @@ bool HM330XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) } #ifdef HM330X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* HM330X_I2C_CLOCK_SPEED */ @@ -83,21 +79,18 @@ int32_t HM330XSensor::pendingForReadyMs() bool HM330XSensor::getMetrics(meshtastic_Telemetry *measurement) { #ifdef HM330X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: attempting to reclock speed to %uHz", sensorName, HM330X_I2C_CLOCK_SPEED); reClockI2C.setClock(HM330X_I2C_CLOCK_SPEED); #endif /* HM330X_I2C_CLOCK_SPEED */ if (hm330x.read_sensor_value(buffer, 29)) { LOG_WARN("%s: read result failed", sensorName); #ifdef HM330X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* HM330X_I2C_CLOCK_SPEED */ return false; } #ifdef HM330X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* HM330X_I2C_CLOCK_SPEED */ diff --git a/src/modules/Telemetry/Sensor/MAX17048Sensor.cpp b/src/modules/Telemetry/Sensor/MAX17048Sensor.cpp index 1a6792d3a8..8e6406b80d 100644 --- a/src/modules/Telemetry/Sensor/MAX17048Sensor.cpp +++ b/src/modules/Telemetry/Sensor/MAX17048Sensor.cpp @@ -53,7 +53,7 @@ bool MAX17048Singleton::isBatteryCharging() chargeState = MAX17048ChargeState::IDLE; } - LOG_DEBUG("%s::isBatteryCharging %s volts: %.3f soc: %.3f rate: %.3f", sensorStr, chargeLabels[chargeState], volts, + LOG_TRACE("%s::isBatteryCharging %s volts: %.3f soc: %.3f rate: %.3f", sensorStr, chargeLabels[chargeState], volts, sample.cellPercent, sample.chargeRate); return chargeState == MAX17048ChargeState::IMPORT; } @@ -65,14 +65,14 @@ uint16_t MAX17048Singleton::getBusVoltageMv() LOG_DEBUG("%s::getBusVoltageMv is not connected", sensorStr); return 0; } - LOG_DEBUG("%s::getBusVoltageMv %.3fmV", sensorStr, volts); + LOG_TRACE("%s::getBusVoltageMv %.3fmV", sensorStr, volts); return (uint16_t)(volts * 1000.0f); } uint8_t MAX17048Singleton::getBusBatteryPercent() { float soc = cellPercent(); - LOG_DEBUG("%s::getBusBatteryPercent %.1f%%", sensorStr, soc); + LOG_TRACE("%s::getBusBatteryPercent %.1f%%", sensorStr, soc); return clamp(static_cast(round(soc)), static_cast(0), static_cast(100)); } @@ -82,7 +82,7 @@ uint16_t MAX17048Singleton::getTimeToGoSecs() float soc = cellPercent(); // state of charge in percent 0 to 100 soc = clamp(soc, 0.0f, 100.0f); // clamp soc between 0 and 100% float ttg = ((100.0f - soc) / rate) * 3600.0f; // calculate seconds to charge/discharge - LOG_DEBUG("%s::getTimeToGoSecs %.0f seconds", sensorStr, ttg); + LOG_TRACE("%s::getTimeToGoSecs %.0f seconds", sensorStr, ttg); return (uint16_t)ttg; } @@ -108,7 +108,7 @@ bool MAX17048Singleton::isExternallyPowered() } // if the bus voltage is over MAX17048_BUS_POWER_VOLTS, then the external power // is assumed to be connected - LOG_DEBUG("%s::isExternallyPowered %s connected", sensorStr, volts >= MAX17048_BUS_POWER_VOLTS ? "is" : "is not"); + LOG_TRACE("%s::isExternallyPowered %s connected", sensorStr, volts >= MAX17048_BUS_POWER_VOLTS ? "is" : "is not"); return volts >= MAX17048_BUS_POWER_VOLTS; } @@ -140,7 +140,7 @@ void MAX17048Sensor::setup() {} bool MAX17048Sensor::getMetrics(meshtastic_Telemetry *measurement) { - LOG_DEBUG("MAX17048 getMetrics id: %i", measurement->which_variant); + LOG_TRACE("MAX17048 getMetrics id: %i", measurement->which_variant); float volts = max17048->cellVoltage(); if (isnan(volts)) { diff --git a/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp b/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp index e67b781451..198e87c489 100644 --- a/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp +++ b/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp @@ -107,7 +107,7 @@ bool NAU7802Sensor::saveCalibrationData() pb_ostream_t stream = {&writecb, static_cast(&file), meshtastic_Nau7802Config_size}; if (!pb_encode(&stream, &meshtastic_Nau7802Config_msg, &nau7802config)) { - LOG_ERROR("Error: can't encode protobuf %s", PB_GET_ERROR(&stream)); + LOG_ERROR("Can't encode protobuf %s", PB_GET_ERROR(&stream)); } else { okay = true; } @@ -126,7 +126,7 @@ bool NAU7802Sensor::loadCalibrationData() LOG_INFO("%s state read from %s", sensorName, nau7802ConfigFileName); pb_istream_t stream = {&readcb, &file, meshtastic_Nau7802Config_size}; if (!pb_decode(&stream, &meshtastic_Nau7802Config_msg, &nau7802config)) { - LOG_ERROR("Error: can't decode protobuf %s", PB_GET_ERROR(&stream)); + LOG_ERROR("Can't decode protobuf %s", PB_GET_ERROR(&stream)); } else { nau7802.setZeroOffset(nau7802config.zeroOffset); nau7802.setCalibrationFactor(nau7802config.calibrationFactor); diff --git a/src/modules/Telemetry/Sensor/PMSA003ISensor.cpp b/src/modules/Telemetry/Sensor/PMSA003ISensor.cpp index 7fae87b984..c366057735 100644 --- a/src/modules/Telemetry/Sensor/PMSA003ISensor.cpp +++ b/src/modules/Telemetry/Sensor/PMSA003ISensor.cpp @@ -24,8 +24,6 @@ bool PMSA003ISensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) #ifdef PMSA003I_I2C_CLOCK_SPEED _port = dev->address.port; reClockI2C.setup(_bus, _port); - - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, PMSA003I_I2C_CLOCK_SPEED); reClockI2C.setClock(PMSA003I_I2C_CLOCK_SPEED); #endif /* PMSA003I_I2C_CLOCK_SPEED */ @@ -33,7 +31,6 @@ bool PMSA003ISensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) if (_bus->endTransmission() != 0) { LOG_WARN("%s not found on I2C at 0x12", sensorName); #ifdef PMSA003I_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* PMSA003I_I2C_CLOCK_SPEED */ sleep(); @@ -41,7 +38,6 @@ bool PMSA003ISensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) } #ifdef PMSA003I_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* PMSA003I_I2C_CLOCK_SPEED */ @@ -61,7 +57,6 @@ bool PMSA003ISensor::getMetrics(meshtastic_Telemetry *measurement) } #ifdef PMSA003I_I2C_CLOCK_SPEED - LOG_DEBUG("%s: attempting to reclock speed to %uHz", sensorName, PMSA003I_I2C_CLOCK_SPEED); reClockI2C.setClock(PMSA003I_I2C_CLOCK_SPEED); #endif /* PMSA003I_I2C_CLOCK_SPEED */ @@ -69,7 +64,6 @@ bool PMSA003ISensor::getMetrics(meshtastic_Telemetry *measurement) if (_bus->available() < PMSA003I_FRAME_LENGTH) { LOG_WARN("%s: read failed: incomplete data (%d bytes)", sensorName, _bus->available()); #ifdef PMSA003I_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* PMSA003I_I2C_CLOCK_SPEED */ return false; @@ -80,7 +74,6 @@ bool PMSA003ISensor::getMetrics(meshtastic_Telemetry *measurement) } #ifdef PMSA003I_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* PMSA003I_I2C_CLOCK_SPEED */ @@ -199,7 +192,7 @@ void PMSA003ISensor::sleep() uint32_t PMSA003ISensor::wakeUp() { #ifdef PMSA003I_ENABLE_PIN - LOG_INFO("%s: Waking up", sensorName); + LOG_INFO("%s Waking", sensorName); digitalWrite(PMSA003I_ENABLE_PIN, HIGH); state = PMSA003I_ACTIVE; pmMeasureStarted = getTime(); diff --git a/src/modules/Telemetry/Sensor/RAK9154Sensor.cpp b/src/modules/Telemetry/Sensor/RAK9154Sensor.cpp index ad3925f081..367f5bdc9f 100644 --- a/src/modules/Telemetry/Sensor/RAK9154Sensor.cpp +++ b/src/modules/Telemetry/Sensor/RAK9154Sensor.cpp @@ -63,7 +63,7 @@ static void onewire_evt(const uint8_t pid, const uint8_t sid, const SNHUBAPI_EVT // { // LOG_INFO("%02x,", msg[i]); // } - // LOG_INFO(""); + // LOG_INFO("."); switch (msg[0]) { case RAK_IPSO_CAPACITY: dc_prec = msg[1]; @@ -91,7 +91,7 @@ static void onewire_evt(const uint8_t pid, const uint8_t sid, const SNHUBAPI_EVT // { // LOG_INFO("%02x,", msg[i]); // } - // LOG_INFO(""); + // LOG_INFO("."); switch (msg[0]) { case RAK_IPSO_CAPACITY: diff --git a/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp b/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp index 3dbd06e8d6..27a3f0e282 100644 --- a/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp +++ b/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp @@ -52,7 +52,7 @@ float RCWL9620Sensor::getDistance() _wire->requestFrom(_addr, (uint8_t)3); if (_wire->available() < 3) { - LOG_DEBUG("[RCWL9620] less than 3 octets !"); + LOG_DEBUG("[RCWL9620] less than 3 octets "); return 0.0; } diff --git a/src/modules/Telemetry/Sensor/SCD30Sensor.cpp b/src/modules/Telemetry/Sensor/SCD30Sensor.cpp index 59a50779c3..c380f0f42e 100644 --- a/src/modules/Telemetry/Sensor/SCD30Sensor.cpp +++ b/src/modules/Telemetry/Sensor/SCD30Sensor.cpp @@ -18,28 +18,24 @@ bool SCD30Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) #ifdef SCD30_I2C_CLOCK_SPEED _port = dev->address.port; reClockI2C.setup(_bus, _port); - - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD30_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD30_I2C_CLOCK_SPEED); #endif /* SCD30_I2C_CLOCK_SPEED */ scd30.begin(*_bus, _address); if (!startMeasurement()) { - LOG_ERROR("%s: Failed to start periodic measurement", sensorName); + LOG_ERROR("%s: Periodic measurement start failed", sensorName); #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ return false; } if (!getASC(ascActive)) { - LOG_WARN("%s: Could not determine ASC state", sensorName); + LOG_WARN("%s: Can't determine ASC state", sensorName); } #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ @@ -59,21 +55,18 @@ bool SCD30Sensor::getMetrics(meshtastic_Telemetry *measurement) float co2, temperature, humidity; #ifdef SCD30_I2C_CLOCK_SPEED - LOG_DEBUG("%s: attempting to reclock speed to %uHz", sensorName, SCD30_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD30_I2C_CLOCK_SPEED); #endif /* SCD30_I2C_CLOCK_SPEED */ if (scd30.readMeasurementData(co2, temperature, humidity) != SCD30_NO_ERROR) { - LOG_ERROR("%s: Failed to read measurement data", sensorName); + LOG_ERROR("%s: Measurement read failed", sensorName); #ifdef SCD30_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ return false; } #ifdef SCD30_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ @@ -102,7 +95,7 @@ bool SCD30Sensor::setMeasurementInterval(uint16_t measInterval) error = scd30.setMeasurementInterval(measInterval); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to set measurement interval. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't set measurement interval, rc=%u", sensorName, error); return false; } @@ -123,7 +116,7 @@ bool SCD30Sensor::getMeasurementInterval(uint16_t &measInterval) error = scd30.getMeasurementInterval(measInterval); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to get measurement interval. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't get measurement interval, rc=%u", sensorName, error); return false; } @@ -153,7 +146,7 @@ bool SCD30Sensor::startMeasurement() state = SCD30_MEASUREMENT; return true; } else { - LOG_ERROR("%s: Couldn't start measurement mode", sensorName); + LOG_ERROR("%s: Can't start measurement mode", sensorName); return false; } } @@ -168,7 +161,7 @@ bool SCD30Sensor::stopMeasurement() error = scd30.stopPeriodicMeasurement(); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to stop measurement", sensorName); + LOG_ERROR("%s: Can't stop measurement", sensorName); return false; } @@ -180,17 +173,17 @@ bool SCD30Sensor::performFRC(uint16_t targetCO2) { uint16_t error; - LOG_INFO("%s: Issuing FRC. Ensure device has been working at least 3 minutes in stable target environment", sensorName); + LOG_INFO("%s: Issuing FRC. Needs 3+ min in stable target environment", sensorName); LOG_INFO("%s: Target CO2: %u ppm", sensorName, targetCO2); error = scd30.forceRecalibration((uint16_t)targetCO2); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to perform forced recalibration.", sensorName); + LOG_ERROR("%s: Can't perform FRC", sensorName); return false; } - LOG_INFO("%s: FRC Correction successful.", sensorName); + LOG_INFO("%s: FRC done", sensorName); return true; } @@ -204,12 +197,12 @@ bool SCD30Sensor::setASC(bool ascEnabled) error = scd30.activateAutoCalibration((uint16_t)ascEnabled); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to send command.", sensorName); + LOG_ERROR("%s: Can't send command", sensorName); return false; } if (!getASC(ascActive)) { - LOG_ERROR("%s: Unable to check if ASC is enabled", sensorName); + LOG_ERROR("%s: Can't check if ASC enabled", sensorName); return false; } @@ -224,7 +217,7 @@ bool SCD30Sensor::getASC(uint16_t &_ascActive) error = scd30.getAutoCalibrationStatus(_ascActive); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to send command.", sensorName); + LOG_ERROR("%s: Can't get ASC status", sensorName); return false; } @@ -260,23 +253,23 @@ bool SCD30Sensor::setTemperature(float tempReference) if (tempReference == 100) { // Requesting the value of 100 will restore the temperature offset - LOG_INFO("%s: Setting reference temperature at 0degC", sensorName); + LOG_INFO("%s: Setting reference temp at 0degC", sensorName); _tempOffset = 0; } else { - LOG_INFO("%s: Setting reference temperature at: %.2f", sensorName, tempReference); + LOG_INFO("%s: Setting reference temp at: %.2f", sensorName, tempReference); error = scd30.readMeasurementData(co2, temperature, humidity); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to read current temperature. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't read current temp, rc=%u", sensorName, error); return false; } - LOG_INFO("%s: Current sensor temperature: %.2f", sensorName, temperature); + LOG_INFO("%s: Current sensor temp: %.2f", sensorName, temperature); tempOffset = (temperature - tempReference); if (tempOffset < 0) { - LOG_ERROR("%s: temperature offset is only positive", sensorName); + LOG_ERROR("%s: temp offset is only positive", sensorName); return false; } @@ -284,16 +277,16 @@ bool SCD30Sensor::setTemperature(float tempReference) _tempOffset = static_cast(tempOffset); } - LOG_INFO("%s: Setting temperature offset: %u (*100)", sensorName, _tempOffset); + LOG_INFO("%s: Setting temp offset: %u (*100)", sensorName, _tempOffset); error = scd30.setTemperatureOffset(_tempOffset); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to set temperature offset. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't set temp offset, rc=%u", sensorName, error); return false; } scd30.getTemperatureOffset(updatedTempOffset); - LOG_INFO("%s: Updated sensor temperature offset: %u (*100)", sensorName, updatedTempOffset); + LOG_INFO("%s: Updated sensor temp offset: %u (*100)", sensorName, updatedTempOffset); return true; } @@ -307,7 +300,7 @@ bool SCD30Sensor::setAltitude(uint16_t altitude) error = scd30.setAltitudeCompensation(altitude); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to set altitude. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't set altitude, rc=%u", sensorName, error); return false; } @@ -325,7 +318,7 @@ bool SCD30Sensor::getAltitude(uint16_t &altitude) error = scd30.getAltitudeCompensation(altitude); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to get altitude. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't get altitude, rc=%u", sensorName, error); return false; } LOG_INFO("%s: Sensor altitude: %u", sensorName, altitude); @@ -342,11 +335,11 @@ bool SCD30Sensor::softReset() error = scd30.softReset(); if (error != SCD30_NO_ERROR) { - LOG_ERROR("%s: Unable to do soft reset. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't soft reset, rc=%u", sensorName, error); return false; } - LOG_INFO("%s: soft reset successful", sensorName); + LOG_INFO("%s: soft reset done", sensorName); return true; } @@ -366,14 +359,12 @@ bool SCD30Sensor::isActive() uint32_t SCD30Sensor::wakeUp() { #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD30_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD30_I2C_CLOCK_SPEED); #endif /* SCD30_I2C_CLOCK_SPEED */ startMeasurement(); #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ @@ -387,14 +378,12 @@ uint32_t SCD30Sensor::wakeUp() void SCD30Sensor::sleep() { #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD30_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD30_I2C_CLOCK_SPEED); #endif /* SCD30_I2C_CLOCK_SPEED */ stopMeasurement(); #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ } @@ -420,7 +409,6 @@ AdminMessageHandleResult SCD30Sensor::handleAdminMessage(const meshtastic_MeshPa AdminMessageHandleResult result; #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD30_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD30_I2C_CLOCK_SPEED); #endif /* SCD30_I2C_CLOCK_SPEED */ @@ -478,7 +466,6 @@ AdminMessageHandleResult SCD30Sensor::handleAdminMessage(const meshtastic_MeshPa } #ifdef SCD30_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD30_I2C_CLOCK_SPEED */ diff --git a/src/modules/Telemetry/Sensor/SCD4XSensor.cpp b/src/modules/Telemetry/Sensor/SCD4XSensor.cpp index 26d50ab3e7..7c6bc3ecf7 100644 --- a/src/modules/Telemetry/Sensor/SCD4XSensor.cpp +++ b/src/modules/Telemetry/Sensor/SCD4XSensor.cpp @@ -19,8 +19,6 @@ bool SCD4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) #ifdef SCD4X_I2C_CLOCK_SPEED _port = dev->address.port; reClockI2C.setup(_bus, _port); - - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD4X_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD4X_I2C_CLOCK_SPEED); #endif /* SCD4X_I2C_CLOCK_SPEED */ @@ -32,7 +30,6 @@ bool SCD4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) // Stop periodic measurement if (!stopMeasurement()) { #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return false; @@ -44,9 +41,8 @@ bool SCD4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) if (sensorVariant == SCD4X_SENSOR_VARIANT_SCD41) { LOG_INFO("%s: Found SCD41", sensorName); if (!powerUp()) { - LOG_ERROR("%s: Error trying to execute powerUp()", sensorName); + LOG_ERROR("%s: powerUp() failed", sensorName); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return false; @@ -54,9 +50,8 @@ bool SCD4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) } if (!getASC(ascActive)) { - LOG_ERROR("%s: Unable to check if ASC is enabled", sensorName); + LOG_ERROR("%s: Can't check if ASC enabled", sensorName); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return false; @@ -64,16 +59,14 @@ bool SCD4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) // Start measurement in selected power mode (low power by default) if (!startMeasurement()) { - LOG_ERROR("%s: Couldn't start measurement", sensorName); + LOG_ERROR("%s: Can't start measurement", sensorName); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return false; } #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ @@ -100,7 +93,6 @@ bool SCD4XSensor::getMetrics(meshtastic_Telemetry *measurement) float temperature, humidity; #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: attempting to reclock speed to %uHz", sensorName, SCD4X_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD4X_I2C_CLOCK_SPEED); #endif /* SCD4X_I2C_CLOCK_SPEED */ @@ -118,7 +110,6 @@ bool SCD4XSensor::getMetrics(meshtastic_Telemetry *measurement) if (error != SCD4X_NO_ERROR || !dataReady) { #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ LOG_ERROR("SCD4X: Data is not ready"); @@ -128,15 +119,14 @@ bool SCD4XSensor::getMetrics(meshtastic_Telemetry *measurement) error = scd4x.readMeasurement(co2, temperature, humidity); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ LOG_DEBUG("Got %s readings: co2=%u, co2_temp=%.2f, co2_hum%.2f", sensorName, co2, temperature, humidity); if (error != SCD4X_NO_ERROR) { - LOG_DEBUG("%s: Error while getting measurements: %u", sensorName, error); + LOG_DEBUG("%s: Error getting measurements: %u", sensorName, error); if (co2 == 0) { - LOG_ERROR("%s: Skipping invalid measurement.", sensorName); + LOG_ERROR("%s: Skipping invalid measurement", sensorName); } return false; } else { @@ -167,7 +157,7 @@ bool SCD4XSensor::performFRC(uint32_t targetCO2) { uint16_t error, frcCorr; - LOG_INFO("%s: Issuing FRC. Ensure device has been working at least 3 minutes in stable target environment", sensorName); + LOG_INFO("%s: Issuing FRC. Needs 3+ min in stable target environment", sensorName); if (!stopMeasurement()) { return false; @@ -180,16 +170,16 @@ bool SCD4XSensor::performFRC(uint32_t targetCO2) delay(400); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to perform forced recalibration.", sensorName); + LOG_ERROR("%s: Can't perform FRC", sensorName); return false; } if (frcCorr == 0xFFFF) { - LOG_ERROR("%s: Error while performing forced recalibration.", sensorName); + LOG_ERROR("%s: FRC failed", sensorName); return false; } - LOG_INFO("%s: FRC Correction successful. Correction output: %u", sensorName, (uint16_t)(frcCorr - 0x8000)); + LOG_INFO("%s: FRC done. Correction output: %u", sensorName, (uint16_t)(frcCorr - 0x8000)); return true; } @@ -224,7 +214,7 @@ bool SCD4XSensor::startMeasurement() state = SCD4X_MEASUREMENT; return true; } else { - LOG_ERROR("%s: Unable to start measurement mode", sensorName); + LOG_ERROR("%s: Can't start measurement mode", sensorName); return false; } } @@ -239,7 +229,7 @@ bool SCD4XSensor::stopMeasurement() error = scd4x.stopPeriodicMeasurement(); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to stop measurement.", sensorName); + LOG_ERROR("%s: Can't stop measurement", sensorName); return false; } @@ -286,11 +276,11 @@ bool SCD4XSensor::getASC(uint16_t &_ascActive) error = scd4x.getAutomaticSelfCalibrationEnabled(_ascActive); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to send command.", sensorName); + LOG_ERROR("%s: Can't send command", sensorName); return false; } - LOG_INFO("%s ASC is %s", sensorName, _ascActive ? "enabled" : "disabled"); + LOG_INFO("%s: ASC is %s", sensorName, _ascActive ? "enabled" : "disabled"); return true; } @@ -308,7 +298,7 @@ bool SCD4XSensor::setASC(bool ascEnabled) { uint16_t error; - LOG_INFO("%s %s ASC", sensorName, ascEnabled ? "Enabling" : "Disabling"); + LOG_INFO("%s: %s ASC", sensorName, ascEnabled ? "Enabling" : "Disabling"); if (!stopMeasurement()) { return false; @@ -317,18 +307,18 @@ bool SCD4XSensor::setASC(bool ascEnabled) error = scd4x.setAutomaticSelfCalibrationEnabled((uint16_t)ascEnabled); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to send command.", sensorName); + LOG_ERROR("%s: Can't send command", sensorName); return false; } error = scd4x.persistSettings(); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to make settings persistent.", sensorName); + LOG_ERROR("%s: Can't persist settings", sensorName); return false; } if (!getASC(ascActive)) { - LOG_ERROR("%s: Unable to check if ASC is enabled", sensorName); + LOG_ERROR("%s: Can't check if ASC enabled", sensorName); return false; } @@ -356,7 +346,7 @@ bool SCD4XSensor::setASCBaseline(uint32_t targetCO2) getASC(ascActive); if (!ascActive) { - LOG_ERROR("%s: Can't set ASC baseline. ASC is not active", sensorName); + LOG_ERROR("%s: Can't set ASC baseline, ASC not active", sensorName); return false; } @@ -367,17 +357,17 @@ bool SCD4XSensor::setASCBaseline(uint32_t targetCO2) error = scd4x.setAutomaticSelfCalibrationTarget((uint16_t)targetCO2); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to send command.", sensorName); + LOG_ERROR("%s: Can't send command", sensorName); return false; } error = scd4x.persistSettings(); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to make settings persistent.", sensorName); + LOG_ERROR("%s: Can't persist settings", sensorName); return false; } - LOG_INFO("%s: Setting ASC baseline successful", sensorName); + LOG_INFO("%s: ASC baseline set", sensorName); return true; } @@ -414,7 +404,7 @@ bool SCD4XSensor::setTemperature(float tempReference) float temperature; float humidity; - LOG_INFO("%s: Setting reference temperature at: %.2f", sensorName, tempReference); + LOG_INFO("%s: Setting reference temp at: %.2f", sensorName, tempReference); error = scd4x.getDataReadyStatus(dataReady); if (error != SCD4X_NO_ERROR || !dataReady) { @@ -424,11 +414,11 @@ bool SCD4XSensor::setTemperature(float tempReference) error = scd4x.readMeasurement(co2, temperature, humidity); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to read current temperature. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't read current temp, rc=%u", sensorName, error); return false; } - LOG_INFO("%s: Current sensor temperature: %.2f", sensorName, temperature); + LOG_INFO("%s: Current sensor temp: %.2f", sensorName, temperature); if (!stopMeasurement()) { return false; @@ -437,28 +427,28 @@ bool SCD4XSensor::setTemperature(float tempReference) error = scd4x.getTemperatureOffset(prevTempOffset); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to get temperature offset. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't get temp offset, rc=%u", sensorName, error); return false; } - LOG_INFO("%s: Current sensor temperature offset: %.2f", sensorName, prevTempOffset); + LOG_INFO("%s: Current sensor temp offset: %.2f", sensorName, prevTempOffset); tempOffset = temperature - tempReference + prevTempOffset; - LOG_INFO("%s: Setting temperature offset: %.2f", sensorName, tempOffset); + LOG_INFO("%s: Setting temp offset: %.2f", sensorName, tempOffset); error = scd4x.setTemperatureOffset(tempOffset); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to set temperature offset. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't set temp offset, rc=%u", sensorName, error); return false; } error = scd4x.persistSettings(); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to make settings persistent. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't persist settings, rc=%u", sensorName, error); return false; } scd4x.getTemperatureOffset(updatedTempOffset); - LOG_INFO("%s: Updated sensor temperature offset: %.2f", sensorName, updatedTempOffset); + LOG_INFO("%s: Updated sensor temp offset: %.2f", sensorName, updatedTempOffset); return true; } @@ -484,7 +474,7 @@ bool SCD4XSensor::getAltitude(uint16_t &altitude) error = scd4x.getSensorAltitude(altitude); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to get altitude. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't get altitude, rc=%u", sensorName, error); return false; } LOG_INFO("%s: Sensor altitude: %u", sensorName, altitude); @@ -508,7 +498,7 @@ bool SCD4XSensor::getAmbientPressure(uint32_t &ambientPressure) error = scd4x.getAmbientPressure(ambientPressure); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to get altitude. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't get ambient pressure, rc=%u", sensorName, error); return false; } LOG_INFO("%s: Sensor ambient pressure: %u", sensorName, ambientPressure); @@ -537,7 +527,7 @@ bool SCD4XSensor::setAltitude(uint32_t altitude) error = scd4x.setSensorAltitude(altitude); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to set altitude. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't set altitude, rc=%u", sensorName, error); return false; } @@ -545,7 +535,7 @@ bool SCD4XSensor::setAltitude(uint32_t altitude) // doesn't indicate it's needed. // error = scd4x.persistSettings(); // if (error != SCD4X_NO_ERROR) { - // LOG_ERROR("%s: Unable to make settings persistent. Error code: %u", sensorName, error); + // LOG_ERROR("%s: Can't make settings persistent. Error code: %u", sensorName, error); // return false; // } @@ -577,18 +567,18 @@ bool SCD4XSensor::setAmbientPressure(uint32_t ambientPressure) error = scd4x.setAmbientPressure(ambientPressure); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to set altitude. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't set ambient pressure, rc=%u", sensorName, error); return false; } // Sensirion doesn't indicate if this is necessary. We send it anyway error = scd4x.persistSettings(); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to make settings persistent. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't persist settings, rc=%u", sensorName, error); return false; } - LOG_INFO("%s: ambient pressure set set", sensorName); + LOG_INFO("%s: ambient pressure set", sensorName); return true; } @@ -615,11 +605,11 @@ bool SCD4XSensor::factoryReset() error = scd4x.performFactoryReset(); if (error != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Unable to do factory reset. Error code: %u", sensorName, error); + LOG_ERROR("%s: Can't factory reset, rc=%u", sensorName, error); return false; } - LOG_INFO("%s: Factory reset successful", sensorName); + LOG_INFO("%s: Factory reset done", sensorName); return true; } @@ -636,37 +626,33 @@ bool SCD4XSensor::factoryReset() */ bool SCD4XSensor::powerDown() { - LOG_INFO("%s: Trying to send sensor to sleep", sensorName); + LOG_INFO("%s: Sending sensor to sleep", sensorName); if (sensorVariant != SCD4X_SENSOR_VARIANT_SCD41) { - LOG_WARN("SCD4X: Can't send sensor to sleep. Incorrect variant. Ignoring"); + LOG_WARN("SCD4X: Can't sleep: wrong variant, ignoring"); return true; } #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD4X_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD4X_I2C_CLOCK_SPEED); #endif /* SCD4X_I2C_CLOCK_SPEED */ if (!stopMeasurement()) { #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return false; } if (scd4x.powerDown() != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Error trying to execute sleep()", sensorName); + LOG_ERROR("%s: sleep() failed", sensorName); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return false; } #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ @@ -687,10 +673,10 @@ bool SCD4XSensor::powerDown() */ bool SCD4XSensor::powerUp() { - LOG_INFO("%s: Waking up", sensorName); + LOG_INFO("%s Waking", sensorName); if (scd4x.wakeUp() != SCD4X_NO_ERROR) { - LOG_ERROR("%s: Error trying to execute wakeUp()", sensorName); + LOG_ERROR("%s: wakeUp() failed", sensorName); return false; } @@ -715,21 +701,18 @@ uint32_t SCD4XSensor::wakeUp() { #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD4X_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD4X_I2C_CLOCK_SPEED); #endif /* SCD4X_I2C_CLOCK_SPEED */ if (startMeasurement()) { co2MeasureStarted = getTime(); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ return SCD4X_WARMUP_MS; } #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ @@ -743,14 +726,12 @@ uint32_t SCD4XSensor::wakeUp() void SCD4XSensor::sleep() { #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD4X_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD4X_I2C_CLOCK_SPEED); #endif /* SCD4X_I2C_CLOCK_SPEED */ stopMeasurement(); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ } @@ -780,7 +761,7 @@ int32_t SCD4XSensor::pendingForReadyMs() LOG_DEBUG("%s: Since measure started: %ums", sensorName, sinceCO2MeasureStarted); if (sinceCO2MeasureStarted < SCD4X_WARMUP_MS) { - LOG_INFO("%s: not enough time passed since starting measurement", sensorName); + LOG_INFO("%s: not enough time since measurement start", sensorName); return SCD4X_WARMUP_MS - sinceCO2MeasureStarted; } return 0; @@ -792,7 +773,6 @@ AdminMessageHandleResult SCD4XSensor::handleAdminMessage(const meshtastic_MeshPa AdminMessageHandleResult result; #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: attempting to reclock speed to %uHz", sensorName, SCD4X_I2C_CLOCK_SPEED); reClockI2C.setClock(SCD4X_I2C_CLOCK_SPEED); #endif /* SCD4X_I2C_CLOCK_SPEED */ @@ -897,7 +877,6 @@ AdminMessageHandleResult SCD4XSensor::handleAdminMessage(const meshtastic_MeshPa this->startMeasurement(); #ifdef SCD4X_I2C_CLOCK_SPEED - LOG_INFO("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SCD4X_I2C_CLOCK_SPEED */ diff --git a/src/modules/Telemetry/Sensor/SEN5XSensor.cpp b/src/modules/Telemetry/Sensor/SEN5XSensor.cpp index 58ac4370ad..37df1204be 100644 --- a/src/modules/Telemetry/Sensor/SEN5XSensor.cpp +++ b/src/modules/Telemetry/Sensor/SEN5XSensor.cpp @@ -22,16 +22,18 @@ bool SEN5XSensor::getVersion() } delay(20); // From Sensirion Datasheet - uint8_t versionBuffer[12]{}; - size_t charNumber = readBuffer(&versionBuffer[0], 3); - if (charNumber == 0) { - LOG_ERROR("%s: Error getting data ready flag value", sensorName); + // Version reply layout: fw major/minor, fw debug, hw major/minor, + // protocol major/minor, padding + uint8_t versionBuffer[SEN5X_VERSION_BUFFER_SIZE]{}; + size_t charNumber = readBuffer(&versionBuffer[0], SEN5X_VERSION_BUFFER_SIZE + (SEN5X_VERSION_BUFFER_SIZE / 2)); + if (charNumber < SEN5X_VERSION_BUFFER_SIZE) { + LOG_ERROR("%s: Error getting device version value", sensorName); return false; } - firmwareVer = versionBuffer[0] + (versionBuffer[1] / 10); - hardwareVer = versionBuffer[3] + (versionBuffer[4] / 10); - protocolVer = versionBuffer[5] + (versionBuffer[6] / 10); + firmwareVer = versionBuffer[0] + (versionBuffer[1] / 10.0f); + hardwareVer = versionBuffer[3] + (versionBuffer[4] / 10.0f); + protocolVer = versionBuffer[5] + (versionBuffer[6] / 10.0f); LOG_INFO("%s: Firmware Version: %0.2f", sensorName, firmwareVer); LOG_INFO("%s: Hardware Version: %0.2f", sensorName, hardwareVer); @@ -48,12 +50,11 @@ bool SEN5XSensor::findModel() } delay(50); // From Sensirion Datasheet - const uint8_t nameSize = 48; - uint8_t name[nameSize]; - size_t charNumber = readBuffer(&name[0], nameSize); + uint8_t name[SEN5X_PRODUCT_NAME_BUFFER_SIZE]{}; + size_t charNumber = readBuffer(&name[0], SEN5X_PRODUCT_NAME_BUFFER_SIZE + (SEN5X_PRODUCT_NAME_BUFFER_SIZE / 2)); bool foundModel = false; - if (charNumber == 0) { + if (charNumber < SEN5X_PRODUCT_NAME_BUFFER_SIZE) { LOG_ERROR("%s: Error getting device name", sensorName); return foundModel; } @@ -132,7 +133,6 @@ bool SEN5XSensor::sendCommand(uint16_t command, uint8_t *buffer, uint8_t byteNum } #ifdef SEN5X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: Attempting to reclock speed to %uHz", sensorName, SEN5X_I2C_CLOCK_SPEED); reClockI2C.setClock(SEN5X_I2C_CLOCK_SPEED); #endif /* SEN5X_I2C_CLOCK_SPEED */ @@ -145,7 +145,6 @@ bool SEN5XSensor::sendCommand(uint16_t command, uint8_t *buffer, uint8_t byteNum uint8_t i2c_error = _bus->endTransmission(); #ifdef SEN5X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SEN5X_I2C_CLOCK_SPEED */ @@ -164,7 +163,6 @@ bool SEN5XSensor::sendCommand(uint16_t command, uint8_t *buffer, uint8_t byteNum uint8_t SEN5XSensor::readBuffer(uint8_t *buffer, uint8_t byteNumber) { #ifdef SEN5X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: Attempting to reclock speed to %uHz", sensorName, SEN5X_I2C_CLOCK_SPEED); reClockI2C.setClock(SEN5X_I2C_CLOCK_SPEED); #endif /* SEN5X_I2C_CLOCK_SPEED */ @@ -172,7 +170,6 @@ uint8_t SEN5XSensor::readBuffer(uint8_t *buffer, uint8_t byteNumber) if (readBytes != byteNumber) { LOG_ERROR("%s: Error reading I2C bus", sensorName); #ifdef SEN5X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SEN5X_I2C_CLOCK_SPEED */ return 0; @@ -186,9 +183,8 @@ uint8_t SEN5XSensor::readBuffer(uint8_t *buffer, uint8_t byteNumber) uint8_t recvCRC = _bus->read(); uint8_t calcCRC = sen5xCRC(&buffer[i - 2]); if (recvCRC != calcCRC) { - LOG_ERROR("%s: Checksum error while receiving msg", sensorName); + LOG_ERROR("%s: Checksum error receiving msg", sensorName); #ifdef SEN5X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SEN5X_I2C_CLOCK_SPEED */ return 0; @@ -198,7 +194,6 @@ uint8_t SEN5XSensor::readBuffer(uint8_t *buffer, uint8_t byteNumber) } #ifdef SEN5X_I2C_CLOCK_SPEED - LOG_DEBUG("%s: restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SEN5X_I2C_CLOCK_SPEED */ @@ -259,7 +254,7 @@ bool SEN5XSensor::idle(bool checkState) } if (!(vocStateStable() && vocValid)) { - LOG_INFO("%s: Not stopping measurement, vocState is not stable yet!", sensorName); + LOG_INFO("%s: Not stopping measurement, vocState not stable yet", sensorName); return true; } } @@ -268,7 +263,7 @@ bool SEN5XSensor::idle(bool checkState) } if (!oneShotMode) { - LOG_INFO("%s: Not stopping measurement, continuous mode!", sensorName); + LOG_INFO("%s: Not stopping measurement, continuous mode", sensorName); return true; } else { LOG_INFO("%s: One shot mode enabled", sensorName); @@ -367,19 +362,22 @@ bool SEN5XSensor::vocStateFromSensor() delay(20); // From Sensirion Datasheet - // Retrieve the data - // Allocate buffer to account for CRC - size_t receivedNumber = readBuffer(&vocState[0], SEN5X_VOC_STATE_BUFFER_SIZE + (SEN5X_VOC_STATE_BUFFER_SIZE / 2)); + // Retrieve the data into a staging buffer so a partial read (e.g. a CRC + // failure halfway through) cannot corrupt the current vocState. + // The requested size accounts for the CRC bytes + uint8_t stateBuffer[SEN5X_VOC_STATE_BUFFER_SIZE]{}; + size_t receivedNumber = readBuffer(&stateBuffer[0], SEN5X_VOC_STATE_BUFFER_SIZE + (SEN5X_VOC_STATE_BUFFER_SIZE / 2)); delay(20); // From Sensirion Datasheet - if (receivedNumber == 0) { + if (receivedNumber < SEN5X_VOC_STATE_BUFFER_SIZE) { LOG_DEBUG("%s: Error getting VOC's state", sensorName); return false; } + memcpy(vocState, stateBuffer, SEN5X_VOC_STATE_BUFFER_SIZE); // Print the state (if debug is on) - LOG_DEBUG("%s: VOC state retrieved from sensor: [%u, %u, %u, %u, %u, %u, %u, %u]", sensorName, vocState[0], vocState[1], - vocState[2], vocState[3], vocState[4], vocState[5], vocState[6], vocState[7]); + LOG_DEBUG("%s: VOC state from sensor: [%u, %u, %u, %u, %u, %u, %u, %u]", sensorName, vocState[0], vocState[1], vocState[2], + vocState[3], vocState[4], vocState[5], vocState[6], vocState[7]); return true; } @@ -433,6 +431,7 @@ bool SEN5XSensor::loadState() return okay; #else LOG_ERROR("%s: Filesystem not implemented", sensorName); + return false; #endif } @@ -473,11 +472,12 @@ bool SEN5XSensor::saveState() okay &= file.close(); if (okay) - LOG_INFO("%s: state write to %s successful", sensorName, sen5XStateFileName); + LOG_INFO("%s: state write to %s OK", sensorName, sen5XStateFileName); return okay; #else LOG_ERROR("%s: Filesystem not implemented", sensorName); + return false; #endif } @@ -489,7 +489,7 @@ bool SEN5XSensor::isActive() uint32_t SEN5XSensor::wakeUp() { - LOG_DEBUG("%s: Waking up sensor", sensorName); + LOG_TRACE("%s Waking", sensorName); if (!sendCommand(SEN5X_START_MEASUREMENT)) { LOG_ERROR("%s: Error starting measurement", sensorName); @@ -503,8 +503,7 @@ uint32_t SEN5XSensor::wakeUp() // keep track of how long it has passed pmMeasureStarted = getTime(); state = SEN5X_MEASUREMENT; - if (state == SEN5X_MEASUREMENT) - LOG_INFO("%s: Started measurement mode", sensorName); + LOG_INFO("%s: Started measurement mode", sensorName); return SEN5X_WARMUP_MS_1; } @@ -513,7 +512,7 @@ bool SEN5XSensor::vocStateStable() uint32_t now; now = getTime(); uint32_t sinceFirstMeasureStarted = (now - rhtGasMeasureStarted); - LOG_DEBUG("%s: sinceFirstMeasureStarted: %us", sensorName, sinceFirstMeasureStarted); + LOG_TRACE("%s: sinceFirstMeasureStarted: %us", sensorName, sinceFirstMeasureStarted); return sinceFirstMeasureStarted > SEN5X_VOC_STATE_WARMUP_S; } @@ -537,9 +536,9 @@ bool SEN5XSensor::startCleaning() delay(20); // From Sensirion Datasheet // This message will be always printed so the user knows the device it's not hung - LOG_INFO("%s: Started fan cleaning it will take 10 seconds...", sensorName); + LOG_INFO("%s: Started fan cleaning (10 sec)", sensorName); - uint16_t started = millis(); + uint32_t started = millis(); while (millis() - started < 10500) { delay(500); } @@ -586,7 +585,7 @@ bool SEN5XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) if (!getVersion()) return false; if (firmwareVer < 2) { - LOG_ERROR("%s: firmware is too old and will not work with this implementation", sensorName); + LOG_ERROR("%s: firmware too old, unsupported", sensorName); return false; } delay(200); // From Sensirion Datasheet @@ -611,12 +610,10 @@ bool SEN5XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) if (passed > ONE_WEEK_IN_SECONDS && (now > SEN5X_VOC_VALID_DATE)) { // If current date greater than 01/01/2018 (validity check) - LOG_INFO("%s: More than a week (%us) since last cleaning in epoch (%us). Trigger, cleaning...", sensorName, - passed, lastCleaning); + LOG_INFO("%s: Over a week (%us) since last cleaning (%us), trigger cleaning", sensorName, passed, lastCleaning); startCleaning(); } else { - LOG_INFO("%s: Cleaning not needed (%ds passed). Last cleaning date (in epoch): %us", sensorName, passed, - lastCleaning); + LOG_INFO("%s: Cleaning not needed (%ds passed), last cleaning: %us", sensorName, passed, lastCleaning); } } else { // We assume the device has just been updated or it is new, @@ -625,7 +622,7 @@ bool SEN5XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) // Otherwise, we will never trigger cleaning in some cases lastCleaning = now; lastCleaningValid = true; - LOG_INFO("%s: No valid last cleaning date found, saving it now: %us", sensorName, lastCleaning); + LOG_INFO("%s: No valid last cleaning date, saving now: %us", sensorName, lastCleaning); saveState(); } @@ -640,7 +637,7 @@ bool SEN5XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) LOG_INFO("%s: VOC state is valid and recent", sensorName); vocStateToSensor(); } else { - LOG_INFO("%s: VOC state is too old or date is invalid", sensorName); + LOG_INFO("%s: VOC state too old or date invalid", sensorName); LOG_DEBUG("%s: vocTime %u, Passed %u, and now %u", sensorName, vocTime, passed, now); } } @@ -663,12 +660,12 @@ bool SEN5XSensor::readValues() LOG_ERROR("%s: Error sending read command", sensorName); return false; } - LOG_DEBUG("%s: Reading PM Values", sensorName); + LOG_TRACE("%s: Reading PM Values", sensorName); delay(20); // From Sensirion Datasheet - uint8_t dataBuffer[16]{}; - size_t receivedNumber = readBuffer(&dataBuffer[0], 24); - if (receivedNumber == 0) { + uint8_t dataBuffer[SEN5X_READ_VALUES_BUFFER_SIZE]{}; + size_t receivedNumber = readBuffer(&dataBuffer[0], SEN5X_READ_VALUES_BUFFER_SIZE + (SEN5X_READ_VALUES_BUFFER_SIZE / 2)); + if (receivedNumber < SEN5X_READ_VALUES_BUFFER_SIZE) { LOG_ERROR("%s: Error getting values", sensorName); return false; } @@ -684,26 +681,28 @@ bool SEN5XSensor::readValues() int16_t int_vocIndex = static_cast((dataBuffer[12] << 8) | dataBuffer[13]); int16_t int_noxIndex = static_cast((dataBuffer[14] << 8) | dataBuffer[15]); - // Convert values based on Sensirion Arduino lib - sen5xmeasurement.pM1p0 = !isnan(uint_pM1p0) ? uint_pM1p0 / 10 : UINT16_MAX; - sen5xmeasurement.pM2p5 = !isnan(uint_pM2p5) ? uint_pM2p5 / 10 : UINT16_MAX; - sen5xmeasurement.pM4p0 = !isnan(uint_pM4p0) ? uint_pM4p0 / 10 : UINT16_MAX; - sen5xmeasurement.pM10p0 = !isnan(uint_pM10p0) ? uint_pM10p0 / 10 : UINT16_MAX; - sen5xmeasurement.humidity = !isnan(int_humidity) ? int_humidity / 100.0f : FLT_MAX; - sen5xmeasurement.temperature = !isnan(int_temperature) ? int_temperature / 200.0f : FLT_MAX; - sen5xmeasurement.vocIndex = !isnan(int_vocIndex) ? int_vocIndex / 10.0f : FLT_MAX; - sen5xmeasurement.noxIndex = !isnan(int_noxIndex) ? int_noxIndex / 10.0f : FLT_MAX; + // Convert values based on Sensirion Arduino lib. + // Map values the sensor reports as unavailable (SEN5X_UINT_INVALID / + // SEN5X_INT_INVALID) to the sentinels getMetrics() checks for + sen5xmeasurement.pM1p0 = (uint_pM1p0 != SEN5X_UINT_INVALID) ? (uint_pM1p0 / 10) : UINT16_MAX; + sen5xmeasurement.pM2p5 = (uint_pM2p5 != SEN5X_UINT_INVALID) ? (uint_pM2p5 / 10) : UINT16_MAX; + sen5xmeasurement.pM4p0 = (uint_pM4p0 != SEN5X_UINT_INVALID) ? (uint_pM4p0 / 10) : UINT16_MAX; + sen5xmeasurement.pM10p0 = (uint_pM10p0 != SEN5X_UINT_INVALID) ? (uint_pM10p0 / 10) : UINT16_MAX; + sen5xmeasurement.humidity = (int_humidity != SEN5X_INT_INVALID) ? (int_humidity / 100.0f) : FLT_MAX; + sen5xmeasurement.temperature = (int_temperature != SEN5X_INT_INVALID) ? (int_temperature / 200.0f) : FLT_MAX; + sen5xmeasurement.vocIndex = (int_vocIndex != SEN5X_INT_INVALID) ? (int_vocIndex / 10.0f) : FLT_MAX; + sen5xmeasurement.noxIndex = (int_noxIndex != SEN5X_INT_INVALID) ? (int_noxIndex / 10.0f) : FLT_MAX; - LOG_DEBUG("%s: Got readings: pM1p0=%u, pM2p5=%u, pM4p0=%u, pM10p0=%u", sensorName, sen5xmeasurement.pM1p0, + LOG_TRACE("%s: Got readings: pM1p0=%u, pM2p5=%u, pM4p0=%u, pM10p0=%u", sensorName, sen5xmeasurement.pM1p0, sen5xmeasurement.pM2p5, sen5xmeasurement.pM4p0, sen5xmeasurement.pM10p0); if (model != SEN50) { - LOG_DEBUG("%s: Got readings: humidity=%.2f, temperature=%.2f, vocIndex=%.2f", sensorName, sen5xmeasurement.humidity, + LOG_TRACE("%s: Got readings: humidity=%.2f, temperature=%.2f, vocIndex=%.2f", sensorName, sen5xmeasurement.humidity, sen5xmeasurement.temperature, sen5xmeasurement.vocIndex); } if (model == SEN55) { - LOG_DEBUG("%s: Got readings: noxIndex=%.2f", sensorName, sen5xmeasurement.noxIndex); + LOG_TRACE("%s: Got readings: noxIndex=%.2f", sensorName, sen5xmeasurement.noxIndex); } return true; @@ -716,12 +715,12 @@ bool SEN5XSensor::readPNValues(bool cumulative) return false; } - LOG_DEBUG("%s: Reading PN Values", sensorName); + LOG_TRACE("%s: Reading PN Values", sensorName); delay(20); // From Sensirion Datasheet - uint8_t dataBuffer[20]{}; - size_t receivedNumber = readBuffer(&dataBuffer[0], 30); - if (receivedNumber == 0) { + uint8_t dataBuffer[SEN5X_READ_PM_BUFFER_SIZE]{}; + size_t receivedNumber = readBuffer(&dataBuffer[0], SEN5X_READ_PM_BUFFER_SIZE + (SEN5X_READ_PM_BUFFER_SIZE / 2)); + if (receivedNumber < SEN5X_READ_PM_BUFFER_SIZE) { LOG_ERROR("%s: Error getting PN values", sensorName); return false; } @@ -738,25 +737,32 @@ bool SEN5XSensor::readPNValues(bool cumulative) uint16_t uint_pN10p0 = static_cast((dataBuffer[16] << 8) | dataBuffer[17]); uint16_t uint_tSize = static_cast((dataBuffer[18] << 8) | dataBuffer[19]); - // Convert values based on Sensirion Arduino lib - // Multiply by 100 for converting from #/cm3 to #/0.1l for PN values - sen5xmeasurement.pN0p5 = !isnan(uint_pN0p5) ? uint_pN0p5 / 10 * 100 : UINT32_MAX; - sen5xmeasurement.pN1p0 = !isnan(uint_pN1p0) ? uint_pN1p0 / 10 * 100 : UINT32_MAX; - sen5xmeasurement.pN2p5 = !isnan(uint_pN2p5) ? uint_pN2p5 / 10 * 100 : UINT32_MAX; - sen5xmeasurement.pN4p0 = !isnan(uint_pN4p0) ? uint_pN4p0 / 10 * 100 : UINT32_MAX; - sen5xmeasurement.pN10p0 = !isnan(uint_pN10p0) ? uint_pN10p0 / 10 * 100 : UINT32_MAX; - sen5xmeasurement.tSize = !isnan(uint_tSize) ? uint_tSize / 1000.0f : FLT_MAX; + // Convert values based on Sensirion Arduino lib. + // Raw PN values are #/cm3 with 0.1 resolution; multiplying by 10 + // converts to #/0.1l without the truncation of dividing first. + // Map values the sensor reports as unavailable (SEN5X_UINT_INVALID) to the + // sentinels getMetrics() checks for + sen5xmeasurement.pN0p5 = (uint_pN0p5 != SEN5X_UINT_INVALID) ? ((uint32_t)uint_pN0p5 * 10) : UINT32_MAX; + sen5xmeasurement.pN1p0 = (uint_pN1p0 != SEN5X_UINT_INVALID) ? ((uint32_t)uint_pN1p0 * 10) : UINT32_MAX; + sen5xmeasurement.pN2p5 = (uint_pN2p5 != SEN5X_UINT_INVALID) ? ((uint32_t)uint_pN2p5 * 10) : UINT32_MAX; + sen5xmeasurement.pN4p0 = (uint_pN4p0 != SEN5X_UINT_INVALID) ? ((uint32_t)uint_pN4p0 * 10) : UINT32_MAX; + sen5xmeasurement.pN10p0 = (uint_pN10p0 != SEN5X_UINT_INVALID) ? ((uint32_t)uint_pN10p0 * 10) : UINT32_MAX; + sen5xmeasurement.tSize = (uint_tSize != SEN5X_UINT_INVALID) ? (uint_tSize / 1000.0f) : FLT_MAX; // Remove accumuluative values: // https://github.com/fablabbcn/smartcitizen-kit-2x/issues/85 if (!cumulative) { - sen5xmeasurement.pN10p0 -= sen5xmeasurement.pN4p0; - sen5xmeasurement.pN4p0 -= sen5xmeasurement.pN2p5; - sen5xmeasurement.pN2p5 -= sen5xmeasurement.pN1p0; - sen5xmeasurement.pN1p0 -= sen5xmeasurement.pN0p5; + if (sen5xmeasurement.pN10p0 != UINT32_MAX && sen5xmeasurement.pN4p0 != UINT32_MAX) + sen5xmeasurement.pN10p0 -= sen5xmeasurement.pN4p0; + if (sen5xmeasurement.pN4p0 != UINT32_MAX && sen5xmeasurement.pN2p5 != UINT32_MAX) + sen5xmeasurement.pN4p0 -= sen5xmeasurement.pN2p5; + if (sen5xmeasurement.pN2p5 != UINT32_MAX && sen5xmeasurement.pN1p0 != UINT32_MAX) + sen5xmeasurement.pN2p5 -= sen5xmeasurement.pN1p0; + if (sen5xmeasurement.pN1p0 != UINT32_MAX && sen5xmeasurement.pN0p5 != UINT32_MAX) + sen5xmeasurement.pN1p0 -= sen5xmeasurement.pN0p5; } - LOG_DEBUG("%s: Got readings: pN0p5=%u, pN1p0=%u, pN2p5=%u, pN4p0=%u, pN10p0=%u, tSize=%.2f", sensorName, + LOG_TRACE("%s: Got readings: pN0p5=%u, pN1p0=%u, pN2p5=%u, pN4p0=%u, pN10p0=%u, tSize=%.2f", sensorName, sen5xmeasurement.pN0p5, sen5xmeasurement.pN1p0, sen5xmeasurement.pN2p5, sen5xmeasurement.pN4p0, sen5xmeasurement.pN10p0, sen5xmeasurement.tSize); @@ -775,10 +781,10 @@ uint8_t SEN5XSensor::getMeasurements() } delay(20); // From Sensirion Datasheet - uint8_t dataReadyBuffer[3]; - size_t charNumber = readBuffer(&dataReadyBuffer[0], 3); - if (charNumber == 0) { - LOG_ERROR("%s: Error getting device version value", sensorName); + uint8_t dataReadyBuffer[SEN5X_DATA_READY_BUFFER_SIZE]{}; + size_t charNumber = readBuffer(&dataReadyBuffer[0], SEN5X_DATA_READY_BUFFER_SIZE + (SEN5X_DATA_READY_BUFFER_SIZE / 2)); + if (charNumber < SEN5X_DATA_READY_BUFFER_SIZE) { + LOG_ERROR("%s: Error getting data ready flag value", sensorName); return 2; } @@ -815,13 +821,13 @@ int32_t SEN5XSensor::pendingForReadyMs() uint32_t now; now = getTime(); uint32_t sincePmMeasureStarted = (now - pmMeasureStarted) * 1000; - LOG_DEBUG("%s: Since measure started: %ums", sensorName, sincePmMeasureStarted); + LOG_TRACE("%s: Since measure started: %ums", sensorName, sincePmMeasureStarted); switch (state) { case SEN5X_MEASUREMENT: { if (sincePmMeasureStarted < SEN5X_WARMUP_MS_1) { - LOG_INFO("%s: not enough time passed since starting measurement", sensorName); + LOG_INFO("%s: not enough time since measurement start", sensorName); return SEN5X_WARMUP_MS_1 - sincePmMeasureStarted; } @@ -835,7 +841,7 @@ int32_t SEN5XSensor::pendingForReadyMs() // If the reading is low (the tyhreshold is in #/cm3) and second warmUp hasn't passed we return to come back later if ((sen5xmeasurement.pN4p0 / 100) < SEN5X_PN4P0_CONC_THD && sincePmMeasureStarted < SEN5X_WARMUP_MS_2) { - LOG_INFO("%s: Concentration is low, we will ask again in the second warm up period", sensorName); + LOG_INFO("%s: Concentration low, will ask again in second warm up period", sensorName); state = SEN5X_MEASUREMENT_2; // Report how many seconds are pending to cover the first warm up period return SEN5X_WARMUP_MS_2 - sincePmMeasureStarted; @@ -857,9 +863,9 @@ int32_t SEN5XSensor::pendingForReadyMs() bool SEN5XSensor::getMetrics(meshtastic_Telemetry *measurement) { - LOG_INFO("%s: Attempting to get metrics", sensorName); + LOG_INFO("%s: Get metrics", sensorName); if (!isActive()) { - LOG_INFO("%s: not in measurement mode", sensorName); + LOG_INFO("%s: Not in measurement mode", sensorName); return false; } @@ -917,7 +923,7 @@ bool SEN5XSensor::getMetrics(meshtastic_Telemetry *measurement) measurement->variant.air_quality_metrics.has_pm_temperature = true; measurement->variant.air_quality_metrics.pm_temperature = sen5xmeasurement.temperature; } - if (sen5xmeasurement.noxIndex != FLT_MAX) { + if (sen5xmeasurement.vocIndex != FLT_MAX) { measurement->variant.air_quality_metrics.has_pm_voc_idx = true; measurement->variant.air_quality_metrics.pm_voc_idx = sen5xmeasurement.vocIndex; } @@ -949,9 +955,9 @@ void SEN5XSensor::setMode(bool setOneShot) { oneShotMode = setOneShot; if (oneShotMode) { - LOG_INFO("%s: setting mode to one shot mode", sensorName); + LOG_INFO("%s: set one shot mode", sensorName); } else { - LOG_INFO("%s: setting mode to continuous mode", sensorName); + LOG_INFO("%s: set continuous mode", sensorName); } } diff --git a/src/modules/Telemetry/Sensor/SEN5XSensor.h b/src/modules/Telemetry/Sensor/SEN5XSensor.h index 5d84b89169..eeebbd3735 100644 --- a/src/modules/Telemetry/Sensor/SEN5XSensor.h +++ b/src/modules/Telemetry/Sensor/SEN5XSensor.h @@ -86,6 +86,18 @@ class SEN5XSensor : public TelemetrySensor #define SEN5X_READ_RAW_VALUES 0x03D2 #define SEN5X_READ_PM_VALUES 0x0413 +// Values the sensor reports when a reading is unavailable +#define SEN5X_UINT_INVALID 0xFFFF +#define SEN5X_INT_INVALID 0x7FFF + +// Reply payload sizes in data bytes; the raw I2C transfer adds one CRC byte +// per 2-byte group, so requests are + / 2 raw bytes +#define SEN5X_VERSION_BUFFER_SIZE 8 +#define SEN5X_PRODUCT_NAME_BUFFER_SIZE 32 +#define SEN5X_DATA_READY_BUFFER_SIZE 2 +#define SEN5X_READ_VALUES_BUFFER_SIZE 16 +#define SEN5X_READ_PM_BUFFER_SIZE 20 + #define SEN5X_VOC_VALID_TIME 600 #define SEN5X_VOC_VALID_DATE 1514764800 @@ -114,8 +126,23 @@ See: https://sensirion.com/resource/application_note/low_power_mode/sen5x #define SEN5X_PN4P0_CONC_THD 100 bool sendCommand(uint16_t command); + /** + * @brief Send a command word followed by a data payload; a CRC byte is + * computed and inserted on the wire after every 2-byte pair. + * @param command 16-bit command code, sent big-endian + * @param buffer payload data bytes, without CRCs + * @param byteNumber payload size in data bytes; must be even + * @return true when the full transfer is written and acknowledged + */ bool sendCommand(uint16_t command, uint8_t *buffer, uint8_t byteNumber = 0); - uint8_t readBuffer(uint8_t *buffer, uint8_t byteNumber); // Return number of bytes received + /** + * @brief Read a reply, verifying and stripping the interleaved CRC bytes. + * @param buffer destination for the data bytes (byteNumber * 2 / 3 of them) + * @param byteNumber raw transfer size including CRCs; must be a multiple + * of 3 (2 data bytes + 1 CRC per group) + * @return the number of data bytes written to buffer, or 0 on any error + */ + uint8_t readBuffer(uint8_t *buffer, uint8_t byteNumber); uint8_t sen5xCRC(const uint8_t *buffer); bool startCleaning(); uint8_t getMeasurements(); diff --git a/src/modules/Telemetry/Sensor/SFA30Sensor.cpp b/src/modules/Telemetry/Sensor/SFA30Sensor.cpp index 5befb44748..aa19baf0fa 100644 --- a/src/modules/Telemetry/Sensor/SFA30Sensor.cpp +++ b/src/modules/Telemetry/Sensor/SFA30Sensor.cpp @@ -17,8 +17,6 @@ bool SFA30Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) #ifdef SFA30_I2C_CLOCK_SPEED _port = dev->address.port; reClockI2C.setup(_bus, _port); - - LOG_INFO("%s attempting to reclock speed to %uHz", sensorName, SFA30_I2C_CLOCK_SPEED); reClockI2C.setClock(SFA30_I2C_CLOCK_SPEED); #endif /* SFA30_I2C_CLOCK_SPEED */ @@ -27,7 +25,6 @@ bool SFA30Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) if (this->isError(sfa30.deviceReset())) { #ifdef SFA30_I2C_CLOCK_SPEED - LOG_INFO("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ return false; @@ -36,7 +33,6 @@ bool SFA30Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) state = State::IDLE; if (this->isError(sfa30.startContinuousMeasurement())) { #ifdef SFA30_I2C_CLOCK_SPEED - LOG_INFO("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ return false; @@ -45,14 +41,13 @@ bool SFA30Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) LOG_INFO("%s starting measurement", sensorName); #ifdef SFA30_I2C_CLOCK_SPEED - LOG_INFO("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ status = 1; state = State::ACTIVE; measureStarted = getTime(); - LOG_INFO("%s Enabled", sensorName); + LOG_INFO("%s: Enabled", sensorName); initI2CSensor(); return true; @@ -71,17 +66,15 @@ bool SFA30Sensor::isError(uint16_t response) void SFA30Sensor::sleep() { #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s attempting to reclock speed to %uHz", sensorName, SFA30_I2C_CLOCK_SPEED); reClockI2C.setClock(SFA30_I2C_CLOCK_SPEED); #endif /* SFA30_I2C_CLOCK_SPEED */ // Note - not recommended for this sensor on a periodic basis if (this->isError(sfa30.stopMeasurement())) { - LOG_ERROR("%s: can't stop measurement", sensorName); + LOG_ERROR("%s: Can't stop measurement", sensorName); }; #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ @@ -93,21 +86,18 @@ void SFA30Sensor::sleep() uint32_t SFA30Sensor::wakeUp() { #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s attempting to reclock speed to %uHz", sensorName, SFA30_I2C_CLOCK_SPEED); reClockI2C.setClock(SFA30_I2C_CLOCK_SPEED); #endif /* SFA30_I2C_CLOCK_SPEED */ - LOG_DEBUG("Waking up %s", sensorName); + LOG_DEBUG("Waking %s", sensorName); if (this->isError(sfa30.startContinuousMeasurement())) { #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ return 0; } #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ @@ -154,21 +144,18 @@ bool SFA30Sensor::getMetrics(meshtastic_Telemetry *measurement) float temperature = 0.0; #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s attempting to reclock speed to %uHz", sensorName, SFA30_I2C_CLOCK_SPEED); reClockI2C.setClock(SFA30_I2C_CLOCK_SPEED); #endif /* SFA30_I2C_CLOCK_SPEED */ if (this->isError(sfa30.readMeasuredValues(hcho, humidity, temperature))) { LOG_WARN("%s: No values", sensorName); #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ return false; } #ifdef SFA30_I2C_CLOCK_SPEED - LOG_DEBUG("%s restoring clock speed", sensorName); reClockI2C.restoreClock(); #endif /* SFA30_I2C_CLOCK_SPEED */ diff --git a/src/modules/Telemetry/Sensor/SHTXXSensor.cpp b/src/modules/Telemetry/Sensor/SHTXXSensor.cpp index 92cac7f777..1512e7cc8c 100644 --- a/src/modules/Telemetry/Sensor/SHTXXSensor.cpp +++ b/src/modules/Telemetry/Sensor/SHTXXSensor.cpp @@ -50,12 +50,12 @@ bool SHTXXSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) _address = dev->address.address; if (sht.init(*_bus)) { - LOG_INFO("%s: init(): success", sensorName); + LOG_INFO("%s init success", sensorName); getSensorVariant(sht.mSensorType); LOG_INFO("%s Sensor detected: %s on 0x%x", sensorName, sensorVariant, _address); status = 1; } else { - LOG_ERROR("%s: init(): failed", sensorName); + LOG_ERROR("%s init failed", sensorName); } initI2CSensor(); diff --git a/src/modules/TraceRouteModule.cpp b/src/modules/TraceRouteModule.cpp index 4d3819f12e..310cf4bc1b 100644 --- a/src/modules/TraceRouteModule.cpp +++ b/src/modules/TraceRouteModule.cpp @@ -310,7 +310,7 @@ void TraceRouteModule::updateNextHops(const meshtastic_MeshPacket &p, meshtastic // point any node's next_hop anywhere. relay_node is 0 for MQTT-sourced packets, which cannot // corroborate an RF route either. if (p.relay_node == NO_RELAY_NODE || nextHopByte != p.relay_node) { - LOG_DEBUG("Ignore traceroute next-hop 0x%02x, packet was relayed by 0x%02x", nextHopByte, p.relay_node); + LOG_DEBUG("Ignore traceroute next-hop 0x%02x, relayed by 0x%02x", nextHopByte, p.relay_node); return; } @@ -333,7 +333,7 @@ void TraceRouteModule::maybeSetNextHop(NodeNum target, uint8_t nextHopByte) meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(target); if (node && node->next_hop != nextHopByte) { - LOG_INFO("Updating next-hop for 0x%08x to 0x%02x based on traceroute", target, nextHopByte); + LOG_INFO("Update next-hop for 0x%08x to 0x%02x via traceroute", target, nextHopByte); node->next_hop = nextHopByte; } @@ -437,7 +437,7 @@ void TraceRouteModule::appendMyIDandSNR(meshtastic_RouteDiscovery *updated, floa route[*route_count] = myNodeInfo.my_node_num; *route_count += 1; } else { - LOG_WARN("Route exceeded maximum hop limit!"); // Are you bridging networks? + LOG_WARN("Route exceeded max hop limit"); // Are you bridging networks? } } @@ -533,11 +533,11 @@ const char *TraceRouteModule::getNodeName(NodeNum node) bool TraceRouteModule::startTraceRoute(NodeNum node) { - LOG_INFO("=== TraceRoute startTraceRoute CALLED: node=0x%08x ===", node); + LOG_INFO("TraceRoute startTraceRoute: node=0x%08x", node); unsigned long now = millis(); if (node == 0 || node == NODENUM_BROADCAST) { - LOG_ERROR("Invalid node number for trace route: 0x%08x", node); + LOG_ERROR("Invalid trace route node: 0x%08x", node); runState = TRACEROUTE_STATE_RESULT; setResultText("Invalid node"); resultShowTime = millis(); @@ -551,7 +551,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) } if (node == nodeDB->getNodeNum()) { - LOG_ERROR("Cannot trace route to self: 0x%08x", node); + LOG_ERROR("Can't trace route to self: 0x%08x", node); runState = TRACEROUTE_STATE_RESULT; setResultText("Cannot trace self"); resultShowTime = millis(); @@ -567,7 +567,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) if (!initialized) { lastTraceRouteTime = 0; initialized = true; - LOG_INFO("TraceRoute initialized for first time"); + LOG_INFO("TraceRoute first init"); } if (runState == TRACEROUTE_STATE_TRACKING) { @@ -587,7 +587,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) UIFrameEvent e; e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; notifyObservers(&e); - LOG_INFO("Cooldown active, please wait %lu seconds before starting a new trace route.", wait); + LOG_INFO("Cooldown active, wait %lu sec before new trace route", wait); return false; } @@ -598,7 +598,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) clearResultLines(); bannerText = String("Tracing ") + getNodeName(node); - LOG_INFO("TraceRoute UI: Starting trace route to node 0x%08x, requesting focus", node); + LOG_INFO("TraceRoute UI: Start trace to 0x%08x, request focus", node); // 请求焦点，然后触发UI更新事件 requestFocus(); @@ -610,7 +610,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) setIntervalFromNow(1000); // 每秒检查一次状态 meshtastic_RouteDiscovery req = meshtastic_RouteDiscovery_init_zero; - LOG_INFO("Creating RouteDiscovery protobuf..."); + LOG_INFO("Creating RouteDiscovery protobuf"); // Allocate a packet directly from router like the reference code meshtastic_MeshPacket *p = router->allocForSending(); @@ -627,16 +627,16 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) p->decoded.payload.size = pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_RouteDiscovery_msg, &req); - LOG_INFO("Packet allocated successfully: to=0x%08x, portnum=%d, want_response=%d, payload_size=%d", p->to, - p->decoded.portnum, p->decoded.want_response, p->decoded.payload.size); - LOG_INFO("About to call service->sendToMesh..."); + LOG_INFO("Packet allocated: to=0x%08x, portnum=%d, want_response=%d, payload_size=%d", p->to, p->decoded.portnum, + p->decoded.want_response, p->decoded.payload.size); + LOG_INFO("Calling service->sendToMesh"); if (service) { - LOG_INFO("MeshService is available, sending packet..."); + LOG_INFO("MeshService is available, sending packet"); service->sendToMesh(p, RX_SRC_USER); - LOG_INFO("sendToMesh called successfully for trace route to node 0x%08x", node); + LOG_INFO("sendToMesh called for trace route to node 0x%08x", node); } else { - LOG_ERROR("MeshService is NULL!"); + LOG_ERROR("MeshService is NULL"); runState = TRACEROUTE_STATE_RESULT; setResultText("Service unavailable"); resultShowTime = millis(); @@ -649,7 +649,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) return false; } } else { - LOG_ERROR("Failed to allocate TraceRoute packet from router"); + LOG_ERROR("TraceRoute packet alloc from router failed"); runState = TRACEROUTE_STATE_RESULT; setResultText("Failed to send"); resultShowTime = millis(); @@ -667,7 +667,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node) void TraceRouteModule::launch(NodeNum node) { if (node == 0 || node == NODENUM_BROADCAST) { - LOG_ERROR("Invalid node number for trace route: 0x%08x", node); + LOG_ERROR("Invalid trace route node: 0x%08x", node); runState = TRACEROUTE_STATE_RESULT; setResultText("Invalid node"); resultShowTime = millis(); @@ -681,7 +681,7 @@ void TraceRouteModule::launch(NodeNum node) } if (node == nodeDB->getNodeNum()) { - LOG_ERROR("Cannot trace route to self: 0x%08x", node); + LOG_ERROR("Can't trace route to self: 0x%08x", node); runState = TRACEROUTE_STATE_RESULT; setResultText("Cannot trace self"); resultShowTime = millis(); @@ -697,7 +697,7 @@ void TraceRouteModule::launch(NodeNum node) if (!initialized) { lastTraceRouteTime = 0; initialized = true; - LOG_INFO("TraceRoute initialized for first time"); + LOG_INFO("TraceRoute first init"); } unsigned long now = millis(); @@ -712,7 +712,7 @@ void TraceRouteModule::launch(NodeNum node) UIFrameEvent e; e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; notifyObservers(&e); - LOG_INFO("Cooldown active, please wait %lu seconds before starting a new trace route.", wait); + LOG_INFO("Cooldown active, wait %lu sec before new trace route", wait); return; } @@ -732,7 +732,7 @@ void TraceRouteModule::launch(NodeNum node) setIntervalFromNow(1000); meshtastic_RouteDiscovery req = meshtastic_RouteDiscovery_init_zero; - LOG_INFO("Creating RouteDiscovery protobuf..."); + LOG_INFO("Creating RouteDiscovery protobuf"); meshtastic_MeshPacket *p = router->allocForSending(); if (p) { @@ -746,21 +746,21 @@ void TraceRouteModule::launch(NodeNum node) p->decoded.payload.size = pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_RouteDiscovery_msg, &req); - LOG_INFO("Packet allocated successfully: to=0x%08x, portnum=%d, want_response=%d, payload_size=%d", p->to, - p->decoded.portnum, p->decoded.want_response, p->decoded.payload.size); + LOG_INFO("Packet allocated: to=0x%08x, portnum=%d, want_response=%d, payload_size=%d", p->to, p->decoded.portnum, + p->decoded.want_response, p->decoded.payload.size); if (service) { service->sendToMesh(p, RX_SRC_USER); - LOG_INFO("sendToMesh called successfully for trace route to node 0x%08x", node); + LOG_INFO("sendToMesh called for trace route to node 0x%08x", node); } else { - LOG_ERROR("MeshService is NULL!"); + LOG_ERROR("MeshService is NULL"); runState = TRACEROUTE_STATE_RESULT; setResultText("Service unavailable"); resultShowTime = millis(); tracingNode = 0; } } else { - LOG_ERROR("Failed to allocate TraceRoute packet from router"); + LOG_ERROR("TraceRoute packet alloc from router failed"); runState = TRACEROUTE_STATE_RESULT; setResultText("Failed to send"); resultShowTime = millis(); @@ -775,7 +775,7 @@ void TraceRouteModule::handleTraceRouteResult(const String &result) resultShowTime = millis(); tracingNode = 0; - LOG_INFO("TraceRoute result ready, requesting focus. Result: %s", result.c_str()); + LOG_INFO("TraceRoute result ready, request focus: %s", result.c_str()); setIntervalFromNow(1000); @@ -784,7 +784,7 @@ void TraceRouteModule::handleTraceRouteResult(const String &result) e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; notifyObservers(&e); - LOG_INFO("=== TraceRoute handleTraceRouteResult END ==="); + LOG_INFO("TraceRoute handleTraceRouteResult END"); } bool TraceRouteModule::shouldDraw() @@ -850,7 +850,7 @@ int32_t TraceRouteModule::runOnce() // Check for tracking timeout if (runState == TRACEROUTE_STATE_TRACKING && now - lastTraceRouteTime > trackingTimeoutMs) { - LOG_INFO("TraceRoute timeout, no response received"); + LOG_INFO("TraceRoute timeout, no response"); runState = TRACEROUTE_STATE_RESULT; setResultText("No response received"); resultShowTime = now; @@ -886,7 +886,7 @@ int32_t TraceRouteModule::runOnce() return 1000; } else { // Cooldown finished - LOG_INFO("TraceRoute cooldown finished, returning to IDLE"); + LOG_INFO("TraceRoute cooldown done, return to IDLE"); runState = TRACEROUTE_STATE_IDLE; resultText = ""; clearResultLines(); diff --git a/src/modules/TrafficManagementModule.cpp b/src/modules/TrafficManagementModule.cpp index 50cc81e3fa..b4c5fae98e 100644 --- a/src/modules/TrafficManagementModule.cpp +++ b/src/modules/TrafficManagementModule.cpp @@ -19,6 +19,7 @@ #include #include +#define TM_LOG_TRACE(fmt, ...) LOG_TRACE("[TM] " fmt, ##__VA_ARGS__) #define TM_LOG_DEBUG(fmt, ...) LOG_DEBUG("[TM] " fmt, ##__VA_ARGS__) #define TM_LOG_INFO(fmt, ...) LOG_INFO("[TM] " fmt, ##__VA_ARGS__) #define TM_LOG_WARN(fmt, ...) LOG_WARN("[TM] " fmt, ##__VA_ARGS__) @@ -148,7 +149,7 @@ TrafficManagementModule::TrafficManagementModule() : MeshModule("TrafficManageme if (cache) { cacheFromPsram = true; } else { - TM_LOG_WARN("PSRAM allocation failed, falling back to heap"); + TM_LOG_WARN("PSRAM alloc failed, fall back to heap"); cache = new UnifiedCacheEntry[allocSize](); } #else @@ -171,7 +172,7 @@ TrafficManagementModule::TrafficManagementModule() : MeshModule("TrafficManageme nodeInfoPayloadFromPsram = true; TM_LOG_INFO("NodeInfo PSRAM cache ready"); } else { - TM_LOG_WARN("NodeInfo PSRAM payload allocation failed; direct responses will fall back to NodeDB"); + TM_LOG_WARN("NodeInfo PSRAM payload alloc failed; direct responses fall back to NodeDB"); } #else // Native unit-test build (see TMM_HAS_NODEINFO_CACHE): plain heap, so the cache paths @@ -634,7 +635,7 @@ void TrafficManagementModule::maintainNodeInfoCacheLocked() // O(entries x members) every 60 s under cacheLock. The hourly reconcile pass // owns it (see reconcileNodeInfoFromNodeDBLocked). } - TM_LOG_DEBUG("NodeInfo cache: %u/%u (%u went stale)", static_cast(countNodeInfoEntriesLocked()), + TM_LOG_TRACE("NodeInfo cache: %u/%u (%u went stale)", static_cast(countNodeInfoEntriesLocked()), static_cast(nodeInfoTargetEntries()), static_cast(nodeInfoSaturated)); // Anti-entropy: seed identities NodeDB knows but this cache lacks - a full pass at @@ -1323,7 +1324,7 @@ int32_t TrafficManagementModule::runOnce() } } - TM_LOG_DEBUG("Maintenance: %u active, %u expired, %u/%u slots, %lums elapsed", activeEntries, expiredEntries, + TM_LOG_TRACE("Maintenance: %u active, %u expired, %u/%u slots, %lums elapsed", activeEntries, expiredEntries, static_cast(activeEntries), static_cast(cacheSize()), static_cast(TrafficManagementModule::clockMs() - sweepStartMs)); @@ -1400,7 +1401,7 @@ bool TrafficManagementModule::shouldDropPosition(const meshtastic_MeshPacket *p, const bool withinInterval = hasPositionState && (windowTicks != 0) && (static_cast(nowPosTick - entry->pos_time) < windowTicks); - TM_LOG_DEBUG("Position dedup 0x%08x: fp=0x%02x prev=0x%02x same=%d within=%d new=%d", p->from, fingerprint, + TM_LOG_TRACE("Position dedup 0x%08x: fp=0x%02x prev=0x%02x same=%d within=%d new=%d", p->from, fingerprint, entry->pos_fingerprint, samePosition, withinInterval, isNew); // Update cache entry (raw tick; 0 is a valid tick value) @@ -1515,7 +1516,7 @@ bool TrafficManagementModule::shouldRespondToNodeInfo(const meshtastic_MeshPacke // request declined above never spends the budget). false forwards the request instead of consuming // it. Rationale in docs/traffic_management_module.md "Throttling direct responses". if (!directResponseAllowed(getFrom(p), p->to, clockMs())) { - TM_LOG_DEBUG("NodeInfo direct response throttled for 0x%08x; forwarding request instead", getFrom(p)); + TM_LOG_DEBUG("NodeInfo direct response throttled for 0x%08x; forwarding request", getFrom(p)); return false; } diff --git a/src/modules/esp32/PaxcounterModule.cpp b/src/modules/esp32/PaxcounterModule.cpp index db38165c6e..d9135c3a2f 100644 --- a/src/modules/esp32/PaxcounterModule.cpp +++ b/src/modules/esp32/PaxcounterModule.cpp @@ -24,7 +24,7 @@ static void startWifiChannelTimer(uint16_t wifi_channel_switch_interval) WifiChanTimer = xTimerCreate("WifiChannelTimer", pdMS_TO_TICKS(wifi_channel_switch_interval * 10), pdTRUE, (void *)0, switchWifiChannel); if (!WifiChanTimer) { - LOG_WARN("Paxcounter could not create WiFi channel switch timer"); + LOG_WARN("Paxcounter can't create WiFi channel switch timer"); return; } xTimerStart(WifiChanTimer, 0); @@ -34,7 +34,7 @@ static void ensureDefaultEventLoop() { esp_err_t result = esp_event_loop_create_default(); if (result != ESP_OK && result != ESP_ERR_INVALID_STATE) { - LOG_WARN("Paxcounter could not create ESP event loop: %d", result); + LOG_WARN("Paxcounter can't create ESP event loop: %d", result); } } diff --git a/src/motion/MagnetometerThread.h b/src/motion/MagnetometerThread.h index 1f558eb574..cf632867da 100644 --- a/src/motion/MagnetometerThread.h +++ b/src/motion/MagnetometerThread.h @@ -67,9 +67,11 @@ class MagnetometerThread : public concurrency::OSThread } switch (device.type) { +#if __has_include() case ScanI2C::DeviceType::MMC5983MA: sensor = new MMC5983MASensor(device); break; +#endif default: disable(); return; diff --git a/src/motion/MotionSensor.cpp b/src/motion/MotionSensor.cpp index b1744ad923..6cbe8e21db 100755 --- a/src/motion/MotionSensor.cpp +++ b/src/motion/MotionSensor.cpp @@ -259,8 +259,11 @@ void MotionSensor::drawFrameCalibration(OLEDDisplay *display, OLEDDisplayUiState const uint32_t now = millis(); const uint32_t endCalibrationAt = screen->getEndCalibration(); uint32_t timeRemaining = 0; - if (endCalibrationAt > now) { - timeRemaining = (endCalibrationAt - now + 999) / 1000; + // Signed delta, as in finishCalibrationIfExpired(): this needs the remaining magnitude, not + // just whether the deadline passed, so it cannot use Throttle::deadlinePassed(). + const int32_t remainingMs = (int32_t)(endCalibrationAt - now); + if (remainingMs > 0) { + timeRemaining = ((uint32_t)remainingMs + 999) / 1000; } int16_t compassX = 0, compassY = 0; diff --git a/src/mqtt/MQTT.cpp b/src/mqtt/MQTT.cpp index 6427b4c315..6bd2f3688f 100644 --- a/src/mqtt/MQTT.cpp +++ b/src/mqtt/MQTT.cpp @@ -89,7 +89,7 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length) { const DecodedServiceEnvelope e(payload, length); if (!e.validDecode || e.channel_id == NULL || e.gateway_id == NULL || e.packet == NULL) { - LOG_ERROR("Invalid MQTT service envelope, topic %s, len %u!", topic, length); + LOG_ERROR("Invalid MQTT service envelope, topic %s, len %u", topic, length); return; } @@ -127,12 +127,12 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length) if (router->sendLocal(pAck) == ERRNO_SHOULD_RELEASE) packetPool.release(pAck); } else { - LOG_INFO("Ignore downlink message we originally sent"); + LOG_INFO("Ignore downlink msg we sent"); } return; } if (isFromUs(e.packet)) { - LOG_INFO("Ignore downlink message we originally sent"); + LOG_INFO("Ignore downlink msg we sent"); return; } @@ -163,7 +163,7 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length) if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) { if (moduleConfig.mqtt.encryption_enabled) { - LOG_INFO("Ignore decoded message on MQTT, encryption is enabled"); + LOG_INFO("Ignore decoded msg on MQTT, encryption enabled"); return; } if (p->decoded.portnum == meshtastic_PortNum_ADMIN_APP) { @@ -179,7 +179,7 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length) // (perhapsDecode) does - checkXeddsaReceivePolicy -> xeddsa_verify mutates shared // CryptoEngine cache state, and MQTT ingress can run on a different task. if (passesRoutingAuthGate(p.get()) != RoutingAuthVerdict::ACCEPT) { - LOG_INFO("Ignore decoded message failing XEdDSA policy"); + LOG_INFO("Ignore decoded msg failing XEdDSA policy"); return; } #endif @@ -281,8 +281,8 @@ bool connectPubSub(const PubSubConfig &config, PubSubClient &pubSub, Client &cli pubSub.setClient(client); pubSub.setServer(config.serverAddr.c_str(), config.serverPort); - LOG_INFO("Connecting directly to MQTT server %s, port: %d, username: %s, password: ***", config.serverAddr.c_str(), - config.serverPort, config.mqttUsername); + LOG_INFO("Direct MQTT connect %s, port %d, user %s, password ***", config.serverAddr.c_str(), config.serverPort, + config.mqttUsername); // Generate node ID from nodenum for client identification std::string nodeId = nodeDB->getNodeId(); @@ -292,7 +292,7 @@ bool connectPubSub(const PubSubConfig &config, PubSubClient &pubSub, Client &cli LOG_INFO("MQTT connected"); } else { isConnected = false; - LOG_WARN("Failed to connect to MQTT server"); + LOG_WARN("MQTT server connect failed"); } return connected; } @@ -347,7 +347,7 @@ void MQTT::onClientProxyReceive(meshtastic_MqttClientProxyMessage msg) strnlen(msg.payload_variant.text, sizeof(msg.payload_variant.text))); break; default: - LOG_WARN("MQTT proxy message carries no payload, topic %s", msg.topic); + LOG_WARN("MQTT proxy msg has no payload, topic %s", msg.topic); break; } } @@ -355,7 +355,7 @@ void MQTT::onClientProxyReceive(meshtastic_MqttClientProxyMessage msg) void MQTT::onReceive(char *topic, byte *payload, size_t length) { if (length == 0) { - LOG_WARN("Empty MQTT payload received, topic %s!", topic); + LOG_WARN("Empty MQTT payload, topic %s", topic); return; } @@ -413,7 +413,7 @@ MQTT::MQTT() : concurrency::OSThread("mqtt"), mqttQueue(MAX_MQTT_QUEUE) #endif if (moduleConfig.mqtt.proxy_to_client_enabled) { - LOG_INFO("MQTT configured to use client proxy"); + LOG_INFO("MQTT uses client proxy"); enabled = true; runASAP = true; reconnectCount = 0; @@ -520,16 +520,16 @@ void MQTT::reconnect() } else { #if HAS_WIFI && !defined(ARCH_PORTDUINO) reconnectCount++; - LOG_ERROR("Failed to contact MQTT server directly (%d/%d)", reconnectCount, reconnectMax); + LOG_ERROR("Direct MQTT contact failed (%d/%d)", reconnectCount, reconnectMax); if (reconnectCount >= reconnectMax) { #if defined(USE_WS5500) || defined(USE_CH390D) - LOG_WARN("MQTT connect failed repeatedly; waiting for Ethernet reconnect"); + LOG_WARN("MQTT connect keeps failing; wait for Ethernet reconnect"); #else needReconnect = true; if (wifiReconnect) { wifiReconnect->setIntervalFromNow(0); } else { - LOG_WARN("MQTT connect failed repeatedly, but WiFi reconnect is unavailable"); + LOG_WARN("MQTT connect keeps failing, WiFi reconnect unavailable"); } #endif reconnectCount = 0; @@ -615,7 +615,7 @@ bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTC #if HAS_NETWORKING if (config.tls_enabled) { #if !MQTT_SUPPORTS_TLS - LOG_ERROR("Invalid MQTT config: tls_enabled is not supported on this node"); + LOG_ERROR("Invalid MQTT config: tls_enabled unsupported on this node"); return false; #endif } @@ -700,6 +700,12 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me { if (mp_encrypted.via_mqtt) return; // Don't send messages that came from MQTT back into MQTT +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL + if (isBlockedEventCoordinatePacket(&mp_decoded)) { + LOG_DEBUG("MQTT onSend - Suppress coordinate packet on event channel"); + return; + } +#endif bool uplinkEnabled = false; for (int i = 0; i <= 7; i++) { if (channels.getByIndex(i).settings.uplink_enabled) @@ -715,13 +721,13 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me bool dontUplink = !mp_decoded.decoded.has_bitfield || !(mp_decoded.decoded.bitfield & BITFIELD_OK_TO_MQTT_MASK); // Respect the DontMqttMeBro flag for other nodes' packets on public MQTT servers if (!isFromUs(&mp_decoded) && !isMqttServerAddressPrivate && dontUplink) { - LOG_INFO("MQTT onSend - Not forwarding packet due to DontMqttMeBro flag"); + LOG_INFO("MQTT onSend - drop packet: DontMqttMeBro flag"); return; } if (isConfiguredForDefaultServer && (mp_decoded.decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP || mp_decoded.decoded.portnum == meshtastic_PortNum_DETECTION_SENSOR_APP)) { - LOG_DEBUG("MQTT onSend - Ignoring range test or detection sensor message on public mqtt"); + LOG_DEBUG("MQTT onSend - Ignore range test/detection sensor msg on public mqtt"); return; } } @@ -769,7 +775,7 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me entry->topic = std::move(topic); entry->envBytes.assign(bytes, numBytes); if (mqttQueue.enqueue(entry, 0) == false) { - LOG_CRIT("Failed to add a message to mqttQueue!"); + LOG_CRIT("Can't add msg to mqttQueue"); abort(); } } @@ -777,6 +783,12 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me void MQTT::perhapsReportToMap() { +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL + if (channels.isEventChannel(channels.getPrimaryIndex())) { + LOG_DEBUG("Suppress MQTT map report on event (everyone) channel"); + return; + } +#endif if (!moduleConfig.mqtt.map_reporting_enabled || !moduleConfig.mqtt.map_report_settings.should_report_location || !(moduleConfig.mqtt.proxy_to_client_enabled || isConnectedDirectly())) return; @@ -784,7 +796,7 @@ void MQTT::perhapsReportToMap() // Coerce the map position precision to be within the valid range // This removes obtusely large radius and privacy problematic ones from the map if (map_position_precision < 12 || map_position_precision > 15) { - LOG_WARN("MQTT Map report position precision %u is out of range, using default %u", map_position_precision, + LOG_WARN("MQTT Map report position precision %u out of range, use default %u", map_position_precision, default_map_position_precision); map_position_precision = default_map_position_precision; } @@ -794,7 +806,7 @@ void MQTT::perhapsReportToMap() if (localPosition.latitude_i == 0 && localPosition.longitude_i == 0) { if (Throttle::isWithinTimespanMs(lastPositionUnavailableWarning, POSITION_UNAVAILABLE_WARNING_INTERVAL_MS) == false) { - LOG_WARN("MQTT Map report enabled, but no position available"); + LOG_WARN("MQTT Map report enabled but no position"); lastPositionUnavailableWarning = millis(); } return; diff --git a/src/nimble/NimbleBluetooth.cpp b/src/nimble/NimbleBluetooth.cpp index bd3de1601f..36f5f9d0e5 100644 --- a/src/nimble/NimbleBluetooth.cpp +++ b/src/nimble/NimbleBluetooth.cpp @@ -70,10 +70,10 @@ static void purgeIncompatibleBleBonds() bool wiped = false; if (mismatch) { - LOG_WARN("Wiping incompatible NimBLE bonds (on-disk format changed)"); + LOG_WARN("Wiping incompatible NimBLE bonds (format changed)"); wiped = nvs_erase_all(handle) == ESP_OK && nvs_commit(handle) == ESP_OK; if (!wiped) { - LOG_ERROR("Failed to erase nimble_bond namespace"); + LOG_ERROR("nimble_bond namespace erase failed"); } } @@ -347,8 +347,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread toPhoneQueueSize++; } #ifdef DEBUG_NIMBLE_ON_READ_TIMING - LOG_DEBUG("BLE getFromRadio returned numBytes=%u, pushed toPhoneQueueSize=%u", numBytes, - toPhoneQueueSize.load()); + LOG_DEBUG("BLE getFromRadio numBytes=%u, toPhoneQueueSize=%u", numBytes, toPhoneQueueSize.load()); #endif } else { // Shouldn't happen because the onRead callback shouldn't be waiting if the queue is full! @@ -370,7 +369,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread // Note: the comparison above is safe without a mutex because we are the only method that *decreases* // fromPhoneQueueSize. (It's okay if fromPhoneQueueSize *increases* in the NimBLE task meanwhile.) - LOG_DEBUG("NimbleBluetooth: handling ToRadio packet, fromPhoneQueueSize=%u", fromPhoneQueueSize.load()); + LOG_DEBUG("NimbleBluetooth: ToRadio packet, fromPhoneQueueSize=%u", fromPhoneQueueSize.load()); // Pop the front of fromPhoneQueue, holding the mutex only briefly while we pop. BLEValue val; @@ -546,7 +545,7 @@ class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks // There's already a packet queued. Great! We don't need to wait for onReadCallbackIsWaitingForData. #ifdef DEBUG_NIMBLE_ON_READ_TIMING - LOG_DEBUG("BLE onRead(%d): packet already waiting, no need to set onReadCallbackIsWaitingForData", currentReadCount); + LOG_DEBUG("BLE onRead(%d): packet already waiting, skip onReadCallbackIsWaitingForData", currentReadCount); #endif } else if (!bleDraining) { // (If deinit() is tearing the stack down, skip the wait entirely and just return a 0-size @@ -580,9 +579,8 @@ class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks tries++; if (tries == 4000) { - LOG_WARN( - "BLE onRead(%d): timeout waiting for data after %u ms, %d tries, giving up and returning 0-size response", - currentReadCount, millis() - startMillis, tries); + LOG_WARN("BLE onRead(%d): data timeout after %u ms, %d tries, returning 0-size response", currentReadCount, + millis() - startMillis, tries); } } } @@ -697,7 +695,7 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks // yields a *failed* encryption change here -- don't latch a connected/authenticated state // on a link that is actually being torn down. if (desc == nullptr || !desc->sec_state.encrypted) { - LOG_WARN("BLE encryption change without an encrypted link; ignoring"); + LOG_WARN("BLE encryption change without encrypted link; ignoring"); return; } @@ -764,7 +762,7 @@ class NimbleBluetoothServerCallback : public BLEServerCallbacks if (dataLenResult == 0) { LOG_INFO("BLE conn %u requested data length %u bytes", connHandle, kPreferredBleTxOctets); } else { - LOG_WARN("Failed to raise data length for conn %u, rc=%d", connHandle, dataLenResult); + LOG_WARN("Can't raise data length for conn %u, rc=%d", connHandle, dataLenResult); } #endif @@ -812,7 +810,7 @@ void NimbleBluetooth::startAdvertising() pAdvertising->setMaxPreferred(0x12); if (!pAdvertising->start(0)) { - LOG_ERROR("BLE failed to start advertising"); + LOG_ERROR("BLE advertising start failed"); } else { LOG_DEBUG("BLE Advertising started"); } @@ -908,7 +906,7 @@ void NimbleBluetooth::setup() // Uncomment for testing // NimbleBluetooth::clearBonds(); - LOG_INFO("Init the NimBLE bluetooth module"); + LOG_INFO("Init NimBLE bluetooth"); // deinit() latches these teardown guards; clear them so a re-init on the same boot (e.g. an // admin disable-bluetooth followed by re-enable) doesn't leave onRead stuck draining or @@ -929,7 +927,7 @@ void NimbleBluetooth::setup() if (mtuResult == 0) { LOG_INFO("BLE MTU request set to %u", kPreferredBleMtu); } else { - LOG_WARN("Unable to request MTU %u, rc=%d", kPreferredBleMtu, mtuResult); + LOG_WARN("Can't request MTU %u, rc=%d", kPreferredBleMtu, mtuResult); } // BLESecurity only forwards to static NimBLEDevice setters; a stack instance suffices. @@ -1063,7 +1061,7 @@ void updateBatteryLevel(uint8_t level) void NimbleBluetooth::clearBonds() { - LOG_INFO("Clearing bluetooth bonds!"); + LOG_INFO("Clearing bluetooth bonds"); ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_OUR_SEC, nullptr); ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr); ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr); diff --git a/src/platform/esp32/ESP32CryptoEngine.cpp b/src/platform/esp32/ESP32CryptoEngine.cpp index b554a3de44..f73895b6e9 100644 --- a/src/platform/esp32/ESP32CryptoEngine.cpp +++ b/src/platform/esp32/ESP32CryptoEngine.cpp @@ -32,7 +32,7 @@ class ESP32CryptoEngine : public CryptoEngine sizeof(scratch) - numBytes); // Fill rest of buffer with zero (in case cypher looks at it) mbedtls_aes_crypt_ctr(&aes, numBytes, &nc_off, _nonce, stream_block, scratch, bytes); } else { - LOG_ERROR("Packet too large for crypto engine: %d. noop encryption!", numBytes); + LOG_ERROR("Packet too large for crypto engine: %d. noop encryption", numBytes); } } } diff --git a/src/platform/esp32/MeshtasticOTA.cpp b/src/platform/esp32/MeshtasticOTA.cpp index dfe04583d4..ce59188c78 100644 --- a/src/platform/esp32/MeshtasticOTA.cpp +++ b/src/platform/esp32/MeshtasticOTA.cpp @@ -102,14 +102,14 @@ bool trySwitchToOTA() const esp_partition_t *part = getAppPartition(); if (part == NULL) { - LOG_WARN("Unable to get app partition in preparation of OTA reboot"); + LOG_WARN("Can't get app partition in preparation of OTA reboot"); return false; } uint8_t result = esp_ota_set_boot_partition(part); // Partition and app checks should now be done in the AdminModule before this is called if (result != ESP_OK) { - LOG_WARN("Unable to switch to OTA partiton. (Reason %d)", result); + LOG_WARN("Can't switch to OTA partition (reason %d)", result); return false; } diff --git a/src/platform/esp32/main-esp32.cpp b/src/platform/esp32/main-esp32.cpp index afbf4482d1..f7879a333f 100644 --- a/src/platform/esp32/main-esp32.cpp +++ b/src/platform/esp32/main-esp32.cpp @@ -69,7 +69,7 @@ static bool shouldReleaseBluetoothMemory() // Paxcounter disables the Meshtastic BLE service, but libpax still needs the // ESP32 BLE controller memory for scanning. if (isPaxcounterActiveForBoot()) { - LOG_DEBUG("Skipping Bluetooth memory release because Paxcounter is active"); + LOG_DEBUG("Skip BT memory release: Paxcounter active"); return false; } @@ -96,7 +96,7 @@ void setBluetoothEnable(bool enable) if (enable && bluetoothMemoryReleased) { if (!shouldReleaseBluetoothMemory() && !bluetoothMemoryReleaseWarned) { bluetoothMemoryReleaseWarned = true; - LOG_WARN("Bluetooth memory has been released; reboot to re-enable Bluetooth"); + LOG_WARN("BT memory released; reboot to re-enable"); } return; } @@ -205,7 +205,7 @@ void enableSlowCLK() LOG_DEBUG("32k XTAL OSC has not started up"); } else { rtc_clk_slow_freq_set(RTC_SLOW_FREQ_32K_XTAL); - LOG_DEBUG("Switch RTC Source to 32.768kHz succeeded, using 32k XTAL"); + LOG_DEBUG("RTC source now 32k XTAL"); CALIBRATE_ONE(RTC_CAL_RTC_MUX); CALIBRATE_ONE(RTC_CAL_32K_XTAL); } @@ -285,14 +285,14 @@ void esp32Setup() }; res = esp_task_wdt_init(&wdt_config); if (res == ESP_ERR_INVALID_STATE) { - LOG_WARN("Task watchdog already initialized, reconfiguring existing instance"); + LOG_WARN("Task watchdog already init, reconfiguring"); res = esp_task_wdt_reconfigure(&wdt_config); } assert(res == ESP_OK); #else res = esp_task_wdt_init(APP_WATCHDOG_SECS, true); if (res == ESP_ERR_INVALID_STATE) { - LOG_WARN("Task watchdog already initialized, reusing existing instance"); + LOG_WARN("Task watchdog already init, reusing"); res = ESP_OK; } assert(res == ESP_OK); diff --git a/src/platform/extra_variants/t5s3_epaper/variant.cpp b/src/platform/extra_variants/t5s3_epaper/variant.cpp index 6c1dacb64b..a83b04b0fb 100644 --- a/src/platform/extra_variants/t5s3_epaper/variant.cpp +++ b/src/platform/extra_variants/t5s3_epaper/variant.cpp @@ -10,6 +10,7 @@ #include "input/InputBroker.h" #include "input/TouchScreenImpl1.h" #include "main.h" +#include "mesh/Throttle.h" #include "sleep.h" #include @@ -100,7 +101,10 @@ volatile bool touchControllerReady = false; volatile bool touchLightSleepActive = false; volatile bool touchNeedsWake = false; volatile bool touchIndicatorRefreshPending = false; -volatile uint32_t touchResumeBlockUntilMs = 0; +// When the light-sleep resume happened, not when the block expires: an interval bounds a missed +// 0-check by the settle time, where a stored deadline would block for up to half a wrap cycle. +constexpr uint32_t TOUCH_RESUME_BLOCK_MS = 150; +volatile uint32_t touchResumeAtMs = 0; volatile uint32_t touchStateEpoch = 1; volatile bool homeCapButtonEventsEnabled = false; #if HAS_SCREEN @@ -184,7 +188,8 @@ class SideKeyInterruptThread : public concurrency::OSThread { const uint32_t now = millis(); - if (now < touchResumeBlockUntilMs) { + // 0 means the device has never light-slept, so no block is armed - test it first. + if (touchResumeAtMs != 0 && Throttle::isWithinTimespanMs(touchResumeAtMs, TOUCH_RESUME_BLOCK_MS)) { resetStateAndStop(); return OSThread::disable(); } @@ -279,8 +284,8 @@ class SideKeyInterruptThread : public concurrency::OSThread if (touchLightSleepActive) { return; } - const uint32_t now = millis(); - if (now < touchResumeBlockUntilMs) { + // See the runOnce() guard above for why 0 must be tested separately. + if (touchResumeAtMs != 0 && Throttle::isWithinTimespanMs(touchResumeAtMs, TOUCH_RESUME_BLOCK_MS)) { return; } if (state != State::REST) { @@ -550,7 +555,7 @@ struct TouchLightSleepEndObserver { } touchStateEpoch++; - touchResumeBlockUntilMs = millis() + 150; + touchResumeAtMs = millis(); touchIndicatorRefreshPending = !isTouchInputEnabled(); #ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS // Clear sleep-time touch overlay after wake. @@ -569,17 +574,18 @@ struct TouchLightSleepEndObserver { bool readTouch(int16_t *x, int16_t *y) { #ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS - static uint32_t suppressUntilMs = 0; + constexpr uint32_t TOUCH_WAKE_SUPPRESS_MS = 60; + static uint32_t suppressFromMs = 0; // 0 = not suppressing, same reading as touchResumeAtMs static uint32_t seenTouchStateEpoch = 0; // Reset transient gesture helpers whenever touch mode changes. if (seenTouchStateEpoch != touchStateEpoch) { seenTouchStateEpoch = touchStateEpoch; - suppressUntilMs = 0; + suppressFromMs = 0; } - // Let buses and peripherals settle briefly after light-sleep wake. - if (millis() < touchResumeBlockUntilMs) { + // Let buses and peripherals settle briefly after light-sleep wake. 0 means no wake yet. + if (touchResumeAtMs != 0 && Throttle::isWithinTimespanMs(touchResumeAtMs, TOUCH_RESUME_BLOCK_MS)) { return false; } @@ -596,12 +602,12 @@ bool readTouch(int16_t *x, int16_t *y) LOG_DEBUG("touchscreen1: wakeup() on deferred resume"); touch.wakeup(); touchNeedsWake = false; - suppressUntilMs = millis() + 60; + suppressFromMs = millis(); return false; } // After a recovery pulse, emit a brief "released" window so gesture state can reset. - if (suppressUntilMs != 0 && millis() < suppressUntilMs) { + if (suppressFromMs != 0 && Throttle::isWithinTimespanMs(suppressFromMs, TOUCH_WAKE_SUPPRESS_MS)) { return false; } #endif @@ -696,7 +702,7 @@ void lateInitVariant() #endif } else { touchControllerReady = false; - LOG_ERROR("Failed to find touch controller!"); + LOG_ERROR("Failed to find touch controller"); } #if defined(BOARD_PCA9535_ADDR) && defined(BOARD_PCA9535_BUTTON_MASK) diff --git a/src/platform/extra_variants/t_deck_pro/variant.cpp b/src/platform/extra_variants/t_deck_pro/variant.cpp index 2915ff3633..20105da60c 100644 --- a/src/platform/extra_variants/t_deck_pro/variant.cpp +++ b/src/platform/extra_variants/t_deck_pro/variant.cpp @@ -119,7 +119,7 @@ void lateInitVariant() break; } else { - LOG_DEBUG("CST3530 not response ~!"); + LOG_DEBUG("CST3530 no response"); } } uint8_t cmd1[] = {0xD0, 0x00, 0x04, 0x00}; diff --git a/src/platform/nrf52/AsyncUDP.cpp b/src/platform/nrf52/AsyncUDP.cpp index 8c937d71f3..5431597c5b 100644 --- a/src/platform/nrf52/AsyncUDP.cpp +++ b/src/platform/nrf52/AsyncUDP.cpp @@ -8,8 +8,9 @@ bool AsyncUDP::listenMulticast(IPAddress multicastIP, uint16_t port, uint8_t ttl { if (!isMulticast(multicastIP)) return false; + if (!udp.beginMulticast(multicastIP, port)) + return false; localPort = port; - udp.beginMulticast(multicastIP, port); return true; } @@ -80,4 +81,4 @@ int32_t AsyncUDP::runOnce() return 5; // check every 5ms } -#endif // HAS_ETHERNET \ No newline at end of file +#endif // HAS_ETHERNET diff --git a/src/platform/nrf52/NRF52Bluetooth.cpp b/src/platform/nrf52/NRF52Bluetooth.cpp index f1d9c6845d..85a29e05a9 100644 --- a/src/platform/nrf52/NRF52Bluetooth.cpp +++ b/src/platform/nrf52/NRF52Bluetooth.cpp @@ -255,7 +255,7 @@ void NRF52Bluetooth::startDisabled() // Shutdown bluetooth for minimum power draw Bluefruit.Advertising.stop(); Bluefruit.setTxPower(-40); // Minimum power - LOG_INFO("Disable NRF52 Bluetooth. (Workaround: tx power min, advertise stopped)"); + LOG_INFO("Disable NRF52 BT (tx power min, advertise stopped)"); } bool NRF52Bluetooth::isConnected() { @@ -283,7 +283,7 @@ void NRF52Bluetooth::setup() // current Bluefruit config. Without this check the node would silently run without BLE. // Rebuild with -DCFG_DEBUG=1 to get "SoftDevice's RAM requires: 0x..." in the log, then // raise the ORIGIN accordingly. - LOG_ERROR("Bluefruit.begin failed - SoftDevice RAM reservation too small for this config"); + LOG_ERROR("Bluefruit.begin failed: SoftDevice RAM too small"); RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_UNSPECIFIED); return; } @@ -399,7 +399,7 @@ void updateBatteryLevel(uint8_t level) } void NRF52Bluetooth::clearBonds() { - LOG_INFO("Clear bluetooth bonds!"); + LOG_INFO("Clear bluetooth bonds"); bond_print_list(BLE_GAP_ROLE_PERIPH); bond_print_list(BLE_GAP_ROLE_CENTRAL); Bluefruit.Periph.clearBonds(); @@ -446,7 +446,7 @@ bool NRF52Bluetooth::onPairingPasskey(uint16_t conn_handle, uint8_t const passke if (match_request) { uint32_t start_time = millis(); - while (millis() < start_time + 30000) { + while (Throttle::isWithinTimespanMs(start_time, 30000)) { if (!Bluefruit.connected(conn_handle)) break; } @@ -481,7 +481,7 @@ void NRF52Bluetooth::disconnect() delay(1); if (Bluefruit.connected()) - LOG_WARN("BLE disconnect unconfirmed after %ums, continuing shutdown", millis() - start); + LOG_WARN("BLE disconnect unconfirmed after %ums, shutdown anyway", millis() - start); else LOG_INFO("Ended BLE connection"); } diff --git a/src/platform/nrf52/main-nrf52.cpp b/src/platform/nrf52/main-nrf52.cpp index ae12ef4a0c..eb20844033 100644 --- a/src/platform/nrf52/main-nrf52.cpp +++ b/src/platform/nrf52/main-nrf52.cpp @@ -1,4 +1,5 @@ #include "configuration.h" +#include "mesh/Throttle.h" #include #include #include @@ -51,12 +52,14 @@ uint16_t getVDDVoltage(); // Weak empty variant shutdown prep function. // May be redefined by variant files. -void variant_shutdown() __attribute__((weak)); -void variant_shutdown() {} +// noinline: same reason as variant_enableBatteryLpcompWake() below -- weak default and call +// site are in this file, so LTO would inline the empty body and drop the variant's override. +__attribute__((noinline)) void variant_shutdown() __attribute__((weak)); +__attribute__((noinline)) void variant_shutdown() {} // Optional variant hook called each nrf52Loop(); e.g. for low-VDD System OFF. -void variant_nrf52LoopHook(void) __attribute__((weak)); -void variant_nrf52LoopHook(void) {} +__attribute__((noinline)) void variant_nrf52LoopHook(void) __attribute__((weak)); +__attribute__((noinline)) void variant_nrf52LoopHook(void) {} // Return false to skip LPCOMP wake when entering System OFF (e.g. user CLI shutdown). // noinline: weak default and call site are in this file; without it GCC may inline the @@ -268,12 +271,17 @@ namespace { constexpr uint8_t NRF52_MAGIC_LFS_IS_CORRUPT = 0xF5; constexpr uint32_t MULTIPLE_CORRUPTION_DELAY_MILLIS = 20 * 60 * 1000; -static unsigned long millis_until_formatting_again = 0; +// When the last format happened, not when the next one is due: measuring forward from the event +// bounds the pause below by the constant, where a stored deadline could hand delay() any value. +// Armed separately because preFSBegin() runs in the first millisecond of boot, so a zero timestamp +// is a legitimate value here, not an "unset" marker. +static uint32_t last_format_ms = 0; +static bool formatted_this_boot = false; // Report the critical error from loop(), giving a chance for the screen to be initialized first. inline void reportLittleFSCorruptionOnce() { - static bool report_corruption = !!millis_until_formatting_again; + static bool report_corruption = formatted_this_boot; if (report_corruption) { report_corruption = false; RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_FLASH_CORRUPTION_UNRECOVERABLE); @@ -288,7 +296,8 @@ void preFSBegin() if (!(NRF_POWER->RESETREAS == 0 && NRF_POWER->GPREGRET == NRF52_MAGIC_LFS_IS_CORRUPT)) return; NRF_POWER->GPREGRET = 0; - millis_until_formatting_again = millis() + MULTIPLE_CORRUPTION_DELAY_MILLIS; + last_format_ms = millis(); + formatted_this_boot = true; InternalFS.format(); LOG_INFO("LittleFS format complete; restoring default settings"); } @@ -296,9 +305,11 @@ void preFSBegin() extern "C" void lfs_assert(const char *reason) { LOG_ERROR("LittleFS corruption detected: %s", reason); - if (millis_until_formatting_again > millis()) { + // Test the armed flag first, since elapsed-since-0 is inside the backoff for the first 20 + // minutes after each wrap. + if (formatted_this_boot && Throttle::isWithinTimespanMs(last_format_ms, MULTIPLE_CORRUPTION_DELAY_MILLIS)) { RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_FLASH_CORRUPTION_UNRECOVERABLE); - const long millis_remain = millis_until_formatting_again - millis(); + const long millis_remain = MULTIPLE_CORRUPTION_DELAY_MILLIS - (millis() - last_format_ms); LOG_WARN("Pausing %d seconds to avoid wear on flash storage", millis_remain / 1000); delay(millis_remain); } @@ -419,7 +430,7 @@ void nrf52Setup() #ifdef BQ25703A_ADDR auto *bq = new BQ25713(); if (!bq->setup()) - LOG_ERROR("ERROR! Charge controller init failed"); + LOG_ERROR("Charge controller init failed"); #endif // Init random seed @@ -526,7 +537,7 @@ void cpuDeepSleep(uint32_t msecToWake) auto ok = sd_power_system_off(); if (ok != NRF_SUCCESS) { - LOG_ERROR("FIXME: Ignoring soft device (EasyDMA pending?) and forcing system-off!"); + LOG_ERROR("FIXME: Ignoring soft device (EasyDMA pending?) and forcing system-off"); NRF_POWER->SYSTEMOFF = 1; } } diff --git a/src/platform/nrf54l15/Arduino.h b/src/platform/nrf54l15/Arduino.h index b608c4856c..c67628afa1 100644 --- a/src/platform/nrf54l15/Arduino.h +++ b/src/platform/nrf54l15/Arduino.h @@ -297,6 +297,7 @@ class Print } virtual void flush() {} + virtual int availableForWrite() { return 0; } }; // ── Stream base class ──────────────────────────────────────────────────────── diff --git a/src/platform/nrf54l15/InternalFileSystem.cpp b/src/platform/nrf54l15/InternalFileSystem.cpp index 18ea368e21..15fdec6df6 100644 --- a/src/platform/nrf54l15/InternalFileSystem.cpp +++ b/src/platform/nrf54l15/InternalFileSystem.cpp @@ -77,7 +77,7 @@ bool InternalFileSystem::begin() } // Mount failed: attempt to format (creates a fresh LittleFS) - LOG_WARN("LittleFS mount failed (%d), formatting storage partition...", rc); + LOG_WARN("LittleFS mount failed (%d), formatting storage partition", rc); int fmt_rc = fs_mkfs(FS_LITTLEFS, (uintptr_t)FIXED_PARTITION_ID(storage_partition), NULL, 0); if (fmt_rc != 0) { LOG_ERROR("LittleFS format failed (%d)", fmt_rc); diff --git a/src/platform/nrf54l15/NRF54L15Bluetooth.cpp b/src/platform/nrf54l15/NRF54L15Bluetooth.cpp index c6c751ae27..9ce0326316 100644 --- a/src/platform/nrf54l15/NRF54L15Bluetooth.cpp +++ b/src/platform/nrf54l15/NRF54L15Bluetooth.cpp @@ -442,7 +442,7 @@ static void security_changed_cb(struct bt_conn *conn, bt_security_t level, enum if (err == BT_SECURITY_ERR_PIN_OR_KEY_MISSING) { // Phone has a stale bond (device was wiped/reflashed). Unpair the stale // entry so the phone re-pairs cleanly on the next connection attempt. - LOG_WARN("BLE stale bond detected (key missing) - unpairing"); + LOG_WARN("BLE stale bond (key missing) - unpairing"); bt_unpair(BT_ID_DEFAULT, bt_conn_get_dst(conn)); bt_conn_disconnect(conn, BT_HCI_ERR_AUTH_FAIL); } else if (err) { @@ -691,7 +691,7 @@ static bool nrf54l15_bt_init_common() // instead of leaving BLE silently broken. if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) { LOG_WARN("BLE: NO_PIN not supported on nRF54L15-DK (MITM-only build); " - "treating as RANDOM_PIN"); + "treat as RANDOM_PIN"); } bt_conn_auth_cb_register(&auth_cb); @@ -759,7 +759,7 @@ void NRF54L15Bluetooth::startDisabled() return; } ble_enabled = false; - LOG_INFO("BLE initialized, advertising stopped (startDisabled)"); + LOG_INFO("BLE initialized, adv stopped (startDisabled)"); } void NRF54L15Bluetooth::resumeAdvertising() diff --git a/src/platform/portduino/GpsdSerial.cpp b/src/platform/portduino/GpsdSerial.cpp index 1b80c7d06d..e85b951c04 100644 --- a/src/platform/portduino/GpsdSerial.cpp +++ b/src/platform/portduino/GpsdSerial.cpp @@ -115,7 +115,7 @@ bool GpsdSerial::connectToGpsd() std::string portStr = std::to_string(_port); if (getaddrinfo(_host.c_str(), portStr.c_str(), &hints, &res) != 0 || !res) { - LOG_WARN("gpsdSerial: could not resolve %s", _host.c_str()); + LOG_WARN("gpsdSerial: can't resolve %s", _host.c_str()); return false; } diff --git a/src/platform/portduino/SimRadio.cpp b/src/platform/portduino/SimRadio.cpp index 2786903ebb..d60c34db07 100644 --- a/src/platform/portduino/SimRadio.cpp +++ b/src/platform/portduino/SimRadio.cpp @@ -27,7 +27,7 @@ ErrorCode SimRadio::send(meshtastic_MeshPacket *p) // set (random) transmit delay to let others reconfigure their radio, // to avoid collisions and implement timing-based flooding - LOG_DEBUG("Set random delay before tx"); + LOG_TRACE("Set random delay before tx"); setTransmitDelay(); return res; } @@ -47,7 +47,7 @@ void SimRadio::setTransmitDelay() startTransmitTimer(true); } else { // If there is a SNR, start a timer scaled based on that SNR. - LOG_DEBUG("rx_snr found. hop_limit:%d rx_snr:%f", p->hop_limit, p->rx_snr); + LOG_TRACE("rx_snr found. hop_limit:%d rx_snr:%f", p->hop_limit, p->rx_snr); startTransmitTimerRebroadcast(p); } } @@ -169,7 +169,7 @@ void SimRadio::onNotify(uint32_t notification) startTransmitTimer(); break; } - LOG_DEBUG("delay done"); + LOG_TRACE("delay done"); // If we are not currently in receive mode, then restart the random delay (this can happen if the main thread // has placed the unit into standby) FIXME, how will this work if the chipset is in sleep mode? @@ -238,7 +238,7 @@ void SimRadio::startSend(meshtastic_MeshPacket *txp) memcpy(&c.data.bytes, p->encrypted.bytes, p->encrypted.size); c.data.size = p->encrypted.size; } else { - LOG_WARN("Encrypted payload (%u) exceeds sim loopback capacity (%u)! Send empty payload", (unsigned)p->encrypted.size, + LOG_WARN("Encrypted payload (%u) > sim loopback capacity (%u), send empty", (unsigned)p->encrypted.size, (unsigned)loopbackCapacity); } } else { @@ -248,7 +248,7 @@ void SimRadio::startSend(meshtastic_MeshPacket *txp) memcpy(&c.data.bytes, p->decoded.payload.bytes, p->decoded.payload.size); c.data.size = p->decoded.payload.size; } else { - LOG_WARN("Payload size larger than compressed message allows! Send empty payload"); + LOG_WARN("Payload > compressed max, send empty"); } } @@ -295,7 +295,7 @@ void SimRadio::unpackAndReceive(meshtastic_MeshPacket &p) p.decoded.portnum = scratch.portnum; } } else - LOG_ERROR("Error decoding proto for simulator message!"); + LOG_ERROR("Error decoding proto for simulator message"); } // Let SimRadio receive as if it did via its LoRa chip startReceive(&p); @@ -305,7 +305,7 @@ void SimRadio::startReceive(meshtastic_MeshPacket *p) { #ifdef USERPREFS_SIMRADIO_EMULATE_COLLISIONS if (isActivelyReceiving()) { - LOG_WARN("Collision detected, dropping current and previous packet!"); + LOG_WARN("Collision detected, dropping current and previous packet"); rxBad++; airTime->logAirtime(RX_ALL_LOG, getPacketTime(receivingPacket, true)); packetPool.release(receivingPacket); @@ -319,7 +319,7 @@ void SimRadio::startReceive(meshtastic_MeshPacket *p) } else if ((interval - airtimeLeft) > preambleTimeMsec) { // Only if transmitting for longer than preamble there is a collision // (channel should actually be detected as active otherwise) - LOG_WARN("Collision detected during transmission!"); + LOG_WARN("Collision detected during transmission"); return; } } @@ -359,11 +359,11 @@ void SimRadio::handleReceiveInterrupt() } if (!isReceiving) { - LOG_DEBUG("*** WAS_ASSERT *** handleReceiveInterrupt called when not in receive mode"); + LOG_DEBUG("*** WAS_ASSERT *** handleReceiveInterrupt outside receive mode"); return; } - LOG_DEBUG("HANDLE RECEIVE INTERRUPT"); + LOG_TRACE("HANDLE RECEIVE INTERRUPT"); rxGood++; meshtastic_MeshPacket *mp = packetPool.allocCopy(*receivingPacket); // keep a copy in packetPool diff --git a/src/platform/portduino/USBHal.h b/src/platform/portduino/USBHal.h index 2c00ed3904..e07fb70dc8 100644 --- a/src/platform/portduino/USBHal.h +++ b/src/platform/portduino/USBHal.h @@ -89,7 +89,7 @@ class Ch341Hal : public RadioLibHal } auto res = pinedio_set_pin_mode(&pinedio, pin, mode); if (res < 0 && rebootAtMsec == 0) { - LOG_ERROR("USBHal pinMode: Could not set pin %u mode to %u: %d", pin, mode, res); + LOG_ERROR("USBHal pinMode: Can't set pin %u mode to %u: %d", pin, mode, res); } } @@ -103,7 +103,7 @@ class Ch341Hal : public RadioLibHal } auto res = pinedio_digital_write(&pinedio, pin, value); if (res < 0 && rebootAtMsec == 0) { - LOG_ERROR("USBHal digitalWrite: Could not write pin %u: %d", pin, res); + LOG_ERROR("USBHal digitalWrite: Can't write pin %u: %d", pin, res); portduino_status.LoRa_in_error = true; } } @@ -118,7 +118,7 @@ class Ch341Hal : public RadioLibHal } auto res = pinedio_digital_read(&pinedio, pin); if (res < 0 && rebootAtMsec == 0) { - LOG_ERROR("USBHal digitalRead: Could not read pin %u: %d", pin, res); + LOG_ERROR("USBHal digitalRead: Can't read pin %u: %d", pin, res); portduino_status.LoRa_in_error = true; return 0; } diff --git a/src/platform/rp2xx0/main-rp2xx0.cpp b/src/platform/rp2xx0/main-rp2xx0.cpp index cb95f8e845..75646a52f7 100644 --- a/src/platform/rp2xx0/main-rp2xx0.cpp +++ b/src/platform/rp2xx0/main-rp2xx0.cpp @@ -111,7 +111,7 @@ bool getDeviceId(uint8_t *deviceId) void rp2040Setup() { if (watchdog_caused_reboot()) { - LOG_WARN("Rebooted by watchdog!"); + LOG_WARN("Rebooted by watchdog"); } /* Sets a random seed to make sure we get different random numbers on each boot. */ diff --git a/src/platform/stm32wl/main-stm32wl.cpp b/src/platform/stm32wl/main-stm32wl.cpp index d429c5662d..50f7ae3d81 100644 --- a/src/platform/stm32wl/main-stm32wl.cpp +++ b/src/platform/stm32wl/main-stm32wl.cpp @@ -18,20 +18,9 @@ static bool stm32wlRtcValid = false; #endif // ─── Bootloader redirect ────────────────────────────────────────────────────── -// -// Why .noinit + constructor instead of TAMP backup registers: -// -// The STM32duino startup sequence initialises clocks which may call -// __HAL_RCC_BACKUPRESET_FORCE/RELEASE when configuring the LSE oscillator, -// wiping the entire backup domain (including TAMP->BKP0R) before setup() -// ever runs. The backup-register approach therefore cannot reliably survive -// a soft reset in this toolchain. -// -// Solution: store the magic in a .noinit SRAM variable. -// - NVIC_SystemReset() does NOT clear SRAM. -// - The linker script skips zero-init for .noinit sections. -// - __attribute__((constructor)) fires before main()/HAL_Init(), so we can -// intercept and jump before anything disturbs peripheral state. +// Uses .noinit SRAM instead of TAMP backup registers: STM32duino's clock init can wipe the +// backup domain via __HAL_RCC_BACKUPRESET_FORCE/RELEASE before setup() runs, but .noinit +// survives NVIC_SystemReset() and this constructor fires before HAL_Init() touches anything. #define BOOTLOADER_MAGIC 0xD00DB007UL #define SYS_MEM_BASE 0x1FFF0000UL @@ -58,8 +47,10 @@ __attribute__((constructor(101), used)) static void earlyBootCheck(void) SCB->VTOR = SYS_MEM_BASE; __set_MSP(*(volatile uint32_t *)SYS_MEM_BASE); ((void (*)(void))(*(volatile uint32_t *)(SYS_MEM_BASE + 4)))(); - while (1) - ; + // Should never be reached: the bootloader ROM does not return. A bare reset + // (rather than returning normally) avoids unwinding through this function's + // epilogue, which would restore registers relative to the now-repointed MSP. + NVIC_SystemReset(); } void enterDfuMode() @@ -146,7 +137,7 @@ void cpuDeepSleep(uint32_t msecToWake) if (!stm32wlRtcAvailable()) { // Hardware can't shutdown, but firmware has already prepared itself for shutdown // Do not leave the device unresponsive, reset instead - LOG_WARN("STM32WL: hardware RTC failed, cannot deep sleep/shutdown"); + LOG_WARN("STM32WL: hardware RTC failed, can't deep sleep/shutdown"); if (Serial) { Serial.flush(); Serial.end(); @@ -169,15 +160,7 @@ void cpuDeepSleep(uint32_t msecToWake) #endif } -// Hacks to force more code and data out. - -// By default __assert_func uses fiprintf which pulls in stdio. -extern "C" void __wrap___assert_func(const char *, int, const char *, const char *) -{ - while (true) - ; - return; -} +// ─── Linker hacks to reduce code size ───────────────────────────────────────── // By default strerror has a lot of strings we probably don't use. Make it return an empty string instead. char empty = 0; @@ -197,6 +180,8 @@ extern "C" void __wrap__tzset_unlocked_r(struct _reent *reent_ptr) } #endif +// ─── Fault handling & recovery ──────────────────────────────────────────────── + // Taken from https://interrupt.memfault.com/blog/cortex-m-hardfault-debug typedef struct __attribute__((packed)) ContextStateFrame { uint32_t r0; @@ -233,32 +218,11 @@ static void debug_printf(const char *format, ...) uart_debug_write((uint8_t *)hardfault_message_buffer, min((unsigned int)length, sizeof(hardfault_message_buffer) - 1)); } -// N picked by guessing -#define DOT_TIME 1200000 -static void dot() +// By default __assert_func uses fiprintf which pulls in stdio. +extern "C" void __wrap___assert_func(const char *file, int line, const char *func, const char *failedexpr) { - digitalWrite(LED_POWER, LED_STATE_ON); - for (volatile int i = 0; i < DOT_TIME; i++) { /* busy wait */ - } - digitalWrite(LED_POWER, LED_STATE_OFF); - for (volatile int i = 0; i < DOT_TIME; i++) { /* busy wait */ - } -} - -static void dash() -{ - digitalWrite(LED_POWER, LED_STATE_ON); - for (volatile int i = 0; i < (DOT_TIME * 3); i++) { /* busy wait */ - } - digitalWrite(LED_POWER, LED_STATE_OFF); - for (volatile int i = 0; i < DOT_TIME; i++) { /* busy wait */ - } -} - -static void space() -{ - for (volatile int i = 0; i < (DOT_TIME * 3); i++) { /* busy wait */ - } + debug_printf("assert: %s:%d in %s: %s\r\n", file, line, func, failedexpr); + HAL_NVIC_SystemReset(); } // Disable optimizations for this function so "frame" argument @@ -277,17 +241,5 @@ extern "C" __attribute__((optimize("O0"))) void HardFault_Handler_C(sContextStat HALT_IF_DEBUGGING(); - // blink SOS forever - while (1) { - dot(); - dot(); - dot(); - dash(); - dash(); - dash(); - dot(); - dot(); - dot(); - space(); - } -} \ No newline at end of file + HAL_NVIC_SystemReset(); +} diff --git a/src/security/EncryptedStorage.cpp b/src/security/EncryptedStorage.cpp index d34906eaad..9572f7ea07 100644 --- a/src/security/EncryptedStorage.cpp +++ b/src/security/EncryptedStorage.cpp @@ -204,7 +204,7 @@ static void writeBackoff(uint8_t attempts, uint8_t bootsSinceFail, uint32_t last bool ok = computeBackoffHmac(buf.data(), mac); nRFCrypto.end(); if (!ok) { - LOG_ERROR("EncryptedStorage: backoff HMAC compute failed"); + LOG_ERROR("EncryptedStorage: backoff HMAC failed"); return; } memcpy(buf.data() + BACKOFF_BODY_SIZE, mac, HMAC_SIZE); @@ -489,7 +489,7 @@ static bool loadDEK() const uint8_t *storedHmac = buf + DEK_SIZE - HMAC_SIZE; if (!constTimeEq(expectedHmac.data(), storedHmac, HMAC_SIZE)) { - LOG_ERROR("EncryptedStorage: DEK HMAC mismatch - wrong passphrase or tampered file"); + LOG_ERROR("EncryptedStorage: DEK HMAC mismatch - wrong passphrase or tampered"); return false; } @@ -791,7 +791,7 @@ static bool writeUnlockToken(uint8_t bootsRemaining, uint32_t validUntilEpoch, u // greater than the persisted value); readAndConsumeToken will // promote .tokmono on the next read. if (!writeMonoCounter(newMonoCounter)) { - LOG_WARN("EncryptedStorage: mono-counter persist failed (will self-heal on next read)"); + LOG_WARN("EncryptedStorage: mono-counter persist failed (self-heals on next read)"); } LOG_INFO("EncryptedStorage: Unlock token written (boots=%d, epoch=%u, mono=%u)", bootsRemaining, validUntilEpoch, @@ -893,7 +893,7 @@ static bool readAndConsumeToken() // current value. Equal is the normal case post-write. uint32_t maxSeenCounter = readMonoCounter(); if (tokenMonoCounter < maxSeenCounter) { - LOG_ERROR("EncryptedStorage: Token rollback detected (counter=%u, max-seen=%u), deleting", (unsigned)tokenMonoCounter, + LOG_ERROR("EncryptedStorage: Token rollback (counter=%u, max-seen=%u), deleting", (unsigned)tokenMonoCounter, (unsigned)maxSeenCounter); concurrency::LockGuard g(spiLock); FSCom.remove(TOKEN_FILENAME); @@ -931,8 +931,7 @@ static bool readAndConsumeToken() if (validUntilEpoch != 0) { uint32_t now = getValidTime(RTCQualityDevice); if (now == 0) { - LOG_WARN("EncryptedStorage: Token wall-clock TTL unverifiable (no RTC), falling back to boot count (%u left)", - bootsRemaining); + LOG_WARN("EncryptedStorage: Token wall-clock TTL unverifiable (no RTC), using boot count (%u left)", bootsRemaining); } else if (now > validUntilEpoch) { LOG_WARN("EncryptedStorage: Token expired (now=%u, until=%u), deleting", now, validUntilEpoch); concurrency::LockGuard g(spiLock); @@ -1041,7 +1040,7 @@ void initLocked() if (isProvisioned()) { LOG_WARN("EncryptedStorage: Device LOCKED - reason: %s", lockReason); } else { - LOG_WARN("EncryptedStorage: Device NOT PROVISIONED - operator must set passphrase"); + LOG_WARN("EncryptedStorage: Device NOT PROVISIONED - set passphrase"); } } @@ -1145,7 +1144,7 @@ bool provisionPassphrase(const uint8_t *passphrase, size_t passphraseLen, uint8_ // Create unlock token (validUntilEpoch is an absolute Unix timestamp from the client; 0 = no limit) if (!writeUnlockToken(bootsRemaining, validUntilEpoch, sessionMaxSeconds)) { - LOG_WARN("EncryptedStorage: Token write failed after provision (continuing unlocked)"); + LOG_WARN("EncryptedStorage: Token write failed after provision (still unlocked)"); } // H4 (audit): seed an attempts=0 backoff sentinel so the file is @@ -1234,7 +1233,7 @@ bool unlockWithPassphrase(const uint8_t *passphrase, size_t passphraseLen, uint8 if (maxRemaining > 0) { s_backoffSecondsRemaining = maxRemaining; - LOG_WARN("EncryptedStorage: Passphrase attempt blocked by backoff (~%us remaining)", s_backoffSecondsRemaining); + LOG_WARN("EncryptedStorage: Passphrase blocked by backoff (~%us left)", s_backoffSecondsRemaining); return false; } } @@ -1296,7 +1295,7 @@ bool unlockWithPassphrase(const uint8_t *passphrase, size_t passphraseLen, uint8 // Create fresh unlock token (validUntilEpoch is an absolute Unix timestamp from the client; 0 = no limit) if (!writeUnlockToken(bootsRemaining, validUntilEpoch, sessionMaxSeconds)) { - LOG_WARN("EncryptedStorage: Token write failed after unlock (continuing unlocked this boot)"); + LOG_WARN("EncryptedStorage: Token write failed after unlock (unlocked this boot)"); } dekLoaded = true; @@ -1318,7 +1317,7 @@ void lockNow() secureWipeKeys(); s_sessionMaxMs = 0; s_sessionStartedMs = 0; - LOG_INFO("EncryptedStorage: Device locked - token deleted, DEK and KEK material zeroed"); + LOG_INFO("EncryptedStorage: Device locked - token deleted, DEK/KEK zeroed"); } void secureWipeKeys() @@ -1433,8 +1432,7 @@ bool readAndDecrypt(const char *filename, uint8_t *outBuf, size_t outBufSize, si // MAX_NUM_NODES pushes the serialised protobuf past that limit. const size_t maxAcceptedFileSize = outBufSize + OVERHEAD; if (fileSize > maxAcceptedFileSize) { - LOG_ERROR("EncryptedStorage: File %s too large (%d bytes, max %d), refusing", filename, fileSize, - maxAcceptedFileSize); + LOG_ERROR("EncryptedStorage: File %s too large (%d bytes, max %d)", filename, fileSize, maxAcceptedFileSize); f.close(); meshtastic_security::secure_zero(dekSnapshot, sizeof(dekSnapshot)); return false; @@ -1512,7 +1510,7 @@ bool readAndDecrypt(const char *filename, uint8_t *outBuf, size_t outBufSize, si hmacData.reset(); if (!hmacOk || !constTimeEq(computedHmac, storedHmac, HMAC_SIZE)) { - LOG_ERROR("EncryptedStorage: HMAC verification failed for %s", filename); + LOG_ERROR("EncryptedStorage: HMAC verify failed for %s", filename); meshtastic_security::secure_zero(computedHmac, sizeof(computedHmac)); meshtastic_security::secure_zero(dekSnapshot, sizeof(dekSnapshot)); return false; @@ -1620,7 +1618,7 @@ bool encryptAndWrite(const char *filename, const uint8_t *plaintext, size_t plai hmacData.reset(); if (!hmacOk) { - LOG_ERROR("EncryptedStorage: HMAC computation failed for %s", filename); + LOG_ERROR("EncryptedStorage: HMAC compute failed for %s", filename); meshtastic_security::secure_zero(dekSnapshot, sizeof(dekSnapshot)); return false; } @@ -1688,7 +1686,7 @@ bool migrateFile(const char *filename) // the device. constexpr size_t kMigrateMaxFileSize = 64 * 1024; if (fileSize > kMigrateMaxFileSize) { - LOG_ERROR("EncryptedStorage: refusing to migrate %s - size %u exceeds %u-byte cap", filename, (unsigned)fileSize, + LOG_ERROR("EncryptedStorage: won't migrate %s - size %u > %u-byte cap", filename, (unsigned)fileSize, (unsigned)kMigrateMaxFileSize); f.close(); return false; @@ -1733,7 +1731,7 @@ bool migrateFileToPlaintext(const char *filename) return true; } if (!dekLoaded) { - LOG_ERROR("EncryptedStorage: cannot revert %s - not unlocked", filename); + LOG_ERROR("EncryptedStorage: can't revert %s - not unlocked", filename); return false; } @@ -1797,7 +1795,7 @@ void removeLockdownArtifacts() secureWipeKeys(); s_sessionMaxMs = 0; s_sessionStartedMs = 0; - LOG_INFO("EncryptedStorage: lockdown artifacts removed - device is no longer in lockdown"); + LOG_INFO("EncryptedStorage: lockdown artifacts removed - lockdown off"); } } // namespace EncryptedStorage diff --git a/src/serialization/MeshPacketSerializer.cpp b/src/serialization/MeshPacketSerializer.cpp index f889c4f3ca..a50bc747df 100644 --- a/src/serialization/MeshPacketSerializer.cpp +++ b/src/serialization/MeshPacketSerializer.cpp @@ -416,7 +416,7 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp, break; } } else if (shouldLog) { - LOG_WARN("Couldn't convert encrypted payload of MeshPacket to JSON"); + LOG_WARN("Can't convert encrypted payload of MeshPacket to JSON"); } jsonObj["id"] = (Json::UInt)mp->id; diff --git a/src/sleep.cpp b/src/sleep.cpp index 370c3338a1..c5d469b42a 100644 --- a/src/sleep.cpp +++ b/src/sleep.cpp @@ -611,18 +611,18 @@ void enableLoraInterrupt() loraFEMInterface.setRxModeEnableWhenMCUSleep(); #endif - LOG_INFO("setup LORA_DIO1 (GPIO%02d) with wakeup by gpio interrupt", LORA_DIO1); + LOG_INFO("Wake on LORA_DIO1 (GPIO%02d) gpio interrupt", LORA_DIO1); gpio_wakeup_enable((gpio_num_t)LORA_DIO1, GPIO_INTR_HIGH_LEVEL); #elif defined(LORA_DIO1) && (LORA_DIO1 != RADIOLIB_NC) if (radioType != RF95_RADIO) { - LOG_INFO("setup LORA_DIO1 (GPIO%02d) with wakeup by gpio interrupt", LORA_DIO1); + LOG_INFO("Wake on LORA_DIO1 (GPIO%02d) gpio interrupt", LORA_DIO1); gpio_wakeup_enable((gpio_num_t)LORA_DIO1, GPIO_INTR_HIGH_LEVEL); // SX126x/SX128x interrupt, active high } #endif #if defined(RF95_IRQ) && (RF95_IRQ != RADIOLIB_NC) if (radioType == RF95_RADIO) { - LOG_INFO("setup RF95_IRQ (GPIO%02d) with wakeup by gpio interrupt", RF95_IRQ); + LOG_INFO("Wake on RF95_IRQ (GPIO%02d) gpio interrupt", RF95_IRQ); gpio_wakeup_enable((gpio_num_t)RF95_IRQ, GPIO_INTR_HIGH_LEVEL); // RF95 interrupt, active high } #endif diff --git a/test/README.md b/test/README.md index 4074d94f51..d1dbd804c4 100644 --- a/test/README.md +++ b/test/README.md @@ -467,8 +467,8 @@ Unity suite, because what it asserts - the exit status and printed report of `meshtasticd --check`, and the fact that a normal run still refuses a bad config - are properties of the process, not of a linkable function. Fixtures live in `test/fixtures/portduino-config/` (see the README there); CI runs it in -`test_native.yml`. It is not counted in `native-suite-count`, which only tracks `test_*` -directories. +`test_native.yml`. It is not a `test_*` directory, so it sits outside the suite count the +harness derives from `test/`. ```bash pio run -e native && ./bin/test-config-check.sh @@ -476,10 +476,11 @@ pio run -e native && ./bin/test-config-check.sh ## Existing Test Suites -**This table is a description, not an inventory.** The canonical suite total lives in -`test/native-suite-count`, is machine-checked against `test/test_*` on every full run and in CI -(`test_native.yml`), and is the only number that should be trusted or quoted. Entries below carry -per-suite descriptions the count cannot; do not infer completeness from the row count. +**This table is a description, not an inventory.** The canonical suite total is the number of +`test_*` directories under `test/`, detected on the fly by `bin/run-tests.sh` on every full run +and cross-checked against the suites that actually ran. That derived count is the only number +that should be trusted or quoted. Entries below carry per-suite descriptions the count cannot; +do not infer completeness from the row count. | Suite | Module Under Test | | ---------------------------- | ----------------------------- | diff --git a/test/native-suite-count b/test/native-suite-count deleted file mode 100644 index c739b42c4d..0000000000 --- a/test/native-suite-count +++ /dev/null @@ -1 +0,0 @@ -44 diff --git a/test/test_airtime/test_main.cpp b/test/test_airtime/test_main.cpp new file mode 100644 index 0000000000..97adeac0cb --- /dev/null +++ b/test/test_airtime/test_main.cpp @@ -0,0 +1,196 @@ +// Unit tests for src/airtime.{h,cpp} - AirTime::syncNow() and its rolling windows. +// +// syncNow() replaced a per-second runOnce() tick with monotonic-uptime bucket rotation so windows +// stay correct across light sleep. It now takes its seconds from Time::getUptimeSecs(), which is a +// pure read of a carry the main loop publishes via Time::serviceMonotonic(); these tests exercise +// the rotation/decay math on top of that, including across the 32-bit millis() wrap. The wrap cases +// therefore step the clock the way the main loop does - advance, then publish. +#include "Arduino.h" +#include "TestUtil.h" +#include "UptimeClock.h" +#include "airtime.h" +#include +#include + +void setUp(void) +{ + // Absolute uptime assertions (e.g. getSecondsSinceBoot()) must not inherit wraps counted by + // an earlier case that moved the test clock backwards via setTestMillis(). + Time::resetMonotonicForTests(); +} +void tearDown(void) +{ + Time::useRealClock(); // don't leak the fake clock into other suites +} + +// --- first sync / immediate writes --- + +void test_logAirtime_writes_into_current_bucket_immediately() +{ + Time::setTestMillis(0); + AirTime a; + + a.logAirtime(TX_LOG, 100); + + TEST_ASSERT_EQUAL_UINT32(100, a.airtimeReport(TX_LOG)[0]); +} + +void test_getSecondsSinceBoot_tracks_elapsed_time() +{ + Time::setTestMillis(0); + AirTime a; + + TEST_ASSERT_EQUAL_UINT32(0, a.getSecondsSinceBoot()); + Time::advanceTestMillis(5000); + TEST_ASSERT_EQUAL_UINT32(5, a.getSecondsSinceBoot()); +} + +// --- hourly period rotation --- + +void test_period_rotates_after_one_hour() +{ + Time::setTestMillis(0); + AirTime a; + a.logAirtime(TX_LOG, 500); + + Time::advanceTestMillis(3600u * 1000u); // exactly one SECONDS_PER_PERIOD + + uint32_t *report = a.airtimeReport(TX_LOG); + TEST_ASSERT_EQUAL_UINT32(0, report[0]); // new period starts empty + TEST_ASSERT_EQUAL_UINT32(500, report[1]); // old period shifted back one slot +} + +// The property runOnce() alone could never exercise: several hours pass in a single sync (e.g. the +// device was light-sleeping), so the rotation has to walk forward more than one period at once. +void test_period_rotates_once_per_hour_crossed_while_asleep() +{ + Time::setTestMillis(0); + AirTime a; + a.logAirtime(TX_LOG, 200); + + Time::advanceTestMillis(3u * 3600u * 1000u); // 3 hours in one jump + + uint32_t *report = a.airtimeReport(TX_LOG); + TEST_ASSERT_EQUAL_UINT32(200, report[3]); + TEST_ASSERT_EQUAL_UINT32(0, report[0]); + TEST_ASSERT_EQUAL_UINT32(0, report[1]); + TEST_ASSERT_EQUAL_UINT32(0, report[2]); +} + +// More periods elapse than there are slots to rotate through: the whole history is stale, not just +// the oldest slot, so it must be wiped rather than rotated PERIODS_TO_LOG times. +void test_period_history_clears_when_asleep_longer_than_the_whole_log() +{ + Time::setTestMillis(0); + AirTime a; + a.logAirtime(TX_LOG, 999); + + Time::advanceTestMillis(9u * 3600u * 1000u); // 9 hours > PERIODS_TO_LOG (8) + + uint32_t *report = a.airtimeReport(TX_LOG); + for (uint8_t i = 0; i < a.getPeriodsToLog(); i++) { + TEST_ASSERT_EQUAL_UINT32_MESSAGE(0, report[i], "stale history must be cleared, not rotated in"); + } +} + +// --- channel utilization: rolling 60s window --- + +void test_channel_utilization_reflects_recent_airtime() +{ + Time::setTestMillis(0); + AirTime a; + a.logAirtime(RX_LOG, 6000); // 6s of airtime inside the 60s window + + TEST_ASSERT_FLOAT_WITHIN(0.01f, 10.0f, a.channelUtilizationPercent()); +} + +void test_channel_utilization_decays_once_the_60s_window_passes() +{ + Time::setTestMillis(0); + AirTime a; + a.logAirtime(RX_LOG, 6000); + + Time::advanceTestMillis(70u * 1000u); // longer than the 60s rolling window + + TEST_ASSERT_FLOAT_WITHIN(0.01f, 0.0f, a.channelUtilizationPercent()); +} + +void test_isTxAllowedChannelUtil_blocks_once_over_threshold() +{ + Time::setTestMillis(0); + AirTime a; + + TEST_ASSERT_TRUE(a.isTxAllowedChannelUtil()); // nothing logged yet + + a.logAirtime(RX_LOG, 25000); // 25s / 60s = 41.7%, over the 40% default max + TEST_ASSERT_FALSE(a.isTxAllowedChannelUtil()); +} + +// --- TX utilization: rolling 60-minute window --- + +void test_tx_utilization_decays_once_the_60_minute_window_passes() +{ + Time::setTestMillis(0); + AirTime a; + a.logAirtime(TX_LOG, 60000); // 1 minute of TX airtime + + TEST_ASSERT_TRUE(a.utilizationTXPercent() > 0.0f); + + Time::advanceTestMillis(61u * 60u * 1000u); // longer than the 60-minute rolling window + + TEST_ASSERT_FLOAT_WITHIN(0.01f, 0.0f, a.utilizationTXPercent()); +} + +// --- the headline property: syncNow() must survive the 32-bit millis() wrap --- + +void test_syncNow_survives_millis_wrap() +{ + const uint32_t beforeWrap = 4294967000u; // 296ms before the wrap, on a whole-second boundary + Time::setTestMillis(beforeWrap); + Time::serviceMonotonic(); // the main loop's publish, which is what carries the wrap + AirTime a; + + TEST_ASSERT_EQUAL_UINT32(4294967u, a.getSecondsSinceBoot()); + + Time::advanceTestMillis(1000); // crosses the wrap + Time::serviceMonotonic(); + TEST_ASSERT_EQUAL_UINT32(4294968u, a.getSecondsSinceBoot()); +} + +// A bucket logged just before the wrap must still be the one that rotates out after it - pinning +// the same property test_period_rotates_after_one_hour checks, but across the wrap boundary. +void test_period_rotation_survives_millis_wrap() +{ + const uint32_t beforeWrap = 0xFFFFFFFFu - (3600u * 1000u) + 1; // one hour minus 1ms before the wrap + Time::setTestMillis(beforeWrap); + Time::serviceMonotonic(); + AirTime a; + a.logAirtime(TX_LOG, 777); + + Time::advanceTestMillis(3600u * 1000u); // wraps partway through + Time::serviceMonotonic(); + + uint32_t *report = a.airtimeReport(TX_LOG); + TEST_ASSERT_EQUAL_UINT32(0, report[0]); + TEST_ASSERT_EQUAL_UINT32(777, report[1]); +} + +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + RUN_TEST(test_logAirtime_writes_into_current_bucket_immediately); + RUN_TEST(test_getSecondsSinceBoot_tracks_elapsed_time); + RUN_TEST(test_period_rotates_after_one_hour); + RUN_TEST(test_period_rotates_once_per_hour_crossed_while_asleep); + RUN_TEST(test_period_history_clears_when_asleep_longer_than_the_whole_log); + RUN_TEST(test_channel_utilization_reflects_recent_airtime); + RUN_TEST(test_channel_utilization_decays_once_the_60s_window_passes); + RUN_TEST(test_isTxAllowedChannelUtil_blocks_once_over_threshold); + RUN_TEST(test_tx_utilization_decays_once_the_60_minute_window_passes); + RUN_TEST(test_syncNow_survives_millis_wrap); + RUN_TEST(test_period_rotation_survives_millis_wrap); + exit(UNITY_END()); +} + +void loop() {} diff --git a/test/test_banner_font_tags/test_main.cpp b/test/test_banner_font_tags/test_main.cpp new file mode 100644 index 0000000000..4033c2785f --- /dev/null +++ b/test/test_banner_font_tags/test_main.cpp @@ -0,0 +1,176 @@ +// Regression tests for the alert-banner font-tag pipeline ([S]/[M]/[L] line prefixes). +// +// The BLE pairing banner (src/platform/nrf52/NRF52Bluetooth.cpp) sends +// "Bluetooth\nPIN\n[M]" with notification type pairing_pin. The [M] prefix is a +// font-change tag, never text: it must be stripped by parseBannerMessageWithFonts and, +// crucially, must also be stripped when a draw resolves a line the parsed cache doesn't +// cover (the shape of the historical bug where the pairing PIN rendered a literal "[M]"). +#include "MeshTypes.h" // Include BEFORE TestUtil.h (provides NodeNum, etc.) +#include "TestUtil.h" // initializeTestEnvironment() +#include + +#if HAS_SCREEN // Same guard as the module under test + +#include "graphics/draw/NotificationRenderer.h" +#include + +using graphics::NotificationRenderer; +using graphics::notificationTypeEnum; + +static const char *BLE_PIN_MESSAGE = "Bluetooth\nPIN\n[M]123 456"; + +// Reset every static the tests touch, so each case starts from a known state. +void setUp(void) +{ + NotificationRenderer::alertBannerMessage[0] = '\0'; + NotificationRenderer::parseBannerMessageWithFonts(""); + NotificationRenderer::alertBannerOptions = 0; + NotificationRenderer::current_notification_type = notificationTypeEnum::none; +} + +void tearDown(void) {} + +// Simulate Screen::showOverlayBanner storing and parsing a banner message. +static void showBanner(const char *message, notificationTypeEnum type, uint8_t options = 0) +{ + strncpy(NotificationRenderer::alertBannerMessage, message, 255); + NotificationRenderer::alertBannerMessage[255] = '\0'; + NotificationRenderer::parseBannerMessageWithFonts(NotificationRenderer::alertBannerMessage); + NotificationRenderer::alertBannerOptions = options; + NotificationRenderer::current_notification_type = type; +} + +// --- parseBannerMessageWithFonts --- + +void test_pairing_message_parses_and_strips_medium_tag() +{ + showBanner(BLE_PIN_MESSAGE, notificationTypeEnum::pairing_pin); + + TEST_ASSERT_EQUAL_UINT8(3, NotificationRenderer::alertBannerLineCount); + TEST_ASSERT_EQUAL_STRING("Bluetooth", NotificationRenderer::alertBannerLines[0]); + TEST_ASSERT_EQUAL_STRING("PIN", NotificationRenderer::alertBannerLines[1]); + TEST_ASSERT_EQUAL_STRING("123 456", NotificationRenderer::alertBannerLines[2]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_DEFAULT, NotificationRenderer::alertBannerLineFonts[0]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_DEFAULT, NotificationRenderer::alertBannerLineFonts[1]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_MEDIUM, NotificationRenderer::alertBannerLineFonts[2]); +} + +void test_small_and_large_tags_parse() +{ + showBanner("[S]small\n[L]large", notificationTypeEnum::text_banner); + + TEST_ASSERT_EQUAL_UINT8(2, NotificationRenderer::alertBannerLineCount); + TEST_ASSERT_EQUAL_STRING("small", NotificationRenderer::alertBannerLines[0]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_SMALL, NotificationRenderer::alertBannerLineFonts[0]); + TEST_ASSERT_EQUAL_STRING("large", NotificationRenderer::alertBannerLines[1]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_LARGE, NotificationRenderer::alertBannerLineFonts[1]); +} + +void test_unknown_tag_is_kept_as_text() +{ + showBanner("[X]hello", notificationTypeEnum::text_banner); + + TEST_ASSERT_EQUAL_STRING("[X]hello", NotificationRenderer::alertBannerLines[0]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_DEFAULT, NotificationRenderer::alertBannerLineFonts[0]); +} + +void test_tag_not_at_line_start_is_kept_as_text() +{ + showBanner("PIN [M]x", notificationTypeEnum::text_banner); + + TEST_ASSERT_EQUAL_STRING("PIN [M]x", NotificationRenderer::alertBannerLines[0]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_DEFAULT, NotificationRenderer::alertBannerLineFonts[0]); +} + +void test_tag_only_line_yields_empty_text_with_font() +{ + showBanner("[L]", notificationTypeEnum::text_banner); + + TEST_ASSERT_EQUAL_STRING("", NotificationRenderer::alertBannerLines[0]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_LARGE, NotificationRenderer::alertBannerLineFonts[0]); +} + +void test_lone_bracket_line_is_kept_as_text() +{ + showBanner("[", notificationTypeEnum::text_banner); + + TEST_ASSERT_EQUAL_STRING("[", NotificationRenderer::alertBannerLines[0]); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_DEFAULT, NotificationRenderer::alertBannerLineFonts[0]); +} + +// --- resolveBannerLine: what the draw code actually puts on the panel --- + +void test_resolve_uses_parsed_lines_for_pairing_pin() +{ + showBanner(BLE_PIN_MESSAGE, notificationTypeEnum::pairing_pin); + + NotificationRenderer::BannerFont font = NotificationRenderer::BANNER_FONT_DEFAULT; + const char *text = NotificationRenderer::resolveBannerLine(2, "[M]123 456", font); + TEST_ASSERT_EQUAL_STRING("123 456", text); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_MEDIUM, font); +} + +// The historical bug: the pairing banner drawn from the raw message, with the parsed-line +// cache not consulted (before the pairing_pin type was tag-aware) or not populated (a draw +// racing the parse from the BLE task). The tag must still act as a font change, not text. +void test_resolve_strips_tag_when_parsed_cache_missing() +{ + strncpy(NotificationRenderer::alertBannerMessage, BLE_PIN_MESSAGE, 255); + NotificationRenderer::current_notification_type = notificationTypeEnum::pairing_pin; + NotificationRenderer::alertBannerOptions = 0; + // Deliberately no parseBannerMessageWithFonts call: cache empty. + + NotificationRenderer::BannerFont font = NotificationRenderer::BANNER_FONT_DEFAULT; + const char *text = NotificationRenderer::resolveBannerLine(2, "[M]123 456", font); + TEST_ASSERT_EQUAL_STRING("123 456", text); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_MEDIUM, font); +} + +// Picker content can be user data (e.g. node names); it must never be tag-interpreted. +void test_resolve_leaves_picker_lines_untouched() +{ + NotificationRenderer::current_notification_type = notificationTypeEnum::node_picker; + NotificationRenderer::alertBannerOptions = 0; + + NotificationRenderer::BannerFont font = NotificationRenderer::BANNER_FONT_LARGE; + const char *text = NotificationRenderer::resolveBannerLine(0, "[M]allory", font); + TEST_ASSERT_EQUAL_STRING("[M]allory", text); + TEST_ASSERT_EQUAL(NotificationRenderer::BANNER_FONT_DEFAULT, font); +} + +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + + RUN_TEST(test_pairing_message_parses_and_strips_medium_tag); + RUN_TEST(test_small_and_large_tags_parse); + RUN_TEST(test_unknown_tag_is_kept_as_text); + RUN_TEST(test_tag_not_at_line_start_is_kept_as_text); + RUN_TEST(test_tag_only_line_yields_empty_text_with_font); + RUN_TEST(test_lone_bracket_line_is_kept_as_text); + + RUN_TEST(test_resolve_uses_parsed_lines_for_pairing_pin); + RUN_TEST(test_resolve_strips_tag_when_parsed_cache_missing); + RUN_TEST(test_resolve_leaves_picker_lines_untouched); + + exit(UNITY_END()); +} + +void loop() {} + +#else // !HAS_SCREEN + +void setUp(void) {} +void tearDown(void) {} + +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + exit(UNITY_END()); +} + +void loop() {} + +#endif // HAS_SCREEN diff --git a/test/test_event_channel_phone_api/test_main.cpp b/test/test_event_channel_phone_api/test_main.cpp new file mode 100644 index 0000000000..f7932b9c3f --- /dev/null +++ b/test/test_event_channel_phone_api/test_main.cpp @@ -0,0 +1,263 @@ +#include "Channels.h" +#include "MeshService.h" +#include "NodeDB.h" +#include "RadioInterface.h" +#include "Router.h" +#include "StreamAPI.h" +#include "TestUtil.h" +#include "mesh-pb-constants.h" +#include +#include +#include +#include + +namespace +{ +constexpr PacketId BLOCKED_PACKET_ID = 0x10203040; +constexpr PacketId FOLLOWUP_PACKET_ID = 0x50607080; +constexpr ChannelIndex EVENT_CHANNEL = 0; +constexpr ChannelIndex PRIVATE_CHANNEL = 1; +constexpr NodeNum REMOTE_NODE = 0x12345678; + +class MockRadioInterface : public RadioInterface +{ + public: + ErrorCode send(meshtastic_MeshPacket *packet) override + { + packetPool.release(packet); + return ERRNO_OK; + } + + uint32_t getPacketTime(uint32_t, bool) override { return 0; } +}; + +class MockRouter : public Router +{ + public: + MockRouter() { addInterface(std::make_unique()); } + + ~MockRouter() + { + delete cryptLock; + cryptLock = nullptr; + } + + ErrorCode send(meshtastic_MeshPacket *packet) override + { + sentPackets.push_back(*packet); + packetPool.release(packet); + return ERRNO_OK; + } + + std::vector sentPackets; +}; + +class MockMeshService : public MeshService +{ + public: + ~MockMeshService() + { + while (auto *status = getQueueStatusForPhone()) { + releaseQueueStatusToPool(status); + } + } + + void sendClientNotification(meshtastic_ClientNotification *notification) override + { + notifications.push_back(*notification); + releaseClientNotificationToPool(notification); + } + + void assertQueueStatus(PacketId packetId) + { + auto *status = getQueueStatusForPhone(); + TEST_ASSERT_NOT_NULL(status); + TEST_ASSERT_EQUAL_UINT32(packetId, status->mesh_packet_id); + releaseQueueStatusToPool(status); + } + + std::vector notifications; +}; + +class TestStreamAPI : public StreamAPI +{ + public: + TestStreamAPI() : StreamAPI(nullptr) {} + bool checkIsConnected() override { return true; } +}; + +struct GlobalState { + MeshService *service; + Router *router; + NodeDB *nodeDB; + // Router's ctor asserts !cryptLock and allocates one; ~MockRouter() deletes it. Save the + // incoming lock so the restored router keeps the one it was built with. + concurrency::Lock *cryptLock; + meshtastic_MyNodeInfo myNodeInfo; + Channels channels; + meshtastic_ChannelFile channelFile; + meshtastic_LocalConfig config; + meshtastic_LocalModuleConfig moduleConfig; + meshtastic_DeviceState deviceState; +}; + +GlobalState *savedState; +MockMeshService *mockService; +MockRouter *mockRouter; +NodeDB *mockNodeDB; +TestStreamAPI *streamAPI; + +void configureChannels() +{ + const meshtastic_ChannelFile defaultChannelFile = meshtastic_ChannelFile_init_default; + channelFile = defaultChannelFile; + channelFile.channels_count = 2; + + auto &eventChannel = channelFile.channels[EVENT_CHANNEL]; + eventChannel.index = EVENT_CHANNEL; + eventChannel.has_settings = true; + eventChannel.role = meshtastic_Channel_Role_PRIMARY; + strncpy(eventChannel.settings.name, "everyone", sizeof(eventChannel.settings.name) - 1); +#ifdef USERPREFS_CHANNEL_0_PSK + static const uint8_t eventPsk[] = USERPREFS_CHANNEL_0_PSK; + eventChannel.settings.psk.size = sizeof(eventPsk); + memcpy(eventChannel.settings.psk.bytes, eventPsk, sizeof(eventPsk)); +#endif + + auto &privateChannel = channelFile.channels[PRIVATE_CHANNEL]; + privateChannel.index = PRIVATE_CHANNEL; + privateChannel.has_settings = true; + privateChannel.role = meshtastic_Channel_Role_SECONDARY; + strncpy(privateChannel.settings.name, "private", sizeof(privateChannel.settings.name) - 1); + privateChannel.settings.psk.size = 32; + memset(privateChannel.settings.psk.bytes, 0xab, privateChannel.settings.psk.size); + + channels.onConfigChanged(); +} + +meshtastic_ToRadio makePositionToRadio(PacketId id, ChannelIndex channel) +{ + meshtastic_ToRadio message = meshtastic_ToRadio_init_default; + const meshtastic_MeshPacket defaultPacket = meshtastic_MeshPacket_init_default; + message.which_payload_variant = meshtastic_ToRadio_packet_tag; + message.packet = defaultPacket; + message.packet.to = REMOTE_NODE; + message.packet.id = id; + message.packet.channel = channel; + message.packet.which_payload_variant = meshtastic_MeshPacket_decoded_tag; + message.packet.decoded.portnum = meshtastic_PortNum_POSITION_APP; + return message; +} + +bool sendToRadio(const meshtastic_ToRadio &message) +{ + uint8_t encoded[meshtastic_ToRadio_size] = {}; + const size_t encodedSize = + pb_encode_to_bytes(encoded, sizeof(encoded), &meshtastic_ToRadio_msg, const_cast(&message)); + if (encodedSize == 0) { + return false; + } + return streamAPI->handleToRadio(encoded, encodedSize); +} + +void assertSentPacket(size_t index, PacketId id, ChannelIndex channel) +{ + TEST_ASSERT_GREATER_THAN(index, mockRouter->sentPackets.size()); + const auto &packet = mockRouter->sentPackets[index]; + TEST_ASSERT_EQUAL_UINT32(id, packet.id); + TEST_ASSERT_EQUAL_UINT8(channel, packet.channel); + TEST_ASSERT_EQUAL(meshtastic_PortNum_POSITION_APP, packet.decoded.portnum); +} +} // namespace + +void setUp(void) +{ + savedState = + new GlobalState{service, router, nodeDB, cryptLock, myNodeInfo, channels, channelFile, config, moduleConfig, devicestate}; + + service = mockService = new MockMeshService(); + nodeDB = mockNodeDB = new NodeDB(); + myNodeInfo.my_node_num = 0x87654321; + configureChannels(); + cryptLock = nullptr; // Router's ctor asserts this is unset before allocating its own. + router = mockRouter = new MockRouter(); + streamAPI = new TestStreamAPI(); + testDelay(1); +} + +void tearDown(void) +{ + delete streamAPI; + streamAPI = nullptr; + delete mockRouter; + mockRouter = nullptr; + delete mockNodeDB; + mockNodeDB = nullptr; + delete mockService; + mockService = nullptr; + + service = savedState->service; + router = savedState->router; + nodeDB = savedState->nodeDB; + cryptLock = savedState->cryptLock; // ~MockRouter() nulled it; hand the saved router its own back. + myNodeInfo = savedState->myNodeInfo; + channels = savedState->channels; + channelFile = savedState->channelFile; + config = savedState->config; + moduleConfig = savedState->moduleConfig; + devicestate = savedState->deviceState; + delete savedState; + savedState = nullptr; +} + +static void test_event_position_ingress_does_not_poison_retry_state() +{ + const auto eventAttempt = makePositionToRadio(BLOCKED_PACKET_ID, EVENT_CHANNEL); + const auto sameIdPrivateRetry = makePositionToRadio(BLOCKED_PACKET_ID, PRIVATE_CHANNEL); + const auto immediatePrivateFollowup = makePositionToRadio(FOLLOWUP_PACKET_ID, PRIVATE_CHANNEL); + +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + TEST_ASSERT_FALSE(sendToRadio(eventAttempt)); + TEST_ASSERT_EQUAL(0, mockRouter->sentPackets.size()); + mockService->assertQueueStatus(BLOCKED_PACKET_ID); + TEST_ASSERT_EQUAL(1, mockService->notifications.size()); + TEST_ASSERT_EQUAL_UINT32(BLOCKED_PACKET_ID, mockService->notifications[0].reply_id); + + TEST_ASSERT_TRUE(sendToRadio(sameIdPrivateRetry)); + TEST_ASSERT_EQUAL(1, mockRouter->sentPackets.size()); + assertSentPacket(0, BLOCKED_PACKET_ID, PRIVATE_CHANNEL); + mockService->assertQueueStatus(BLOCKED_PACKET_ID); + + TEST_ASSERT_FALSE(sendToRadio(immediatePrivateFollowup)); + TEST_ASSERT_EQUAL(1, mockRouter->sentPackets.size()); + mockService->assertQueueStatus(FOLLOWUP_PACKET_ID); + TEST_ASSERT_EQUAL(1, mockService->notifications.size()); +#else + TEST_ASSERT_TRUE(sendToRadio(eventAttempt)); + TEST_ASSERT_EQUAL(1, mockRouter->sentPackets.size()); + assertSentPacket(0, BLOCKED_PACKET_ID, EVENT_CHANNEL); + mockService->assertQueueStatus(BLOCKED_PACKET_ID); + TEST_ASSERT_EQUAL(0, mockService->notifications.size()); + + TEST_ASSERT_FALSE(sendToRadio(sameIdPrivateRetry)); + TEST_ASSERT_EQUAL(1, mockRouter->sentPackets.size()); + TEST_ASSERT_NULL(mockService->getQueueStatusForPhone()); + + TEST_ASSERT_FALSE(sendToRadio(immediatePrivateFollowup)); + TEST_ASSERT_EQUAL(1, mockRouter->sentPackets.size()); + mockService->assertQueueStatus(FOLLOWUP_PACKET_ID); + TEST_ASSERT_EQUAL(0, mockService->notifications.size()); +#endif +} + +extern "C" { +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + RUN_TEST(test_event_position_ingress_does_not_poison_retry_state); + exit(UNITY_END()); +} + +void loop() {} +} diff --git a/test/test_event_channel_router/test_main.cpp b/test/test_event_channel_router/test_main.cpp new file mode 100644 index 0000000000..c1f5e8becc --- /dev/null +++ b/test/test_event_channel_router/test_main.cpp @@ -0,0 +1,405 @@ +#include "MeshTypes.h" +#include "TestUtil.h" +#include + +#include "airtime.h" +#include "mesh/Channels.h" +#include "mesh/CryptoEngine.h" +#include "mesh/MeshModule.h" +#include "mesh/MeshRadio.h" +#include "mesh/MeshService.h" +#include "mesh/NodeDB.h" +#include "mesh/Router.h" +#if ARCH_PORTDUINO +#include "platform/portduino/PortduinoGlue.h" +#endif +#include +#include +#include +#include +#include +#include + +#if ARCH_PORTDUINO +#define EVENT_ROUTER_TEST_ENTRY extern "C" +#else +#define EVENT_ROUTER_TEST_ENTRY +#endif + +namespace +{ + +constexpr NodeNum kLocalNode = 0x11111111; +constexpr NodeNum kRemoteNode = 0x22222222; +constexpr NodeNum kPkiPeer = 0x33333333; +constexpr ChannelIndex kEventChannel = 0; +constexpr ChannelIndex kPrivateChannel = 1; + +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL +constexpr bool kBlockEventCoordinates = true; +constexpr ErrorCode kExpectedEventTxResult = meshtastic_Routing_Error_NOT_AUTHORIZED; +constexpr size_t kExpectedEventDeliveryCount = 0; +#else +constexpr bool kBlockEventCoordinates = false; +constexpr ErrorCode kExpectedEventTxResult = ERRNO_OK; +constexpr size_t kExpectedEventDeliveryCount = 3; +#endif + +constexpr std::array kCoordinatePorts = { + meshtastic_PortNum_POSITION_APP, + meshtastic_PortNum_WAYPOINT_APP, + meshtastic_PortNum_MAP_REPORT_APP, +}; + +class TestNodeDB : public NodeDB +{ + public: + void clearTestNodes() + { + testNodes.clear(); + meshNodes = &testNodes; + numMeshNodes = 0; + } + + void addNode(NodeNum num, ChannelIndex channel, const uint8_t *publicKey = nullptr) + { + meshtastic_NodeInfoLite node = meshtastic_NodeInfoLite_init_zero; + node.num = num; + node.channel = channel; + if (publicKey) { + node.public_key.size = 32; + memcpy(node.public_key.bytes, publicKey, 32); + } + testNodes.push_back(node); + meshNodes = &testNodes; + numMeshNodes = testNodes.size(); + } + + private: + std::vector testNodes; +}; + +class CaptureRadio : public RadioInterface +{ + public: + ErrorCode send(meshtastic_MeshPacket *packet) override + { + packets.push_back(*packet); + packetPool.release(packet); + return ERRNO_OK; + } + + uint32_t getPacketTime(uint32_t, bool = false) override { return 0; } + + std::vector packets; +}; + +class CaptureModule : public MeshModule +{ + public: + CaptureModule() : MeshModule("event-router-capture") { encryptedOk = true; } + + bool wantPacket(const meshtastic_MeshPacket *) override { return true; } + + ProcessMessage handleReceived(const meshtastic_MeshPacket &packet) override + { + packets.push_back(packet); + return ProcessMessage::CONTINUE; + } + + std::vector packets; +}; + +struct SavedGlobals { + meshtastic_LocalConfig config; + meshtastic_LocalModuleConfig moduleConfig; + meshtastic_ChannelFile channelFile; + meshtastic_User owner; + meshtastic_MyNodeInfo myNodeInfo; + NodeDB *nodeDB; + Router *router; + MeshService *service; + AirTime *airTime; + concurrency::Lock *cryptLock; +#if ARCH_PORTDUINO + bool forceSimRadio; +#endif +}; + +SavedGlobals saved; +TestNodeDB *testNodeDB = nullptr; +Router *testRouter = nullptr; +CaptureRadio *captureRadio = nullptr; +CaptureModule *captureModule = nullptr; +AirTime *testAirTime = nullptr; + +static void installChannels() +{ + memset(&channelFile, 0, sizeof(channelFile)); + channelFile.channels_count = 2; + + meshtastic_Channel &event = channelFile.channels[kEventChannel]; + memset(&event, 0, sizeof(event)); + event.index = kEventChannel; + event.role = meshtastic_Channel_Role_PRIMARY; + event.has_settings = true; + strncpy(event.settings.name, "everyone", sizeof(event.settings.name) - 1); +#ifdef USERPREFS_CHANNEL_0_PSK + static const uint8_t eventKey[] = USERPREFS_CHANNEL_0_PSK; + static_assert(sizeof(eventKey) == 16 || sizeof(eventKey) == 32); + event.settings.psk.size = sizeof(eventKey); + memcpy(event.settings.psk.bytes, eventKey, sizeof(eventKey)); +#else + static const uint8_t eventKey[16] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}; + event.settings.psk.size = sizeof(eventKey); + memcpy(event.settings.psk.bytes, eventKey, sizeof(eventKey)); +#endif + + meshtastic_Channel &privateChannel = channelFile.channels[kPrivateChannel]; + memset(&privateChannel, 0, sizeof(privateChannel)); + privateChannel.index = kPrivateChannel; + privateChannel.role = meshtastic_Channel_Role_SECONDARY; + privateChannel.has_settings = true; + strncpy(privateChannel.settings.name, "private", sizeof(privateChannel.settings.name) - 1); + privateChannel.settings.psk.size = 32; + for (size_t i = 0; i < privateChannel.settings.psk.size; ++i) + privateChannel.settings.psk.bytes[i] = static_cast(0x80 + i); + + channels.onConfigChanged(); +} + +static meshtastic_MeshPacket makeDecodedPacket(meshtastic_PortNum port, NodeNum from, NodeNum to, ChannelIndex channel) +{ + meshtastic_MeshPacket packet = meshtastic_MeshPacket_init_zero; + packet.from = from; + packet.to = to; + packet.id = 0x40000000u + static_cast(port); + packet.channel = channel; + packet.hop_start = 3; + packet.hop_limit = 3; + packet.which_payload_variant = meshtastic_MeshPacket_decoded_tag; + packet.decoded.portnum = port; + + if (port == meshtastic_PortNum_POSITION_APP) { + meshtastic_Position position = meshtastic_Position_init_zero; + position.has_latitude_i = true; + position.latitude_i = 374221234; + position.has_longitude_i = true; + position.longitude_i = -1220845678; + packet.decoded.payload.size = pb_encode_to_bytes(packet.decoded.payload.bytes, sizeof(packet.decoded.payload.bytes), + &meshtastic_Position_msg, &position); + } else { + packet.decoded.payload.size = 1; + packet.decoded.payload.bytes[0] = 0x5a; + } + return packet; +} + +static ErrorCode sendCoordinate(meshtastic_PortNum port, ChannelIndex channel, NodeNum to = NODENUM_BROADCAST) +{ + meshtastic_MeshPacket *packet = testRouter->allocForSending(); + TEST_ASSERT_NOT_NULL(packet); + const meshtastic_MeshPacket contents = makeDecodedPacket(port, kLocalNode, to, channel); + packet->to = contents.to; + packet->channel = contents.channel; + packet->decoded = contents.decoded; + return testRouter->send(packet); +} + +static void receivePacket(const meshtastic_MeshPacket &contents) +{ + meshtastic_MeshPacket *packet = packetPool.allocCopy(contents); + TEST_ASSERT_NOT_NULL(packet); + testRouter->enqueueReceivedMessage(packet); + testRouter->runOnce(); +} + +static void test_tx_event_channel_enforces_compile_time_policy_for_all_coordinate_ports() +{ + TEST_ASSERT_EQUAL(kBlockEventCoordinates, channels.isEventChannel(kEventChannel)); + + for (meshtastic_PortNum port : kCoordinatePorts) { + const size_t before = captureRadio->packets.size(); + TEST_ASSERT_EQUAL_INT(kExpectedEventTxResult, sendCoordinate(port, kEventChannel)); + TEST_ASSERT_EQUAL_UINT32(before + (kBlockEventCoordinates ? 0 : 1), captureRadio->packets.size()); + } +} + +static void test_rx_event_channel_enforces_compile_time_policy_for_all_coordinate_ports() +{ + for (meshtastic_PortNum port : kCoordinatePorts) + receivePacket(makeDecodedPacket(port, kRemoteNode, NODENUM_BROADCAST, kEventChannel)); + + TEST_ASSERT_EQUAL_UINT32(kExpectedEventDeliveryCount, captureModule->packets.size()); +} + +static void test_private_channel_preserves_legacy_tx_and_rx_for_all_coordinate_ports() +{ + TEST_ASSERT_FALSE(channels.isEventChannel(kPrivateChannel)); + + for (meshtastic_PortNum port : kCoordinatePorts) { + TEST_ASSERT_EQUAL_INT(ERRNO_OK, sendCoordinate(port, kPrivateChannel)); + receivePacket(makeDecodedPacket(port, kRemoteNode, NODENUM_BROADCAST, kPrivateChannel)); + } + + TEST_ASSERT_EQUAL_UINT32(kCoordinatePorts.size(), captureRadio->packets.size()); + TEST_ASSERT_EQUAL_UINT32(kCoordinatePorts.size(), captureModule->packets.size()); +} + +#if !(MESHTASTIC_EXCLUDE_PKI) +static void test_tx_event_coordinate_that_uses_pki_reaches_radio() +{ + uint8_t peerPublic[32], peerPrivate[32]; + uint8_t localPublic[32], localPrivate[32]; + crypto->generateKeyPair(peerPublic, peerPrivate); + crypto->generateKeyPair(localPublic, localPrivate); + + config.has_security = true; + config.security.private_key.size = 32; + config.security.public_key.size = 32; + memcpy(config.security.private_key.bytes, localPrivate, 32); + memcpy(config.security.public_key.bytes, localPublic, 32); + crypto->setDHPrivateKey(localPrivate); + testNodeDB->addNode(kPkiPeer, kEventChannel, peerPublic); + + TEST_ASSERT_EQUAL_INT(ERRNO_OK, sendCoordinate(meshtastic_PortNum_WAYPOINT_APP, kEventChannel, kPkiPeer)); + TEST_ASSERT_EQUAL_UINT32(1, captureRadio->packets.size()); + TEST_ASSERT_TRUE(captureRadio->packets.front().pki_encrypted); + TEST_ASSERT_EQUAL(meshtastic_MeshPacket_encrypted_tag, captureRadio->packets.front().which_payload_variant); +} +#endif + +static void test_opaque_tx_is_not_misclassified_as_coordinates() +{ + meshtastic_MeshPacket *outgoing = testRouter->allocForSending(); + TEST_ASSERT_NOT_NULL(outgoing); + outgoing->channel = channels.getHash(kEventChannel); + outgoing->which_payload_variant = meshtastic_MeshPacket_encrypted_tag; + outgoing->encrypted.size = 1; + outgoing->encrypted.bytes[0] = 0xa5; + + TEST_ASSERT_EQUAL_INT(ERRNO_OK, testRouter->send(outgoing)); + TEST_ASSERT_EQUAL_UINT32(1, captureRadio->packets.size()); +} + +static void test_capture_endpoints_release_packet_pool_ownership() +{ + constexpr size_t iterations = 64; + for (size_t i = 0; i < iterations; ++i) { + meshtastic_MeshPacket *outgoing = testRouter->allocForSending(); + TEST_ASSERT_NOT_NULL(outgoing); + outgoing->channel = kPrivateChannel; + outgoing->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP; + outgoing->decoded.payload.size = 1; + outgoing->decoded.payload.bytes[0] = static_cast(i); + TEST_ASSERT_EQUAL_INT(ERRNO_OK, testRouter->send(outgoing)); + + meshtastic_MeshPacket incoming = + makeDecodedPacket(meshtastic_PortNum_TEXT_MESSAGE_APP, kRemoteNode, NODENUM_BROADCAST, kPrivateChannel); + incoming.id += i; + receivePacket(incoming); + } + + TEST_ASSERT_EQUAL_UINT32(iterations, captureRadio->packets.size()); + TEST_ASSERT_EQUAL_UINT32(iterations, captureModule->packets.size()); +} + +} // namespace + +void setUp(void) +{ + saved.config = config; + saved.moduleConfig = moduleConfig; + saved.channelFile = channelFile; + saved.owner = owner; + saved.myNodeInfo = myNodeInfo; + saved.nodeDB = nodeDB; + saved.router = router; + saved.service = service; + saved.airTime = airTime; + saved.cryptLock = cryptLock; +#if ARCH_PORTDUINO + saved.forceSimRadio = portduino_config.force_simradio; +#endif + + testNodeDB = new TestNodeDB(); + testNodeDB->clearTestNodes(); + nodeDB = testNodeDB; + + memset(&config, 0, sizeof(config)); + config.lora.override_duty_cycle = true; + config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT; + memset(&moduleConfig, 0, sizeof(moduleConfig)); + memset(&owner, 0, sizeof(owner)); + memset(&myNodeInfo, 0, sizeof(myNodeInfo)); + myNodeInfo.my_node_num = kLocalNode; + service = nullptr; +#if ARCH_PORTDUINO + portduino_config.force_simradio = false; +#endif + installChannels(); + + testAirTime = new AirTime(); + airTime = testAirTime; + + cryptLock = nullptr; + testRouter = new Router(); + router = testRouter; + std::unique_ptr radio(new CaptureRadio()); + captureRadio = radio.get(); + testRouter->addInterface(std::move(radio)); + captureModule = new CaptureModule(); +} + +void tearDown(void) +{ + delete captureModule; + captureModule = nullptr; + + router = nullptr; + delete testRouter; + testRouter = nullptr; + captureRadio = nullptr; + delete cryptLock; + cryptLock = saved.cryptLock; + + delete testNodeDB; + testNodeDB = nullptr; + delete testAirTime; + testAirTime = nullptr; + + config = saved.config; + moduleConfig = saved.moduleConfig; + channelFile = saved.channelFile; + owner = saved.owner; + myNodeInfo = saved.myNodeInfo; + channels.onConfigChanged(); + nodeDB = saved.nodeDB; + router = saved.router; + service = saved.service; + airTime = saved.airTime; +#if ARCH_PORTDUINO + portduino_config.force_simradio = saved.forceSimRadio; +#endif +} + +EVENT_ROUTER_TEST_ENTRY void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + + printf("\n=== Router event-channel coordinate enforcement ===\n"); + RUN_TEST(test_tx_event_channel_enforces_compile_time_policy_for_all_coordinate_ports); + RUN_TEST(test_rx_event_channel_enforces_compile_time_policy_for_all_coordinate_ports); + RUN_TEST(test_private_channel_preserves_legacy_tx_and_rx_for_all_coordinate_ports); +#if !(MESHTASTIC_EXCLUDE_PKI) + RUN_TEST(test_tx_event_coordinate_that_uses_pki_reaches_radio); +#endif + RUN_TEST(test_opaque_tx_is_not_misclassified_as_coordinates); + RUN_TEST(test_capture_endpoints_release_packet_pool_ownership); + + exit(UNITY_END()); +} + +EVENT_ROUTER_TEST_ENTRY void loop() {} diff --git a/test/test_geocoord_distance/test_main.cpp b/test/test_geocoord_distance/test_main.cpp new file mode 100644 index 0000000000..de3430f1c3 --- /dev/null +++ b/test/test_geocoord_distance/test_main.cpp @@ -0,0 +1,165 @@ +#include "configuration.h" +#include "gps/GeoCoord.h" +#include +#include +#include + +void setUp(void) {} +void tearDown(void) {} + +// Pins latLongToMeter()'s equirectangular-approximation accuracy against the original spherical +// law of cosines, so a future change can't silently regress it. + +static constexpr double kPi = 3.14159265358979323846; + +static double referenceSphericalLawOfCosines(double lat_a, double lng_a, double lat_b, double lng_b) +{ + double a1 = lat_a * kPi / 180.0; + double a2 = lng_a * kPi / 180.0; + double b1 = lat_b * kPi / 180.0; + double b2 = lng_b * kPi / 180.0; + double t1 = std::cos(a1) * std::cos(a2) * std::cos(b1) * std::cos(b2); + double t2 = std::cos(a1) * std::sin(a2) * std::cos(b1) * std::sin(b2); + double t3 = std::sin(a1) * std::sin(b1); + double arg = t1 + t2 + t3; + if (arg > 1.0) + arg = 1.0; + if (arg < -1.0) + arg = -1.0; + return 6366000 * std::acos(arg); +} + +// Below ~1m, relative error is dominated by rounding noise rather than the formula itself, so +// assert an absolute bound instead (still catches a badly-broken implementation). +static constexpr double kNearZeroAbsoluteToleranceMeters = 0.5; + +// An order of magnitude above what the implementation currently produces per group - tight enough to +// catch a regression, loose enough not to track float rounding. Groups differ because +// equirectangular error grows with both separation and latitude. +static constexpr double kLocalTolerancePercent = 0.01; +static constexpr double kRegionalTolerancePercent = 0.1; +static constexpr double kHighLatitudeTolerancePercent = 0.2; +static constexpr double kAntimeridianTolerancePercent = 0.01; + +static void assertWithinPercent(double expected, double actual, double pct, const char *msg) +{ + if (expected < 1.0) { + if (std::fabs(actual - expected) > kNearZeroAbsoluteToleranceMeters) { + char buf[160]; + snprintf(buf, sizeof(buf), "%s: expected=%.3f actual=%.3f (near-zero, limit %.1fm absolute)", msg, expected, actual, + kNearZeroAbsoluteToleranceMeters); + TEST_FAIL_MESSAGE(buf); + } + return; + } + double err = std::fabs(actual - expected) / expected * 100.0; + if (err > pct) { + char buf[160]; + snprintf(buf, sizeof(buf), "%s: expected=%.1f actual=%.1f err=%.2f%% (limit %.2f%%)", msg, expected, actual, err, pct); + TEST_FAIL_MESSAGE(buf); + } +} + +static void test_identical_points_is_zero(void) +{ + TEST_ASSERT_EQUAL_FLOAT(0.0f, GeoCoord::latLongToMeter(51.5, -0.1, 51.5, -0.1)); +} + +static void test_local_distances(void) +{ + // Movement-threshold scale (meters to a few km) - the most common real usage. + struct { + double la, lo, lb, lob; + } cases[] = { + {51.5074, -0.1278, 51.5080, -0.1278}, // ~67m north + {51.5074, -0.1278, 51.5074, -0.1200}, // ~540m east at London's latitude + {0.0, 0.0, 0.001, 0.001}, // ~157m near the equator + {65.0, 25.0, 65.001, 25.002}, // high-ish latitude, small delta + {-33.87, 151.21, -33.865, 151.215}, // Sydney, southern hemisphere + }; + for (auto &c : cases) { + double expected = referenceSphericalLawOfCosines(c.la, c.lo, c.lb, c.lob); + double actual = GeoCoord::latLongToMeter(c.la, c.lo, c.lb, c.lob); + assertWithinPercent(expected, actual, kLocalTolerancePercent, "local distance"); + } +} + +static void test_regional_distances(void) +{ + // City-to-city scale (tens to ~500km) below 60 degrees; see test_high_latitude_distances. + struct { + double la, lo, lb, lob; + } cases[] = { + {51.5074, -0.1278, 48.8566, 2.3522}, // London to Paris, ~344km + {40.7128, -74.0060, 42.3601, -71.0589}, // NYC to Boston, ~306km + {35.6762, 139.6503, 34.6937, 135.5023}, // Tokyo to Osaka, ~400km + {-33.8688, 151.2093, -37.8136, 144.9631}, // Sydney to Melbourne, ~714km + }; + for (auto &c : cases) { + double expected = referenceSphericalLawOfCosines(c.la, c.lo, c.lb, c.lob); + double actual = GeoCoord::latLongToMeter(c.la, c.lo, c.lb, c.lob); + assertWithinPercent(expected, actual, kRegionalTolerancePercent, "regional distance"); + } +} + +static void test_high_latitude_distances(void) +{ + // Regional scale above 60 degrees, where equirectangular error grows fastest - a 500km pair at + // 80 degrees already exceeds 1%. + struct { + double la, lo, lb, lob; + } cases[] = { + {69.6492, 18.9553, 67.2804, 14.4049}, // Tromso to Bodo, ~322km + {64.8378, -147.7164, 61.2181, -149.9003}, // Fairbanks to Anchorage, ~417km + {78.2232, 15.6469, 78.9230, 11.9219}, // Longyearbyen to Ny-Alesund, ~113km + }; + for (auto &c : cases) { + double expected = referenceSphericalLawOfCosines(c.la, c.lo, c.lb, c.lob); + double actual = GeoCoord::latLongToMeter(c.la, c.lo, c.lb, c.lob); + assertWithinPercent(expected, actual, kHighLatitudeTolerancePercent, "high-latitude distance"); + } +} + +static void test_antimeridian_wraparound(void) +{ + // Two points ~22km apart straddling the 180th meridian - regression case for the antimeridian + // wraparound fix (a naive b2-a2 would compute this as ~40,000km). + double expected = referenceSphericalLawOfCosines(0.0, 179.9, 0.0, -179.9); + double actual = GeoCoord::latLongToMeter(0.0, 179.9, 0.0, -179.9); + assertWithinPercent(expected, actual, kAntimeridianTolerancePercent, "antimeridian distance"); + TEST_ASSERT_LESS_THAN_FLOAT(1000000.0f, actual); // sanity: nowhere near the naive-bug's ~40,000km +} + +static void test_symmetry(void) +{ + // distance(a,b) should equal distance(b,a) + double d1 = GeoCoord::latLongToMeter(51.5074, -0.1278, 48.8566, 2.3522); + double d2 = GeoCoord::latLongToMeter(48.8566, 2.3522, 51.5074, -0.1278); + TEST_ASSERT_FLOAT_WITHIN(0.01f, d1, d2); +} + +static void test_no_nan_at_extreme_latitudes(void) +{ + float d1 = GeoCoord::latLongToMeter(90.0, 0.0, -90.0, 0.0); + float d2 = GeoCoord::latLongToMeter(89.9, 10.0, 89.9, -170.0); + float d3 = GeoCoord::latLongToMeter(-89.9, 45.0, -89.9, -135.0); + TEST_ASSERT_FALSE(std::isnan(d1)); + TEST_ASSERT_FALSE(std::isnan(d2)); + TEST_ASSERT_FALSE(std::isnan(d3)); + TEST_ASSERT_TRUE(d1 > 0); +} + +void setup() +{ + UNITY_BEGIN(); + RUN_TEST(test_identical_points_is_zero); + RUN_TEST(test_local_distances); + RUN_TEST(test_regional_distances); + RUN_TEST(test_high_latitude_distances); + RUN_TEST(test_antimeridian_wraparound); + RUN_TEST(test_symmetry); + RUN_TEST(test_no_nan_at_extreme_latitudes); + exit(UNITY_END()); +} + +void loop() {} diff --git a/test/test_gps_fix_hold/test_main.cpp b/test/test_gps_fix_hold/test_main.cpp new file mode 100644 index 0000000000..c6a4aec5e1 --- /dev/null +++ b/test/test_gps_fix_hold/test_main.cpp @@ -0,0 +1,218 @@ +// Unit tests for shouldArmFixHold() / fixHoldInForce() in src/gps/GPS.cpp - the post-lock +// ephemeris hold. +// +// In power-saving mode (gps_update_interval above GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS) the GPS holds +// for up to 20s after a lock to download ephemeris, then publishes and sleeps. The predicate below +// decides, once per GPS thread cycle that has a location, whether a hold should be armed. +// +// The case that matters is a hold that was consumed by a publish which did not sleep: GPS::runOnce() +// clears fixHoldEnds whenever it publishes, but only calls down() when the search timed out or a +// hold expired. If the predicate treats "not holding" as a reason to skip, nothing re-arms, nothing +// publishes, and the receiver stays powered until searchedTooLong() fires. +#include "Arduino.h" +#include "TestUtil.h" +#include "Throttle.h" +#include "UptimeClock.h" +#include +#include + +// The predicates live beside their only caller in src/gps/GPS.cpp rather than in a header of their +// own; the native test build compiles that file, so declaring the prototypes here is enough. A +// signature change breaks the link rather than silently diverging from the definition. +bool fixHoldInForce(uint32_t fixHoldEnds, uint32_t threadIntervalMs); +bool holdJustExpired(uint32_t fixHoldEnds); +bool shouldArmFixHold(bool hasValidLocation, uint8_t prevFixQual, uint32_t fixHoldEnds, uint32_t threadIntervalMs); + +// GPS_THREAD_INTERVAL, spelled out so the suite does not pull in GPS.h and its hardware deps. +static constexpr uint32_t kThreadInterval = 200; + +// The two hold durations the firmware uses: GPS_FIX_HOLD_MAX_MS, and a short one. +static constexpr uint32_t kHoldMs = 20 * 1000; + +void setUp(void) +{ + Time::setTestMillis(0); +} +void tearDown(void) +{ + Time::useRealClock(); +} + +// Arms a hold at the current test time and returns the resulting fixHoldEnds. +static uint32_t armHoldNow(uint32_t holdMs = kHoldMs) +{ + return Time::getMillis() + holdMs; +} + +// --- the reasons to arm --- + +// First lock of a cycle: hasValidLocation is still false on the rising edge. +void test_arms_on_the_first_lock_of_a_cycle(void) +{ + Time::setTestMillis(50 * 1000); + TEST_ASSERT_TRUE(shouldArmFixHold(false, 3, 0, kThreadInterval)); +} + +// Lock after the receiver was off: down() zeroes fixQual, so prev_fixQual is 0 on the way back up. +void test_arms_on_the_first_lock_after_the_gps_was_off(void) +{ + Time::setTestMillis(50 * 1000); + TEST_ASSERT_TRUE(shouldArmFixHold(true, 0, 0, kThreadInterval)); +} + +// The regression. A publish that did not sleep leaves hasValidLocation set, prev_fixQual non-zero +// and fixHoldEnds cleared to 0. Nothing else in runOnce() re-arms, so if this returns false the +// GPS never holds, never publishes again and never calls down() until the search times out. +void test_arms_after_a_publish_cleared_the_hold_without_sleeping(void) +{ + Time::setTestMillis(50 * 1000); + TEST_ASSERT_TRUE_MESSAGE(shouldArmFixHold(true, 3, 0, kThreadInterval), + "fixHoldEnds == 0 means 'not holding', which is a reason to arm"); +} + +void test_arms_once_the_hold_has_expired(void) +{ + Time::setTestMillis(50 * 1000); + const uint32_t fixHoldEnds = armHoldNow(); + + Time::advanceTestMillis(kHoldMs + kThreadInterval); + TEST_ASSERT_TRUE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); +} + +// --- the reason not to arm --- + +void test_does_not_arm_while_a_hold_is_in_force(void) +{ + Time::setTestMillis(50 * 1000); + const uint32_t fixHoldEnds = armHoldNow(); + + Time::advanceTestMillis(kHoldMs / 2); + TEST_ASSERT_FALSE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); +} + +// The GPS_THREAD_INTERVAL grace period: at the exact deadline the hold has not yet expired, because +// the next cycle is one interval away. +void test_does_not_arm_in_the_thread_interval_grace_after_the_deadline(void) +{ + Time::setTestMillis(50 * 1000); + const uint32_t fixHoldEnds = armHoldNow(); + + Time::advanceTestMillis(kHoldMs); // exactly at the deadline + TEST_ASSERT_FALSE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); + + Time::advanceTestMillis(kThreadInterval - 1); + TEST_ASSERT_FALSE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); + + Time::advanceTestMillis(1); // deadline + GPS_THREAD_INTERVAL, inclusive boundary + TEST_ASSERT_TRUE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); +} + +// --- across the 32-bit wrap --- + +// A hold armed just before the wrap must still be held through it. The naive form this replaced +// (`(fixHoldEnds + GPS_THREAD_INTERVAL) < millis()`) read as expired for the whole pre-wrap window, +// re-arming the hold on every single cycle. +void test_does_not_arm_while_a_hold_straddling_the_wrap_is_in_force(void) +{ + Time::setTestMillis(0xFFFFFF00u); // 256ms short of the wrap + const uint32_t fixHoldEnds = armHoldNow(); + + TEST_ASSERT_FALSE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); + + Time::advanceTestMillis(0x200u); // now past the wrap, still inside the hold + TEST_ASSERT_FALSE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); + + Time::advanceTestMillis(kHoldMs); // well past the deadline, still past the wrap + TEST_ASSERT_TRUE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); +} + +// The deadline itself wrapping (fixHoldEnds numerically below millis()) must not read as expired. +void test_holds_when_the_deadline_wraps_but_now_has_not(void) +{ + Time::setTestMillis(0xFFFFFF00u); + const uint32_t fixHoldEnds = armHoldNow(); // wraps to ~0x4CFF + + TEST_ASSERT_TRUE_MESSAGE(fixHoldEnds < Time::getMillis(), "test setup: the deadline must have wrapped"); + TEST_ASSERT_FALSE(shouldArmFixHold(true, 3, fixHoldEnds, kThreadInterval)); +} + +// --- the two readings of the same sentinel --- + +// runOnce() asks two questions of fixHoldEnds and they take opposite answers when nothing is armed: +// "should I arm one?" (yes) and "did one just expire, so publish and sleep?" (no). Both are derived +// from fixHoldInForce(), which is the only place the sentinel is interpreted. +void test_no_hold_means_arm_but_does_not_mean_expired(void) +{ + Time::setTestMillis(50 * 1000); + + TEST_ASSERT_FALSE_MESSAGE(fixHoldInForce(0, kThreadInterval), "a hold that was never armed is not in force"); + TEST_ASSERT_TRUE_MESSAGE(shouldArmFixHold(true, 3, 0, kThreadInterval), "...so it is a reason to arm one"); + TEST_ASSERT_FALSE_MESSAGE(holdJustExpired(0), "...but not a reason to publish and sleep"); +} + +// holdJustExpired()'s sentinel guard is load-bearing on every cycle, not just past the half-range: +// fixHoldInForce() calls an unarmed hold "not in force", so negating it alone reads as expired. +void test_only_an_armed_hold_can_expire(void) +{ + Time::setTestMillis(50 * 1000); + const uint32_t fixHoldEnds = armHoldNow(); + + TEST_ASSERT_FALSE_MESSAGE(holdJustExpired(fixHoldEnds), "still inside the hold"); + + Time::advanceTestMillis(kHoldMs); // the deadline itself, no grace interval at this site + TEST_ASSERT_TRUE_MESSAGE(holdJustExpired(fixHoldEnds), "the deadline is the moment to publish and sleep"); + + TEST_ASSERT_TRUE_MESSAGE(!fixHoldInForce(0, 0), "test premise: the negation alone calls an unarmed hold expired"); + TEST_ASSERT_FALSE_MESSAGE(holdJustExpired(0), "so the sentinel test is what keeps it from expiring"); +} + +// The `fixHoldEnds != 0` term inside fixHoldInForce() looks redundant, and for the first half of +// each wrap cycle it is: deadlinePassed(0 + interval) is true once uptime exceeds one interval, so +// "not in force" would fall out of the arithmetic on its own. Past 2^31 ms of uptime it flips. +// deadlinePassed() is an unsigned half-range test, so `now - interval` lands in the top half and +// the sentinel reads as a deadline ~24.8 days in the FUTURE - an unarmed hold would look like one +// in force for the whole second half of every cycle, and nothing would ever re-arm. +void test_the_sentinel_guard_is_load_bearing_past_the_half_range(void) +{ + Time::setTestMillis(0x90000000u); // ~27.8 days of uptime, past the ~24.8-day half-range point + + // The arithmetic alone now says "not yet" for the sentinel... + TEST_ASSERT_FALSE_MESSAGE(Throttle::deadlinePassed(0 + kThreadInterval), + "test premise: past half-range the sentinel reads as a future deadline"); + + // ...so the explicit sentinel test is the only thing keeping the answer right. + TEST_ASSERT_FALSE_MESSAGE(fixHoldInForce(0, kThreadInterval), "an unarmed hold is never in force"); + TEST_ASSERT_TRUE_MESSAGE(shouldArmFixHold(true, 3, 0, kThreadInterval), "...so a hold must still be armed"); +} + +void test_hold_in_force_tracks_the_deadline(void) +{ + Time::setTestMillis(50 * 1000); + const uint32_t fixHoldEnds = armHoldNow(); + + TEST_ASSERT_TRUE(fixHoldInForce(fixHoldEnds, kThreadInterval)); + + Time::advanceTestMillis(kHoldMs + kThreadInterval); + TEST_ASSERT_FALSE(fixHoldInForce(fixHoldEnds, kThreadInterval)); +} + +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + RUN_TEST(test_no_hold_means_arm_but_does_not_mean_expired); + RUN_TEST(test_only_an_armed_hold_can_expire); + RUN_TEST(test_the_sentinel_guard_is_load_bearing_past_the_half_range); + RUN_TEST(test_hold_in_force_tracks_the_deadline); + RUN_TEST(test_arms_on_the_first_lock_of_a_cycle); + RUN_TEST(test_arms_on_the_first_lock_after_the_gps_was_off); + RUN_TEST(test_arms_after_a_publish_cleared_the_hold_without_sleeping); + RUN_TEST(test_arms_once_the_hold_has_expired); + RUN_TEST(test_does_not_arm_while_a_hold_is_in_force); + RUN_TEST(test_does_not_arm_in_the_thread_interval_grace_after_the_deadline); + RUN_TEST(test_does_not_arm_while_a_hold_straddling_the_wrap_is_in_force); + RUN_TEST(test_holds_when_the_deadline_wraps_but_now_has_not); + exit(UNITY_END()); +} + +void loop() {} diff --git a/test/test_gps_update_scheduling/test_main.cpp b/test/test_gps_update_scheduling/test_main.cpp new file mode 100644 index 0000000000..00c01c0f60 --- /dev/null +++ b/test/test_gps_update_scheduling/test_main.cpp @@ -0,0 +1,91 @@ +#include "Arduino.h" +#include "TestUtil.h" +#include "gps/GPSUpdateScheduling.h" +#include +#include +#include + +void setUp(void) {} +void tearDown(void) {} + +// Confirms gpsHardsleepThresholdMs()'s pow()-free lookup table tracks the original +// `2750 * pow(seconds, 1.22)` curve closely. +static double originalFormula(uint32_t seconds) +{ + return 2750.0 * std::pow((double)seconds, 1.22); +} + +static void test_matches_original_formula_at_sampled_points(void) +{ + // Off-breakpoint values only - a breakpoint interpolates exactly by construction, so it would + // test nothing here (test_exact_at_table_breakpoints covers those). Includes both worst-error + // inputs: 7s (1.60%) and 728s (0.55%). Capped at 900s, the pre-existing 15-minute search clamp. + const uint32_t samples[] = {4, 6, 7, 8, 9, 33, 100, 150, 500, 728, 899}; + for (uint32_t s : samples) { + double expected = originalFormula(s); + uint32_t actual = gpsHardsleepThresholdMs(s); + // Pure integer arithmetic, so results are bit-identical everywhere - no float noise to + // leave headroom for, and these sit just above the measured worst cases. + double tolerance = expected * (s < 10 ? 0.02 : 0.0075); + TEST_ASSERT_DOUBLE_WITHIN(tolerance, expected, (double)actual); + } +} + +static void test_zero_seconds_is_zero(void) +{ + TEST_ASSERT_EQUAL_UINT32(0, gpsHardsleepThresholdMs(0)); +} + +static void test_monotonically_nondecreasing(void) +{ + uint32_t prev = gpsHardsleepThresholdMs(0); + for (uint32_t s = 1; s <= 1200; s += 7) { + uint32_t cur = gpsHardsleepThresholdMs(s); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(prev, cur); + prev = cur; + } +} + +static void test_exact_at_table_breakpoints(void) +{ + // Every breakpoint must return its own sampled value. Catches an off-by-one in the segment + // scan, which a percentage bound on interpolated points would absorb. + const uint32_t breakpoints[] = {0, 1, 2, 3, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 240, 300, 450, 600, 900}; + for (uint32_t s : breakpoints) { + char msg[64]; + snprintf(msg, sizeof(msg), "breakpoint %us", s); + // Within 2ms, not exact: the 30s entry is rounded 1ms high, and pow() can differ by an ULP + // across libm implementations. A real off-by-one in the scan misses by thousands. + TEST_ASSERT_UINT32_WITHIN_MESSAGE(2, (uint32_t)(originalFormula(s) + 0.5), gpsHardsleepThresholdMs(s), msg); + } +} + +static void test_clamps_above_table_range(void) +{ + uint32_t atMax = gpsHardsleepThresholdMs(900); + TEST_ASSERT_EQUAL_UINT32(atMax, gpsHardsleepThresholdMs(2000)); + TEST_ASSERT_EQUAL_UINT32(atMax, gpsHardsleepThresholdMs(UINT32_MAX)); +} + +static void test_clamp_boundary(void) +{ + // The clamp must engage exactly at the last table point, not before or after it. + TEST_ASSERT_LESS_THAN_UINT32(gpsHardsleepThresholdMs(900), gpsHardsleepThresholdMs(899)); + TEST_ASSERT_EQUAL_UINT32(gpsHardsleepThresholdMs(900), gpsHardsleepThresholdMs(901)); +} + +void setup() +{ + delay(10); + initializeTestEnvironment(); + UNITY_BEGIN(); + RUN_TEST(test_matches_original_formula_at_sampled_points); + RUN_TEST(test_zero_seconds_is_zero); + RUN_TEST(test_monotonically_nondecreasing); + RUN_TEST(test_exact_at_table_breakpoints); + RUN_TEST(test_clamps_above_table_range); + RUN_TEST(test_clamp_boundary); + exit(UNITY_END()); +} + +void loop() {} diff --git a/test/test_meshpacket_serializer/ports/test_timestamp.cpp b/test/test_meshpacket_serializer/ports/test_timestamp.cpp index 333945f80a..d6e38bcf1e 100644 --- a/test/test_meshpacket_serializer/ports/test_timestamp.cpp +++ b/test/test_meshpacket_serializer/ports/test_timestamp.cpp @@ -21,7 +21,7 @@ void test_timestamp_zeroed_when_rx_time_absent() std::string json = MeshPacketSerializer::JsonSerialize(&packet, false); Json::Value root = parse_json(json); TEST_ASSERT_TRUE(root.isMember("timestamp")); - TEST_ASSERT_EQUAL_UINT32(0u, root["timestamp"].asUInt()); // must not leak the millis() placeholder + TEST_ASSERT_EQUAL_UINT32(0u, root["timestamp"].asUInt()); // must not leak the uptime placeholder } void test_encrypted_timestamp_zeroed_when_rx_time_absent() diff --git a/test/test_meshpacket_serializer/test_helpers.h b/test/test_meshpacket_serializer/test_helpers.h index 2dc06cec78..63447d5092 100644 --- a/test/test_meshpacket_serializer/test_helpers.h +++ b/test/test_meshpacket_serializer/test_helpers.h @@ -70,7 +70,7 @@ static meshtastic_MeshPacket create_test_packet_no_rx_time(meshtastic_PortNum po int payload_variant = meshtastic_MeshPacket_decoded_tag) { meshtastic_MeshPacket packet = create_test_packet(port, payload, payload_size, payload_variant); - packet.rx_time = 123456; // a plausible millis() placeholder, not a real epoch + packet.rx_time = 123456; // a plausible uptime-seconds placeholder, not a real epoch packet.has_rx_time = false; return packet; } diff --git a/test/test_mqtt/MQTT.cpp b/test/test_mqtt/MQTT.cpp index e2d006e382..3c4f1ab6af 100644 --- a/test/test_mqtt/MQTT.cpp +++ b/test/test_mqtt/MQTT.cpp @@ -338,16 +338,64 @@ const meshtastic_MeshPacket encrypted = { .encrypted = {.size = 0}, .id = 3, }; + +void configureCoordinatePolicyChannels(bool eventChannelIsPrimary = true) +{ + memset(&channelFile, 0, sizeof(channelFile)); + channelFile.channels_count = 2; + + auto &eventChannel = channelFile.channels[0]; + eventChannel.index = 0; + eventChannel.has_settings = true; + strncpy(eventChannel.settings.name, "everyone", sizeof(eventChannel.settings.name) - 1); + eventChannel.settings.uplink_enabled = true; + eventChannel.settings.downlink_enabled = true; + eventChannel.role = eventChannelIsPrimary ? meshtastic_Channel_Role_PRIMARY : meshtastic_Channel_Role_SECONDARY; +#ifdef USERPREFS_CHANNEL_0_PSK + static const uint8_t configuredEventPsk[] = USERPREFS_CHANNEL_0_PSK; + eventChannel.settings.psk.size = sizeof(configuredEventPsk); + memcpy(eventChannel.settings.psk.bytes, configuredEventPsk, sizeof(configuredEventPsk)); +#endif + + auto &privateChannel = channelFile.channels[1]; + privateChannel.index = 1; + privateChannel.has_settings = true; + strncpy(privateChannel.settings.name, "private", sizeof(privateChannel.settings.name) - 1); + privateChannel.settings.psk.size = 32; + memset(privateChannel.settings.psk.bytes, 0xab, privateChannel.settings.psk.size); + privateChannel.settings.uplink_enabled = true; + privateChannel.settings.downlink_enabled = true; + privateChannel.role = eventChannelIsPrimary ? meshtastic_Channel_Role_SECONDARY : meshtastic_Channel_Role_PRIMARY; + + channels.onConfigChanged(); +} + +meshtastic_MeshPacket makePositionPacket(ChannelIndex channel) +{ + meshtastic_MeshPacket packet = decoded; + packet.to = NODENUM_BROADCAST; + packet.channel = channel; + packet.decoded.portnum = meshtastic_PortNum_POSITION_APP; + return packet; +} + +void clearPublicationState() +{ + TEST_ASSERT_EQUAL(0, unitTest->queueSize()); + pubsub->published_.clear(); + mockMeshService->messages_.clear(); +} } // namespace // Initialize mocks and configuration before running each test. void setUp(void) { - config = meshtastic_LocalConfig_init_zero; + memset(&config, 0, sizeof(config)); moduleConfig.mqtt = meshtastic_ModuleConfig_MQTTConfig{.enabled = true, .map_reporting_enabled = true, .has_map_report_settings = true}; moduleConfig.mqtt.map_report_settings = meshtastic_ModuleConfig_MapReportSettings{ .publish_interval_secs = 0, .position_precision = 14, .should_report_location = true}; + memset(&channelFile, 0, sizeof(channelFile)); channelFile.channels[0] = meshtastic_Channel{ .index = 0, .has_settings = true, @@ -355,6 +403,7 @@ void setUp(void) .role = meshtastic_Channel_Role_PRIMARY, }; channelFile.channels_count = 1; + channels.onConfigChanged(); owner = meshtastic_User{.id = "!12345678"}; myNodeInfo = meshtastic_MyNodeInfo{.my_node_num = 0x12345678}; // Match the expected gateway ID in topic localPosition = @@ -412,6 +461,50 @@ void test_sendDirectlyConnectedEncrypted(void) TEST_ASSERT_EQUAL(encrypted.id, env.packet->id); } +void test_eventPositionPublicationFollowsCompileTimePolicy(void) +{ + configureCoordinatePolicyChannels(); + clearPublicationState(); + const meshtastic_MeshPacket position = makePositionPacket(0); + + mqtt->onSend(encrypted, position, 0); + +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + TEST_ASSERT_TRUE(pubsub->published_.empty()); + TEST_ASSERT_EQUAL(0, unitTest->queueSize()); +#else + TEST_ASSERT_EQUAL(1, pubsub->published_.size()); +#endif +} + +void test_privatePositionStillPublishesWithEventPolicy(void) +{ + configureCoordinatePolicyChannels(); + clearPublicationState(); + const meshtastic_MeshPacket position = makePositionPacket(1); + + mqtt->onSend(encrypted, position, 1); + + TEST_ASSERT_EQUAL(1, pubsub->published_.size()); + TEST_ASSERT_EQUAL_STRING("msh/2/e/private/!12345678", pubsub->published_.front().first.c_str()); +} + +void test_explicitPkiPositionStillPublishesWithEventPolicy(void) +{ + configureCoordinatePolicyChannels(); + clearPublicationState(); + meshtastic_MeshPacket position = makePositionPacket(0); + meshtastic_MeshPacket encryptedPki = encrypted; + position.to = 2; + position.pki_encrypted = true; + encryptedPki.pki_encrypted = true; + + mqtt->onSend(encryptedPki, position, 0); + + TEST_ASSERT_EQUAL(1, pubsub->published_.size()); + TEST_ASSERT_EQUAL_STRING("msh/2/e/PKI/!12345678", pubsub->published_.front().first.c_str()); +} + // Verify that the decoded MeshPacket is proxied through the MeshService when encryption_enabled = false. void test_proxyToMeshServiceDecoded(void) { @@ -918,6 +1011,32 @@ void test_reportToMapDefaultImprecise(void) TEST_ASSERT_EQUAL_STRING("msh/2/map/", topic.c_str()); } +void test_eventPrimaryMapReportFollowsCompileTimePolicy(void) +{ + configureCoordinatePolicyChannels(); + clearPublicationState(); + + unitTest->reportToMap(); + +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + TEST_ASSERT_TRUE(pubsub->published_.empty()); + TEST_ASSERT_EQUAL(0, unitTest->queueSize()); +#else + TEST_ASSERT_EQUAL(1, pubsub->published_.size()); +#endif +} + +void test_privatePrimaryMapReportStillPublishesWithEventPolicy(void) +{ + configureCoordinatePolicyChannels(false); + clearPublicationState(); + + unitTest->reportToMap(); + + TEST_ASSERT_EQUAL(1, pubsub->published_.size()); + TEST_ASSERT_EQUAL_STRING("msh/2/map/", pubsub->published_.front().first.c_str()); +} + // Location is sent over the phone proxy. void test_reportToMapImpreciseProxied(void) { @@ -1135,6 +1254,9 @@ void setup() UNITY_BEGIN(); RUN_TEST(test_sendDirectlyConnectedDecoded); RUN_TEST(test_sendDirectlyConnectedEncrypted); + RUN_TEST(test_eventPositionPublicationFollowsCompileTimePolicy); + RUN_TEST(test_privatePositionStillPublishesWithEventPolicy); + RUN_TEST(test_explicitPkiPositionStillPublishesWithEventPolicy); RUN_TEST(test_proxyToMeshServiceDecoded); RUN_TEST(test_proxyToMeshServiceEncrypted); RUN_TEST(test_dontMqttMeOnPublicServer); @@ -1171,6 +1293,8 @@ void setup() RUN_TEST(test_publishTextMessageDirect); RUN_TEST(test_publishTextMessageWithProxy); RUN_TEST(test_reportToMapDefaultImprecise); + RUN_TEST(test_eventPrimaryMapReportFollowsCompileTimePolicy); + RUN_TEST(test_privatePrimaryMapReportStillPublishesWithEventPolicy); RUN_TEST(test_reportToMapImpreciseProxied); RUN_TEST(test_usingDefaultServer); RUN_TEST(test_usingDefaultServerWithPort); diff --git a/test/test_nexthop_routing/test_main.cpp b/test/test_nexthop_routing/test_main.cpp index 7d3dd9eec8..45dfa8c4ac 100644 --- a/test/test_nexthop_routing/test_main.cpp +++ b/test/test_nexthop_routing/test_main.cpp @@ -11,15 +11,21 @@ #include "TestUtil.h" #include +#include "airtime.h" #include "configuration.h" #include "gps/RTC.h" #include "mesh/Default.h" #include "mesh/NextHopRouter.h" #include "mesh/NodeDB.h" #include "mesh/RadioInterface.h" +#include "mesh/ReliableRouter.h" +#include "modules/RoutingModule.h" #include #include +#include #include +#include +#include #define MSG_BUF_LEN 200 #define TEST_MSG_FMT(fmt, ...) \ @@ -30,6 +36,13 @@ } while (0) static constexpr NodeNum kLocalNode = 0x11111111; // last byte 0x11 +static constexpr NodeNum kRemoteNode = 0x22222222; + +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) +static constexpr bool kEventPolicyEnabled = true; +#else +static constexpr bool kEventPolicyEnabled = false; +#endif // --------------------------------------------------------------------------- // MockNodeDB - inject nodes with controlled last byte, hop distance, age, role, favorite flag. @@ -93,6 +106,15 @@ class NextHopRouterTestShim : public NextHopRouter using NextHopRouter::relayOpaquePacket; using Router::shouldDecrementHopLimit; // protected in Router + bool filterViaFlooding(const meshtastic_MeshPacket *p) { return FloodingRouter::shouldFilterReceived(p); } + bool filterViaNextHop(const meshtastic_MeshPacket *p) { return NextHopRouter::shouldFilterReceived(p); } + + void clearPendingForTest() + { + while (!pending.empty()) + stopRetransmission(pending.begin()->first); + } + void resetRouteHealthForTest() { for (auto &h : routeHealth) @@ -100,10 +122,8 @@ class NextHopRouterTestShim : public NextHopRouter } }; -// --------------------------------------------------------------------------- -// MockRadioInterface - mirrors RadioLibInterface::send()'s NODENUM_BROADCAST_NO_LORA branch, which -// returns ERRNO_SHOULD_RELEASE without releasing. -// --------------------------------------------------------------------------- +// Mirrors RadioLibInterface::send()'s NODENUM_BROADCAST_NO_LORA branch, which +// returns ERRNO_SHOULD_RELEASE without releasing the packet. class MockRadioInterface : public RadioInterface { public: @@ -132,8 +152,137 @@ class MockRadioInterface : public RadioInterface uint8_t lastHopStart = 0; }; +class CaptureRadioInterface : public RadioInterface +{ + public: + ErrorCode send(meshtastic_MeshPacket *p) override + { + sentPackets.push_back(*p); + packetPool.release(p); + return ERRNO_OK; + } + + bool cancelSending(NodeNum from, PacketId id) override + { + (void)from; + (void)id; + cancelCount++; + return false; + } + + bool findInTxQueue(NodeNum from, PacketId id) override + { + (void)from; + (void)id; + return false; + } + + uint32_t getPacketTime(uint32_t totalPacketLen, bool received = false) override + { + (void)totalPacketLen; + (void)received; + return 0; + } + + void reset() + { + sentPackets.clear(); + cancelCount = 0; + } + + std::vector sentPackets; + uint32_t cancelCount = 0; +}; + +class ReliableRouterTestShim : public ReliableRouter +{ + public: + ReliableRouterTestShim() : ReliableRouter() {} + + size_t pendingCount() const { return pending.size(); } + + void seedRetry(const meshtastic_MeshPacket &p, uint8_t attempts) + { + auto *copy = packetPool.allocCopy(p); + TEST_ASSERT_NOT_NULL(copy); + startRetransmission(copy, attempts); + } + + void makeRetryDue(NodeNum from, PacketId id) + { + PendingPacket *record = findPendingPacket(from, id); + TEST_ASSERT_NOT_NULL(record); + record->nextTxMsec = 0; + } + + int32_t runDueRetries() { return doRetransmissions(); } + void sniffForTest(const meshtastic_MeshPacket *p, const meshtastic_Routing *routing) + { + ReliableRouter::sniffReceived(p, routing); + } + + void clearPendingForTest() + { + while (!pending.empty()) + stopRetransmission(pending.begin()->first); + } +}; + +class MockRoutingModule : public RoutingModule +{ + public: + void sendAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex, uint8_t hopLimit = 0, + bool ackWantsAck = false) override + { + ackNaks.emplace_back(err, to, idFrom, chIndex, hopLimit, ackWantsAck); + } + + std::list> ackNaks; +}; + +class ScopedAirTimeFixture +{ + public: + ScopedAirTimeFixture() : previous(airTime) { airTime = &instance; } + ~ScopedAirTimeFixture() { airTime = previous; } + + private: + AirTime instance; + AirTime *previous; +}; + +static meshtastic_MeshPacket makeRebroadcastCandidate(NodeNum to) +{ + meshtastic_MeshPacket p = meshtastic_MeshPacket_init_zero; + p.from = kRemoteNode; + p.to = to; + p.id = 0x0BADF00D; + p.hop_start = 3; + p.hop_limit = 3; + p.next_hop = NO_NEXT_HOP_PREFERENCE; + p.which_payload_variant = meshtastic_MeshPacket_encrypted_tag; + p.encrypted.size = 8; + return p; +} + static MockNodeDB *mockNodeDB = nullptr; static NextHopRouterTestShim *shim = nullptr; +static ReliableRouterTestShim *reliableShim = nullptr; +static CaptureRadioInterface *nextHopRadio = nullptr; +static CaptureRadioInterface *reliableRadio = nullptr; +static MockRoutingModule *mockRoutingModule = nullptr; +static std::unique_ptr airTimeFixture; +static PacketId nextBehaviorPacketId = 0x70000000; + +static MockRadioInterface *installMockIface() +{ + MockRadioInterface *mock = new MockRadioInterface(); + // addInterface replaces and destroys the suite's original capture interface. + // Clear its borrowed pointer before the next Unity setUp() runs. + nextHopRadio = nullptr; + shim->addInterface(std::unique_ptr(mock)); + return mock; +} static constexpr uint32_t TTL = NextHopRouter::ROUTE_TTL_MSEC; static constexpr uint8_t THRESH = NextHopRouter::ROUTE_FAILURE_THRESHOLD; @@ -150,12 +299,84 @@ static meshtastic_MeshPacket makeRelayedPacket(uint8_t relay, uint8_t hopsAway) return p; } +static meshtastic_Channel makeBehaviorChannel(meshtastic_Channel_Role role, const char *name) +{ + meshtastic_Channel channel = meshtastic_Channel_init_default; + channel.has_settings = true; + channel.role = role; + channel.settings.has_module_settings = true; + channel.settings.module_settings.position_precision = 16; + strncpy(channel.settings.name, name, sizeof(channel.settings.name) - 1); + return channel; +} + +static void configureBehaviorChannels() +{ + memset(&channelFile, 0, sizeof(channelFile)); + channelFile.channels_count = 2; + + meshtastic_Channel eventChannel = makeBehaviorChannel(meshtastic_Channel_Role_PRIMARY, "everyone"); + eventChannel.index = 0; +#ifdef USERPREFS_CHANNEL_0_PSK + static const uint8_t eventPsk[] = USERPREFS_CHANNEL_0_PSK; + eventChannel.settings.psk.size = sizeof(eventPsk); + memcpy(eventChannel.settings.psk.bytes, eventPsk, sizeof(eventPsk)); +#endif + + meshtastic_Channel privateChannel = makeBehaviorChannel(meshtastic_Channel_Role_SECONDARY, "private"); + privateChannel.index = 1; + privateChannel.settings.psk.size = 32; + memset(privateChannel.settings.psk.bytes, 0xAB, privateChannel.settings.psk.size); + + channelFile.channels[0] = eventChannel; + channelFile.channels[1] = privateChannel; + channels.onConfigChanged(); +} + +static meshtastic_MeshPacket makeBehaviorPacket(meshtastic_PortNum portnum, NodeNum from, NodeNum to, uint8_t channel, + bool wantAck = false) +{ + meshtastic_MeshPacket p = meshtastic_MeshPacket_init_zero; + p.from = from; + p.to = to; + p.id = nextBehaviorPacketId++; + p.channel = channel; + p.hop_start = 3; + p.hop_limit = 3; + p.relay_node = 0x22; + p.next_hop = NO_NEXT_HOP_PREFERENCE; + p.want_ack = wantAck; + p.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA; + p.which_payload_variant = meshtastic_MeshPacket_decoded_tag; + p.decoded.portnum = portnum; + return p; +} + +static meshtastic_MeshPacket *allocBehaviorPacket(meshtastic_PortNum portnum, NodeNum to, uint8_t channel, bool wantAck) +{ + auto packet = makeBehaviorPacket(portnum, kLocalNode, to, channel, wantAck); + auto *allocated = packetPool.allocCopy(packet); + TEST_ASSERT_NOT_NULL(allocated); + return allocated; +} + void setUp(void) { myNodeInfo.my_node_num = kLocalNode; config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT; + config.device.rebroadcast_mode = meshtastic_Config_DeviceConfig_RebroadcastMode_ALL; + config.lora.override_duty_cycle = true; + config.security.private_key.size = 0; + owner.is_licensed = false; mockNodeDB->clearTestNodes(); shim->resetRouteHealthForTest(); + shim->clearPendingForTest(); + reliableShim->clearPendingForTest(); + if (nextHopRadio) + nextHopRadio->reset(); + reliableRadio->reset(); + mockRoutingModule->ackNaks.clear(); + configureBehaviorChannels(); } void tearDown(void) {} @@ -446,33 +667,112 @@ void test_hoplimit_decrement_when_resolved_not_favorite(void) } // =========================================================================== -// Rebroadcast of NODENUM_BROADCAST_NO_LORA +// Group 5 - event-coordinate routing behavior // =========================================================================== -static MockRadioInterface *installMockIface() +void test_eventPolicy_reliableOriginSendSuppressesTxAndPending(void) { - MockRadioInterface *m = new MockRadioInterface(); - shim->addInterface(std::unique_ptr(m)); - return m; + ErrorCode result = reliableShim->send( + allocBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, NODENUM_BROADCAST, /*event channel=*/0, /*wantAck=*/true)); + + if (kEventPolicyEnabled) { + TEST_ASSERT_EQUAL_INT(meshtastic_Routing_Error_NOT_AUTHORIZED, result); + TEST_ASSERT_EQUAL_UINT32(0, reliableRadio->sentPackets.size()); + TEST_ASSERT_EQUAL_UINT32(0, reliableShim->pendingCount()); + } else { + TEST_ASSERT_EQUAL_INT(ERRNO_OK, result); + TEST_ASSERT_EQUAL_UINT32(1, reliableRadio->sentPackets.size()); + TEST_ASSERT_EQUAL_UINT32(1, reliableShim->pendingCount()); + } } -// Eligible for rebroadcast: not from/to us, hops left, nonzero id, no next-hop preference. -// Encrypted variant so Router::send() skips the encode path. -static meshtastic_MeshPacket makeRebroadcastCandidate(NodeNum to) +void test_eventPolicy_reliablePrivateCoordinateStillSends(void) { - meshtastic_MeshPacket p = meshtastic_MeshPacket_init_zero; - p.from = 0x22222222; // not us - p.to = to; - p.id = 0x0BADF00D; - p.hop_start = 3; - p.hop_limit = 3; - p.next_hop = NO_NEXT_HOP_PREFERENCE; - p.which_payload_variant = meshtastic_MeshPacket_encrypted_tag; - p.encrypted.size = 8; - return p; + ErrorCode result = reliableShim->send( + allocBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, NODENUM_BROADCAST, /*private channel=*/1, /*wantAck=*/true)); + + TEST_ASSERT_EQUAL_INT(ERRNO_OK, result); + TEST_ASSERT_EQUAL_UINT32(1, reliableRadio->sentPackets.size()); + TEST_ASSERT_EQUAL_UINT32(1, reliableShim->pendingCount()); +} + +void test_eventPolicy_floodingDuplicateSuppressesCoordinateButRelaysText(void) +{ + mockNodeDB->addNode(kRemoteNode, 0, true, 0); + auto coordinate = makeBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, kRemoteNode, NODENUM_BROADCAST, 0); + TEST_ASSERT_FALSE(shim->filterViaFlooding(&coordinate)); + TEST_ASSERT_TRUE(shim->filterViaFlooding(&coordinate)); + TEST_ASSERT_EQUAL_UINT32(kEventPolicyEnabled ? 0 : 1, nextHopRadio->sentPackets.size()); + + nextHopRadio->reset(); + auto text = makeBehaviorPacket(meshtastic_PortNum_TEXT_MESSAGE_APP, kRemoteNode, NODENUM_BROADCAST, 0); + TEST_ASSERT_FALSE(shim->filterViaFlooding(&text)); + TEST_ASSERT_TRUE(shim->filterViaFlooding(&text)); + TEST_ASSERT_EQUAL_UINT32(1, nextHopRadio->sentPackets.size()); +} + +void test_eventPolicy_nextHopDuplicateSuppressesEventButRelaysPrivateCoordinate(void) +{ + mockNodeDB->addNode(kRemoteNode, 0, true, 0); + auto eventCoordinate = makeBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, kRemoteNode, NODENUM_BROADCAST, 0); + TEST_ASSERT_FALSE(shim->filterViaNextHop(&eventCoordinate)); + TEST_ASSERT_TRUE(shim->filterViaNextHop(&eventCoordinate)); + TEST_ASSERT_EQUAL_UINT32(kEventPolicyEnabled ? 0 : 1, nextHopRadio->sentPackets.size()); + + nextHopRadio->reset(); + auto privateCoordinate = makeBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, kRemoteNode, NODENUM_BROADCAST, 1); + TEST_ASSERT_FALSE(shim->filterViaNextHop(&privateCoordinate)); + TEST_ASSERT_TRUE(shim->filterViaNextHop(&privateCoordinate)); + TEST_ASSERT_EQUAL_UINT32(1, nextHopRadio->sentPackets.size()); +} + +void test_eventPolicy_repeatedLocalPacketSuppressesCoordinateAckButKeepsTextAck(void) +{ + mockNodeDB->addNode(kRemoteNode, 0, true, 0); + auto coordinate = makeBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, kRemoteNode, kLocalNode, 0, /*wantAck=*/true); + TEST_ASSERT_FALSE(shim->filterViaNextHop(&coordinate)); + TEST_ASSERT_TRUE(shim->filterViaNextHop(&coordinate)); + TEST_ASSERT_EQUAL_UINT32(kEventPolicyEnabled ? 0 : 1, mockRoutingModule->ackNaks.size()); + + mockRoutingModule->ackNaks.clear(); + auto text = makeBehaviorPacket(meshtastic_PortNum_TEXT_MESSAGE_APP, kRemoteNode, kLocalNode, 0, /*wantAck=*/true); + TEST_ASSERT_FALSE(shim->filterViaNextHop(&text)); + TEST_ASSERT_TRUE(shim->filterViaNextHop(&text)); + TEST_ASSERT_EQUAL_UINT32(1, mockRoutingModule->ackNaks.size()); + const auto &ack = mockRoutingModule->ackNaks.front(); + TEST_ASSERT_EQUAL_INT(meshtastic_Routing_Error_NONE, std::get<0>(ack)); + TEST_ASSERT_EQUAL_HEX32(kRemoteNode, std::get<1>(ack)); + TEST_ASSERT_EQUAL_HEX32(text.id, std::get<2>(ack)); +} + +void test_eventPolicy_seededRetrySuppressesTxUntilGateOff(void) +{ + auto coordinate = makeBehaviorPacket(meshtastic_PortNum_WAYPOINT_APP, kLocalNode, NODENUM_BROADCAST, 0, /*wantAck=*/true); + reliableShim->seedRetry(coordinate, /*attempts=*/2); + reliableShim->makeRetryDue(kLocalNode, coordinate.id); + + reliableShim->runDueRetries(); + + TEST_ASSERT_EQUAL_UINT32(kEventPolicyEnabled ? 0 : 1, reliableRadio->sentPackets.size()); + TEST_ASSERT_EQUAL_UINT32(1, reliableShim->pendingCount()); +} + +void test_reliableAckStopsNormalPendingTransmission(void) +{ + auto original = makeBehaviorPacket(meshtastic_PortNum_TEXT_MESSAGE_APP, kLocalNode, kRemoteNode, 1, /*wantAck=*/true); + reliableShim->seedRetry(original, NextHopRouter::NUM_RELIABLE_RETX); + TEST_ASSERT_EQUAL_UINT32(1, reliableShim->pendingCount()); + + auto ack = makeBehaviorPacket(meshtastic_PortNum_ROUTING_APP, kRemoteNode, kLocalNode, 1); + ack.decoded.request_id = original.id; + meshtastic_Routing routing = meshtastic_Routing_init_zero; + routing.error_reason = meshtastic_Routing_Error_NONE; + + reliableShim->sniffForTest(&ack, &routing); + + TEST_ASSERT_EQUAL_UINT32(0, reliableShim->pendingCount()); } -// Control: proves the NO_LORA case below turns on the `to` field alone. void test_rebroadcast_normal_broadcast_is_relayed(void) { MockRadioInterface *mockIface = installMockIface(); @@ -491,13 +791,10 @@ void test_rebroadcast_no_lora_broadcast_is_not_relayed(void) TEST_ASSERT_EQUAL_MESSAGE(0, mockIface->sendCount, "no packet should be handed to the radio at all"); } -// Declining mock bypasses the guard so send() is reached; the release itself is only observable as -// a sanitizer leak report, not an assertion. void test_rebroadcast_declined_send_releases_packet(void) { MockRadioInterface *mockIface = installMockIface(); mockIface->declineAll = true; - meshtastic_MeshPacket p = makeRebroadcastCandidate(NODENUM_BROADCAST); TEST_ASSERT_TRUE_MESSAGE(shim->perhapsRebroadcast(&p), "the rebroadcast must still be attempted"); @@ -551,10 +848,23 @@ void setup() initializeTestEnvironment(); UNITY_BEGIN(); + airTimeFixture = std::make_unique(); mockNodeDB = new MockNodeDB(); shim = new NextHopRouterTestShim(); + reliableShim = new ReliableRouterTestShim(); nodeDB = mockNodeDB; + auto nextRadio = std::make_unique(); + nextHopRadio = nextRadio.get(); + shim->addInterface(std::move(nextRadio)); + + auto reliableCapture = std::make_unique(); + reliableRadio = reliableCapture.get(); + reliableShim->addInterface(std::move(reliableCapture)); + + mockRoutingModule = new MockRoutingModule(); + routingModule = mockRoutingModule; + printf("\n=== resolveLastByte (M1) ===\n"); RUN_TEST(test_resolve_none_when_empty); RUN_TEST(test_resolve_zero_byte_is_none); @@ -594,6 +904,15 @@ void setup() RUN_TEST(test_hoplimit_decrement_on_colliding_favorites); RUN_TEST(test_hoplimit_decrement_when_resolved_not_favorite); + printf("\n=== event-coordinate routing behavior ===\n"); + RUN_TEST(test_eventPolicy_reliableOriginSendSuppressesTxAndPending); + RUN_TEST(test_eventPolicy_reliablePrivateCoordinateStillSends); + RUN_TEST(test_eventPolicy_floodingDuplicateSuppressesCoordinateButRelaysText); + RUN_TEST(test_eventPolicy_nextHopDuplicateSuppressesEventButRelaysPrivateCoordinate); + RUN_TEST(test_eventPolicy_repeatedLocalPacketSuppressesCoordinateAckButKeepsTextAck); + RUN_TEST(test_eventPolicy_seededRetrySuppressesTxUntilGateOff); + RUN_TEST(test_reliableAckStopsNormalPendingTransmission); + printf("\n=== rebroadcast of NODENUM_BROADCAST_NO_LORA ===\n"); RUN_TEST(test_rebroadcast_normal_broadcast_is_relayed); RUN_TEST(test_rebroadcast_no_lora_broadcast_is_not_relayed); @@ -602,7 +921,9 @@ void setup() RUN_TEST(test_event_mode_hop_behavior); #endif - exit(UNITY_END()); + int result = UNITY_END(); + airTimeFixture.reset(); + exit(result); } void loop() {} diff --git a/test/test_nodedb_blocked/test_main.cpp b/test/test_nodedb_blocked/test_main.cpp index 88d7f0259d..8b35d65340 100644 --- a/test/test_nodedb_blocked/test_main.cpp +++ b/test/test_nodedb_blocked/test_main.cpp @@ -25,6 +25,7 @@ class NodeDBTestShim : public NodeDB public: void runDemote() { demoteOldestHotNodesToWarm(); } void runCleanup() { cleanupMeshDB(); } + void stampUntrusted(NodeNum num, uint32_t uptimeSecs) { recordHeardWhileClockUntrusted(num, uptimeSecs); } // Read back the role + protected category the warm tier cached for a node. bool warmMeta(NodeNum n, uint8_t &role, uint8_t &prot) { return warmStore.lookupMeta(n, role, prot); } @@ -178,6 +179,27 @@ static void test_eviction_preservesFavorite(void) TEST_ASSERT_NOT_NULL(db->getMeshNode(0x99990000)); } +// A node heard during this boot is newer than every persisted epoch, including valid epochs after +// 2038. Ranking both domains in one uint32_t incorrectly evicts the current-boot node first. +static void test_eviction_prefers_current_boot_stamp_over_post2038_epoch(void) +{ + constexpr NodeNum futureDated = 0x70000001; + constexpr NodeNum heardThisBoot = 0x70000002; + + db->seedSelf(); + db->push(futureDated, 0xB5000000u, false, false, /*withUser=*/true, /*withKey=*/true); + db->push(heardThisBoot, 0, false, false, /*withUser=*/true, /*withKey=*/true); + db->stampUntrusted(heardThisBoot, 10); + for (int i = 3; i < MAX_NUM_NODES; i++) + db->push(0x70000000u + i, UINT32_MAX, false, false, /*withUser=*/true, /*withKey=*/true); + + TEST_ASSERT_EQUAL_INT(MAX_NUM_NODES, (int)db->getNumMeshNodes()); + TEST_ASSERT_NOT_NULL(db->getOrCreateMeshNode(0x79999999)); + + TEST_ASSERT_NULL(db->getMeshNode(futureDated)); + TEST_ASSERT_NOT_NULL(db->getMeshNode(heardThisBoot)); +} + // Ignored handling: an ignored node survives eviction (like a favourite), and is // never purged by cleanupMeshDB even with no user info (a block set by bare ID). static void test_ignored_survivesEvictionAndCleanup(void) @@ -269,6 +291,7 @@ NDB_TEST_ENTRY void setup() RUN_TEST(test_migration_carriesRoleAndProtectedIntoWarm); RUN_TEST(test_migration_carriesSignerBitThroughWarm); RUN_TEST(test_eviction_preservesFavorite); + RUN_TEST(test_eviction_prefers_current_boot_stamp_over_post2038_epoch); RUN_TEST(test_ignored_survivesEvictionAndCleanup); RUN_TEST(test_protectedCap_refusesBeyondLimit); RUN_TEST(test_removeNodeByNum_absentNodeOnFullDb); diff --git a/test/test_packet_signing/test_main.cpp b/test/test_packet_signing/test_main.cpp index c3abb7bc95..d8234290a1 100644 --- a/test/test_packet_signing/test_main.cpp +++ b/test/test_packet_signing/test_main.cpp @@ -22,6 +22,7 @@ // compiled out unless both PKI and XEdDSA are enabled (e.g. stm32 sets MESHTASTIC_EXCLUDE_XEDDSA). #if !(MESHTASTIC_EXCLUDE_PKI) && !(MESHTASTIC_EXCLUDE_XEDDSA) +#include "UptimeClock.h" #include "mesh/Channels.h" #include "mesh/CryptoEngine.h" #include "mesh/MeshRadio.h" @@ -421,6 +422,16 @@ void tearDown(void) delete mockNodeDB; mockNodeDB = nullptr; nodeDB = nullptr; + + // Restore globals here, not at the end of a test body: an assertion aborts the body, and these + // would otherwise leak into every later case. The injected clock is the one the N8-N11 + // suppression-window cases drive; the region and TX bucket are C14's duty-cycle setup. + Time::useRealClock(); + Time::resetMonotonicForTests(); + if (airTime) + airTime->utilizationTX[0] = 0; + config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US; + initRegion(); } // =========================================================================== @@ -1073,6 +1084,7 @@ void test_B13_licensed_port_and_destination_signing_matrix(void) class NodeInfoTestShim : public NodeInfoModule { public: + using MeshModule::currentRequest; // allocReply() only suppresses while a request is in flight using NodeInfoModule::allocReply; using NodeInfoModule::handleReceivedProtobuf; }; @@ -1221,14 +1233,18 @@ void test_C3_invalid_repeated_packet_cannot_ack_or_change_retry_state(void) prior.hop_start = 2; prior.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA; pipelineRouter->remember(&prior); - pipelineRouter->addPending(prior, UINT32_MAX); + // "Far future, so no retransmission is due." Must be a representable future time, not + // UINT32_MAX: doRetransmissions() compares with an unsigned half-range test, under which + // UINT32_MAX is ~1ms in the *past* and would fire a retransmit and rewrite nextTxMsec. + const uint32_t notDueTxMsec = Time::getMillis() + 3600000UL; + pipelineRouter->addPending(prior, notDueTxMsec); const uint32_t lastHeard = mockNodeDB->getMeshNode(LOCAL_NODE)->last_heard; meshtastic_MeshPacket invalid = makeSignedWirePacket(LOCAL_NODE, NODENUM_BROADCAST, id, 2, 2, 0, 0x34, false); runPipelineIngress(invalid); assertNoRejectedPipelineEffects(LOCAL_NODE, lastHeard); TEST_ASSERT_EQUAL(1, pipelineRouter->pendingCount()); - TEST_ASSERT_EQUAL_UINT32(UINT32_MAX, pipelineRouter->pendingNextTx(LOCAL_NODE, id)); + TEST_ASSERT_EQUAL_UINT32(notDueTxMsec, pipelineRouter->pendingNextTx(LOCAL_NODE, id)); } void test_C4_invalid_fallback_packet_cannot_relay(void) @@ -1569,6 +1585,113 @@ void test_N7_unsigned_unicast_nodeinfo_from_nonsigner_changes_name(void) "non-signer identity learning must be unaffected"); } +// --------------------------------------------------------------------------- +// N8-N11: the 12h reply-suppression window. +// +// The stamp is uptime SECONDS, not milliseconds: entries live for as long as the node stays in the +// DB, so a 32-bit millisecond stamp aliased back into the window once uptime passed 49.7 days and +// suppressed a legitimate reply for up to 12h. Driven through Time::setTestMillis() rather than by +// waiting. +// --------------------------------------------------------------------------- + +static constexpr uint32_t kSuppressSecs = 12 * 60 * 60; + +// Deliver a NodeInfo request from `sender` and report whether we would reply to it. +static bool wouldReplyToNodeInfoRequest(NodeInfoTestShim &shim, NodeNum sender) +{ + meshtastic_MeshPacket mp = makeDecoded(sender, NODENUM_BROADCAST, meshtastic_PortNum_NODEINFO_APP, SMALL_PAYLOAD); + mp.decoded.want_response = true; + meshtastic_User user = meshtastic_User_init_zero; + user.is_licensed = owner.is_licensed; + + shim.handleReceivedProtobuf(mp, &user); + + NodeInfoTestShim::currentRequest = ∓ + meshtastic_MeshPacket *reply = shim.allocReply(); + NodeInfoTestShim::currentRequest = nullptr; + + if (reply) { + packetPool.release(reply); + return true; + } + return false; +} + +// Step the injected clock the way the main loop does - advance, then publish the wrap carry. +static void advanceUptime(uint32_t deltaMs) +{ + Time::advanceTestMillis(deltaMs); + Time::serviceMonotonic(); +} + +void test_N8_second_request_inside_the_window_is_suppressed(void) +{ + mockNodeDB->addNode(REMOTE_NODE); + Time::setTestMillis(60 * 1000); + Time::serviceMonotonic(); + + NodeInfoTestShim shim; + TEST_ASSERT_TRUE_MESSAGE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE), "first request must be answered"); + + advanceUptime(60 * 60 * 1000); // 1h later, well inside the 12h window + TEST_ASSERT_FALSE_MESSAGE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE), "repeat request inside 12h must be suppressed"); +} + +void test_N9_request_after_the_window_is_answered(void) +{ + mockNodeDB->addNode(REMOTE_NODE); + Time::setTestMillis(60 * 1000); + Time::serviceMonotonic(); + + NodeInfoTestShim shim; + TEST_ASSERT_TRUE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE)); + + advanceUptime((kSuppressSecs + 60) * 1000); // 12h + a minute + TEST_ASSERT_TRUE_MESSAGE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE), "request after 12h must be answered"); +} + +// The regression. A stamp is only aliased by a counter that wraps underneath it, so the failure +// needs a *full* 2^32 ms of uptime to elapse, not merely a crossing of the boundary: with 32-bit +// millisecond stamps `now - stamp` then computes as 0 and the sender looks like it was answered +// this instant. Uptime seconds do not wrap for 136 years, so the entry reads as ~49.7 days old. +void test_N10_stale_stamp_does_not_alias_after_a_full_wrap(void) +{ + mockNodeDB->addNode(REMOTE_NODE); + Time::setTestMillis(0x80000000u); // ~24.8 days of uptime + Time::serviceMonotonic(); + + NodeInfoTestShim shim; + TEST_ASSERT_TRUE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE)); + + // A whole millis() cycle, in two serviced halves - one publish per window is the contract. + advanceUptime(0x80000000u); + advanceUptime(0x80000000u); + + TEST_ASSERT_TRUE_MESSAGE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE), + "a stamp one full wrap old must read as ~49.7 days, not as this instant"); +} + +// Suppression must still behave normally either side of the boundary: still suppressing inside the +// window, and answering again once 12h have passed, with the stamp and the reading on opposite +// sides of the wrap. +void test_N11_window_still_applies_across_the_wrap(void) +{ + mockNodeDB->addNode(REMOTE_NODE); + Time::setTestMillis(0xFFFF0000u); // just short of the wrap + Time::serviceMonotonic(); + + NodeInfoTestShim shim; + TEST_ASSERT_TRUE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE)); + + advanceUptime(0x20000u); // ~131s later, and now past the wrap + TEST_ASSERT_FALSE_MESSAGE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE), + "the window must still bite when the stamp sits the other side of the wrap"); + + advanceUptime((kSuppressSecs + 60) * 1000); + TEST_ASSERT_TRUE_MESSAGE(wouldReplyToNodeInfoRequest(shim, REMOTE_NODE), + "and must still release once 12h have passed across the wrap"); +} + void test_L1_licensed_nodeinfo_publishes_public_key(void) { owner.is_licensed = true; @@ -1984,6 +2107,10 @@ void setup() RUN_TEST(test_N5_unsigned_unicast_nodeinfo_from_signer_does_not_change_name); RUN_TEST(test_N6_signed_unicast_nodeinfo_from_signer_changes_name); RUN_TEST(test_N7_unsigned_unicast_nodeinfo_from_nonsigner_changes_name); + RUN_TEST(test_N8_second_request_inside_the_window_is_suppressed); + RUN_TEST(test_N9_request_after_the_window_is_answered); + RUN_TEST(test_N10_stale_stamp_does_not_alias_after_a_full_wrap); + RUN_TEST(test_N11_window_still_applies_across_the_wrap); printf("\n=== Group L: licensed identity and plaintext signing ===\n"); RUN_TEST(test_L1_licensed_nodeinfo_publishes_public_key); diff --git a/test/test_position_precision/test_main.cpp b/test/test_position_precision/test_main.cpp index 5f55697522..fae50e87fc 100644 --- a/test/test_position_precision/test_main.cpp +++ b/test/test_position_precision/test_main.cpp @@ -1,11 +1,16 @@ #include "Channels.h" #include "GeoCoord.h" +#include "NodeDB.h" #include "PositionPrecision.h" +#include "Router.h" #include "TestUtil.h" #include "mesh-pb-constants.h" #include #include #include +#if ARCH_PORTDUINO +#include "platform/portduino/PortduinoGlue.h" +#endif static meshtastic_Position makePosition() { @@ -129,6 +134,8 @@ static void test_getPositionPrecisionForChannel_clampsPreciseOnDefaultKeyChannel channels.initDefaults(); // channel 0: primary, default key (psk {0x01}) -> publicly decryptable uint8_t idx = 0; meshtastic_Channel &ch = channels.getByIndex(idx); + ch.settings.psk.size = 1; + ch.settings.psk.bytes[0] = 0x01; ch.settings.has_module_settings = true; ch.settings.module_settings.position_precision = 32; // user requests "Precise" on a public channel @@ -236,6 +243,178 @@ static void test_geocoord_extreme_coords_no_oob() } } +static void configureEventChannels(bool eventAtIndexOne, bool inheritEventKeyOnSecondary) +{ + memset(&channelFile, 0, sizeof(channelFile)); + channelFile.channels_count = 2; + + meshtastic_Channel eventChannel = makeChannel(meshtastic_Channel_Role_PRIMARY, true, 16); + meshtastic_Channel otherChannel = makeChannel(meshtastic_Channel_Role_SECONDARY, true, 16); + strncpy(eventChannel.settings.name, "everyone", sizeof(eventChannel.settings.name) - 1); +#ifdef USERPREFS_CHANNEL_0_PSK + static const uint8_t configuredEventPsk[] = USERPREFS_CHANNEL_0_PSK; + eventChannel.settings.psk.size = sizeof(configuredEventPsk); + memcpy(eventChannel.settings.psk.bytes, configuredEventPsk, sizeof(configuredEventPsk)); +#endif + if (!inheritEventKeyOnSecondary) { + otherChannel.settings.psk.size = 32; + memset(otherChannel.settings.psk.bytes, 0xAB, 32); + strncpy(otherChannel.settings.name, "private", sizeof(otherChannel.settings.name) - 1); + } + + eventChannel.index = eventAtIndexOne ? 1 : 0; + otherChannel.index = eventAtIndexOne ? 0 : 1; + channelFile.channels[eventChannel.index] = eventChannel; + channelFile.channels[otherChannel.index] = otherChannel; + channels.onConfigChanged(); +} + +static void test_getPositionPrecisionForChannel_eventChannelClampedToZero() +{ + // The event ("everyone") channel must never share location, even when the + // stored precision is non-zero. Under the block gate the clamp forces 0; + // otherwise the stored value is honored like any other channel. +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + configureEventChannels(false, false); + TEST_ASSERT_TRUE(channels.isEventChannel(0)); + TEST_ASSERT_EQUAL_UINT32(0, getPositionPrecisionForChannel(0)); +#else + meshtastic_Channel channel = makeChannel(meshtastic_Channel_Role_PRIMARY, true, 16); + TEST_ASSERT_EQUAL_UINT32(16, getPositionPrecisionForChannel(channel)); +#endif +} + +static void test_eventChannelIdentity_usesEffectiveKeyAndSurvivesReorder() +{ +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + configureEventChannels(false, true); + TEST_ASSERT_TRUE(channels.isEventChannel(0)); + TEST_ASSERT_TRUE(channels.isEventChannel(1)); + TEST_ASSERT_EQUAL_UINT32(0, getPositionPrecisionForChannel(1)); + + configureEventChannels(true, false); + TEST_ASSERT_FALSE(channels.isEventChannel(0)); + TEST_ASSERT_TRUE(channels.isEventChannel(1)); + TEST_ASSERT_EQUAL_UINT32(16, getPositionPrecisionForChannel(0)); + TEST_ASSERT_EQUAL_UINT32(0, getPositionPrecisionForChannel(1)); +#else + TEST_ASSERT_FALSE(channels.isEventChannel(0)); +#endif +} + +static meshtastic_MeshPacket makeDecodedPacket(meshtastic_PortNum portnum, uint8_t channelIndex) +{ + meshtastic_MeshPacket packet = meshtastic_MeshPacket_init_default; + packet.which_payload_variant = meshtastic_MeshPacket_decoded_tag; + packet.decoded.portnum = portnum; + packet.channel = channelIndex; + return packet; +} + +static void test_eventCoordinatePolicy_coversPortsAndExcludesPki() +{ +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + configureEventChannels(false, false); + auto position = makeDecodedPacket(meshtastic_PortNum_POSITION_APP, 0); + auto waypoint = makeDecodedPacket(meshtastic_PortNum_WAYPOINT_APP, 0); + auto mapReport = makeDecodedPacket(meshtastic_PortNum_MAP_REPORT_APP, 0); + auto text = makeDecodedPacket(meshtastic_PortNum_TEXT_MESSAGE_APP, 0); + + TEST_ASSERT_TRUE(isBlockedEventCoordinatePacket(&position)); + TEST_ASSERT_TRUE(isBlockedEventCoordinatePacket(&waypoint)); + TEST_ASSERT_TRUE(isBlockedEventCoordinatePacket(&mapReport)); + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&text)); + + waypoint.pki_encrypted = true; + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&waypoint)); + + waypoint.pki_encrypted = false; + waypoint.to = 0x12345678; + config.security.private_key.size = 32; + owner.is_licensed = false; +#if ARCH_PORTDUINO + portduino_config.force_simradio = false; +#endif + TEST_ASSERT_TRUE(willUsePki(&waypoint)); + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&waypoint)); +#else + auto position = makeDecodedPacket(meshtastic_PortNum_POSITION_APP, 0); + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&position)); +#endif +} + +static void test_eventCoordinatePolicy_doesNotClassifyOpaquePacketsByHash() +{ +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + configureEventChannels(false, false); + meshtastic_MeshPacket packet = meshtastic_MeshPacket_init_default; + packet.which_payload_variant = meshtastic_MeshPacket_encrypted_tag; + packet.channel = channels.getHash(0); + packet.from = 0; + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&packet)); + + packet.pki_encrypted = true; + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&packet)); + + packet.channel = 0; + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&packet)); + + packet.pki_encrypted = false; + packet.channel = channels.getHash(0); + packet.from = 0x12345678; + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&packet)); + + packet.from = 0; + packet.channel = channels.getHash(1); + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&packet)); +#else + TEST_ASSERT_TRUE(true); +#endif +} + +static void test_eventCoordinatePolicy_usesResolvedUnicastChannel() +{ +#if USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL && defined(USERPREFS_CHANNEL_0_PSK) + NodeDB *savedNodeDB = nodeDB; + nodeDB = new NodeDB(); + configureEventChannels(false, false); + meshtastic_NodeInfoLite *node = + nodeDB->getNumMeshNodes() > 1 ? nodeDB->getMeshNodeByIndex(1) : nodeDB->getOrCreateMeshNode(0x12345678); + TEST_ASSERT_NOT_NULL(node); + const NodeNum destination = node->num; + const uint8_t savedChannel = node->channel; + + auto position = makeDecodedPacket(meshtastic_PortNum_POSITION_APP, 0); + position.to = destination; + node->channel = 1; + TEST_ASSERT_FALSE(isBlockedEventCoordinatePacket(&position)); + + position.from = 0x87654321; + TEST_ASSERT_TRUE(isBlockedEventCoordinatePacket(&position)); + + position.from = 0; + node->channel = 0; + TEST_ASSERT_TRUE(isBlockedEventCoordinatePacket(&position)); + node->channel = savedChannel; + delete nodeDB; + nodeDB = savedNodeDB; +#else + TEST_ASSERT_TRUE(true); +#endif +} + +static void test_getPositionPrecisionForChannel_nonEventFullKeyIsHonored() +{ + // A private channel with a full 32-byte key that is not the configured + // channel-0 PSK must be + // unaffected by the clamp on either side of the gate. + meshtastic_Channel channel = makeChannel(meshtastic_Channel_Role_PRIMARY, true, 16); + channel.settings.psk.size = 32; + memset(channel.settings.psk.bytes, 0xAB, 32); + + TEST_ASSERT_EQUAL_UINT32(16, getPositionPrecisionForChannel(channel)); +} + void setUp(void) {} void tearDown(void) {} @@ -262,6 +441,12 @@ void setup() RUN_TEST(test_cryptoKeyIsPublic_aes256KeyIsPrivate); RUN_TEST(test_cryptoKeyIsPublic_invalidKeyIsNotPublic); RUN_TEST(test_geocoord_extreme_coords_no_oob); + RUN_TEST(test_getPositionPrecisionForChannel_eventChannelClampedToZero); + RUN_TEST(test_eventChannelIdentity_usesEffectiveKeyAndSurvivesReorder); + RUN_TEST(test_eventCoordinatePolicy_coversPortsAndExcludesPki); + RUN_TEST(test_eventCoordinatePolicy_doesNotClassifyOpaquePacketsByHash); + RUN_TEST(test_eventCoordinatePolicy_usesResolvedUnicastChannel); + RUN_TEST(test_getPositionPrecisionForChannel_nonEventFullKeyIsHonored); exit(UNITY_END()); } diff --git a/test/test_stream_api/test_main.cpp b/test/test_stream_api/test_main.cpp index 5075fe461f..994e82c3d3 100644 --- a/test/test_stream_api/test_main.cpp +++ b/test/test_stream_api/test_main.cpp @@ -526,14 +526,14 @@ static void test_want_config_includes_status_message_module_config(void) } /// Queue a packet as Router::dispatchReceived would have, before any time source existed. -static void queuePendingTimePlaceholderPacket(NodeNum from, uint32_t placeholderMillis) +static void queuePendingTimePlaceholderPacket(NodeNum from, uint32_t placeholderUptimeSecs) { meshtastic_MeshPacket pending = meshtastic_MeshPacket_init_zero; pending.which_payload_variant = meshtastic_MeshPacket_decoded_tag; pending.decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP; pending.from = from; pending.to = NODENUM_BROADCAST; - pending.rx_time = placeholderMillis; + pending.rx_time = placeholderUptimeSecs; // computeRxTimeStamp() stamps Time::getUptimeSecs() pending.has_rx_time = false; service->sendToPhone(packetPool.allocCopy(pending)); } @@ -574,6 +574,7 @@ class ScopedTimeFixture ScopedTimeFixture(uint32_t startMillis) : previous(nodeDB) { resetRTCStateForTests(); + Time::resetMonotonicForTests(); // uptime-seconds placeholders assume no carried wrap nodeDB = &instance; Time::setTestMillis(startMillis); } @@ -597,7 +598,7 @@ static void test_time_given_at_handshake_start_reconciles_queued_packet(void) ScopedTimeFixture timeFixture(5000); const NodeNum sender = 0x12345678; - queuePendingTimePlaceholderPacket(sender, 2000); // "received" 3s before the test's current millis() + queuePendingTimePlaceholderPacket(sender, 2); // "received" at uptime 2s, 3s before the fixture's 5000ms now PhoneAPITestShim api; startHandshake(api); @@ -624,7 +625,7 @@ static void test_time_given_at_handshake_end_does_not_rewrite_already_sent_packe ScopedTimeFixture timeFixture(5000); const NodeNum sender = 0x12345678; - queuePendingTimePlaceholderPacket(sender, 2000); + queuePendingTimePlaceholderPacket(sender, 2); PhoneAPITestShim api; startHandshake(api); @@ -650,6 +651,68 @@ static void test_time_given_at_handshake_end_does_not_rewrite_already_sent_packe api.close(); } +// The NodeDB half of the same transition: a node heard while the clock was untrusted gets no +// last_heard at all (the arrival instant waits in the RAM sidecar as uptime seconds), and the +// clock-valid hook backfills it to the real epoch of the sighting - so the phone reads +// "last heard: unknown" only until time arrives, never a boot-relative value. +static void test_node_heard_before_time_gets_last_heard_backfilled(void) +{ + ScopedMeshService scopedService; + ScopedTimeFixture timeFixture(5000); + + const NodeNum sender = 0x22334455; + meshtastic_MeshPacket heard = meshtastic_MeshPacket_init_zero; + heard.which_payload_variant = meshtastic_MeshPacket_decoded_tag; + heard.decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP; + heard.from = sender; + heard.to = NODENUM_BROADCAST; + heard.rx_time = 2; // uptime-seconds placeholder: "arrived at uptime 2s" + heard.has_rx_time = false; + nodeDB->updateFrom(heard); + + const meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(sender); + TEST_ASSERT_NOT_NULL(info); + TEST_ASSERT_EQUAL_UINT32(0u, info->last_heard); // absent, never a boot-relative stamp + + struct timeval networkTime; + networkTime.tv_sec = time(NULL) + SEC_PER_DAY; + networkTime.tv_usec = 0; + TEST_ASSERT_EQUAL_INT(RTCSetResultSuccess, perhapsSetRTC(RTCQualityFromNet, &networkTime)); + + // Heard at uptime 2s, clock arrived at uptime 5s: the sighting dates to nowEpoch - 3. + TEST_ASSERT_UINT32_WITHIN(2, (uint32_t)networkTime.tv_sec - 3, info->last_heard); +} + +// Uptime zero is a valid arrival instant during the first second of boot. It must not be confused +// with an absent sidecar record when network time arrives. +static void test_node_heard_during_first_uptime_second_gets_last_heard_backfilled(void) +{ + ScopedMeshService scopedService; + ScopedTimeFixture timeFixture(500); + + const NodeNum sender = 0x33445566; + TEST_ASSERT_NOT_NULL(nodeDB->getOrCreateMeshNode(sender)); + meshtastic_MeshPacket heard = meshtastic_MeshPacket_init_zero; + heard.which_payload_variant = meshtastic_MeshPacket_decoded_tag; + heard.decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP; + heard.from = sender; + heard.to = NODENUM_BROADCAST; + heard.rx_time = 0; // received during uptime second zero + heard.has_rx_time = false; + nodeDB->updateFrom(heard); + + const meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(sender); + TEST_ASSERT_NOT_NULL(info); + TEST_ASSERT_EQUAL_UINT32(0u, info->last_heard); + + struct timeval networkTime; + networkTime.tv_sec = time(NULL) + SEC_PER_DAY; + networkTime.tv_usec = 0; + TEST_ASSERT_EQUAL_INT(RTCSetResultSuccess, perhapsSetRTC(RTCQualityFromNet, &networkTime)); + + TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)networkTime.tv_sec, info->last_heard); +} + /// Unity per-test setup; fixtures are local to each test. void setUp(void) {} /// Unity per-test teardown; fixtures clean themselves up. @@ -674,6 +737,8 @@ void setup() RUN_TEST(test_want_config_includes_status_message_module_config); RUN_TEST(test_time_given_at_handshake_start_reconciles_queued_packet); RUN_TEST(test_time_given_at_handshake_end_does_not_rewrite_already_sent_packet); + RUN_TEST(test_node_heard_before_time_gets_last_heard_backfilled); + RUN_TEST(test_node_heard_during_first_uptime_second_gets_last_heard_backfilled); // usingProtobufs intentionally has no reset path, so this must run last. RUN_TEST(test_serial_console_suppresses_raw_output_in_protobuf_mode); exit(UNITY_END()); diff --git a/test/test_throttle/test_main.cpp b/test/test_throttle/test_main.cpp new file mode 100644 index 0000000000..e2630ba3dd --- /dev/null +++ b/test/test_throttle/test_main.cpp @@ -0,0 +1,237 @@ +// Unit tests for src/mesh/Throttle.{h,cpp} - the firmware's elapsed-time and deadline helpers. +// +// These drive the injected clock across the 32-bit millis() wrap, which is not otherwise reachable +// in a test, and which every caller of these helpers depends on being handled correctly. +#include "Arduino.h" +#include "TestUtil.h" +#include "UptimeClock.h" +#include "mesh/Throttle.h" +#include +#include + +void setUp(void) {} +void tearDown(void) +{ + Time::useRealClock(); // don't leak the fake clock into other suites +} + +// --- basic window semantics --- + +void test_isWithinTimespan_true_inside_window() +{ + Time::setTestMillis(10000); + TEST_ASSERT_TRUE(Throttle::isWithinTimespanMs(9500, 1000)); // 500ms elapsed of a 1000ms window +} + +void test_isWithinTimespan_false_outside_window() +{ + Time::setTestMillis(10000); + TEST_ASSERT_FALSE(Throttle::isWithinTimespanMs(8000, 1000)); // 2000ms elapsed +} + +// The boundary is exclusive: elapsed == interval is NOT "within". +void test_isWithinTimespan_boundary_is_exclusive() +{ + Time::setTestMillis(10000); + TEST_ASSERT_FALSE(Throttle::isWithinTimespanMs(9000, 1000)); // exactly 1000ms elapsed + TEST_ASSERT_TRUE(Throttle::isWithinTimespanMs(9001, 1000)); // 999ms elapsed +} + +// --- hasElapsed is the exact complement --- + +void test_hasElapsed_is_complement_of_isWithinTimespan() +{ + Time::setTestMillis(10000); + const uint32_t cases[][2] = {{9500, 1000}, {8000, 1000}, {9000, 1000}, {10000, 1}, {0, 5000}}; + for (auto &c : cases) { + TEST_ASSERT_EQUAL(!Throttle::isWithinTimespanMs(c[0], c[1]), Throttle::hasElapsed(c[0], c[1])); + } +} + +void test_hasElapsed_boundary_is_inclusive() +{ + Time::setTestMillis(10000); + TEST_ASSERT_TRUE(Throttle::hasElapsed(9000, 1000)); // exactly 1000ms elapsed + TEST_ASSERT_FALSE(Throttle::hasElapsed(9001, 1000)); // 999ms elapsed +} + +// --- rollover: the headline property --- + +// A window opened just before the 32-bit wrap must still close correctly after it. +void test_isWithinTimespan_survives_millis_wrap() +{ + const uint32_t lastRun = 0xFFFFFF00u; // 256ms before the wrap + Time::setTestMillis(lastRun); + + Time::advanceTestMillis(100); // 0xFFFFFF64 - still before the wrap + TEST_ASSERT_TRUE(Throttle::isWithinTimespanMs(lastRun, 1000)); + + Time::advanceTestMillis(200); // wraps to 0x0000002C - 300ms elapsed in total + TEST_ASSERT_TRUE(Throttle::isWithinTimespanMs(lastRun, 1000)); + TEST_ASSERT_FALSE(Throttle::hasElapsed(lastRun, 1000)); + + Time::advanceTestMillis(800); // 1100ms elapsed in total, well past the wrap + TEST_ASSERT_FALSE(Throttle::isWithinTimespanMs(lastRun, 1000)); + TEST_ASSERT_TRUE(Throttle::hasElapsed(lastRun, 1000)); +} + +// The long-interval end of the range: a 24h window (the longest in the tree) across the wrap. +void test_long_interval_survives_wrap() +{ + const uint32_t dayMs = 24u * 60u * 60u * 1000u; // 86,400,000 + const uint32_t lastRun = 0xFFFFFF00u; + Time::setTestMillis(lastRun); + + Time::advanceTestMillis(dayMs - 1); + TEST_ASSERT_TRUE(Throttle::isWithinTimespanMs(lastRun, dayMs)); + + Time::advanceTestMillis(1); // exactly one day elapsed + TEST_ASSERT_TRUE(Throttle::hasElapsed(lastRun, dayMs)); +} + +// --- deadlinePassed() --- + +void test_deadlinePassed_basic() +{ + Time::setTestMillis(10000); + TEST_ASSERT_FALSE(Throttle::deadlinePassed(10001)); // 1ms in the future + TEST_ASSERT_TRUE(Throttle::deadlinePassed(10000)); // exactly now counts as passed + TEST_ASSERT_TRUE(Throttle::deadlinePassed(9999)); // 1ms in the past +} + +// The property the naive `millis() > deadline` compare fails: a deadline set before the wrap must +// fire once, and only once, after the wrap. +void test_deadlinePassed_survives_millis_wrap() +{ + Time::setTestMillis(0xFFFFFF00u); // 256ms before the wrap + const uint32_t deadline = 0xFFFFFF00u + 500; + + TEST_ASSERT_FALSE(Throttle::deadlinePassed(deadline)); // not yet + Time::advanceTestMillis(400); // 0x00000090 - wrapped, still not due + TEST_ASSERT_FALSE(Throttle::deadlinePassed(deadline)); + Time::advanceTestMillis(100); // exactly due, past the wrap + TEST_ASSERT_TRUE(Throttle::deadlinePassed(deadline)); + Time::advanceTestMillis(60000); // stays passed + TEST_ASSERT_TRUE(Throttle::deadlinePassed(deadline)); +} + +// The naive compare's actual failure mode, pinned so a regression is unmistakable: before the wrap +// the deadline is numerically smaller than now, so `millis() > deadline` would fire it early. +void test_deadlinePassed_does_not_fire_early_when_deadline_wraps() +{ + Time::setTestMillis(0xFFFFFF00u); + const uint32_t deadline = 0xFFFFFF00u + 1000; // wraps to 0x000002E8 + + TEST_ASSERT_TRUE(deadline < Time::getMillis()); // the naive compare would fire here + TEST_ASSERT_FALSE(Throttle::deadlinePassed(deadline)); +} + +// deadlinePassedAt() judges against a caller-supplied now, so a loop that snapshots the clock once +// gets one instant for every entry - including across the wrap, where the clock has moved on. +void test_deadlinePassedAt_uses_the_supplied_now() +{ + Time::setTestMillis(0xFFFFFF00u); + const uint32_t now = Time::getMillis(); + const uint32_t deadline = 0xFFFFFF00u + 500; // wraps to 0x000000F4 + + TEST_ASSERT_FALSE(Throttle::deadlinePassedAt(now, deadline)); + TEST_ASSERT_TRUE(Throttle::deadlinePassedAt(deadline, deadline)); // inclusive boundary + TEST_ASSERT_TRUE(Throttle::deadlinePassedAt(deadline + 1, deadline)); // past the wrap + Time::advanceTestMillis(60000); // clock moved, snapshot did not + TEST_ASSERT_FALSE(Throttle::deadlinePassedAt(now, deadline)); + TEST_ASSERT_TRUE(Throttle::deadlinePassed(deadline)); +} + +// deadlinePassed() cannot know about sentinels, so it reports them as passed. This pins that +// contract, since callers relying on it must test armed-ness first. +void test_deadlinePassed_reads_disarmed_sentinels_as_passed() +{ + Time::setTestMillis(6247); + + TEST_ASSERT_TRUE(Throttle::deadlinePassed(0)); // "inactive" for rebootAtMsec et al + TEST_ASSERT_TRUE(Throttle::deadlinePassed(UINT32_MAX)); // "inactive" for nagCycleCutoff + + // The guarded form every caller must use. + const uint32_t disarmed = 0; + TEST_ASSERT_FALSE(disarmed && Throttle::deadlinePassed(disarmed)); + + // And it still holds after a wrap. + Time::setTestMillis(0xFFFFFF00u); + Time::advanceTestMillis(1000); + TEST_ASSERT_FALSE(disarmed && Throttle::deadlinePassed(disarmed)); +} + +// --- execute() --- + +static int executeCount = 0; +static int deferCount = 0; +static void countExecute() +{ + executeCount++; +} +static void countDefer() +{ + deferCount++; +} + +void test_execute_runs_first_time_then_throttles() +{ + executeCount = 0; + deferCount = 0; + Time::setTestMillis(5000); + + uint32_t last = 0; // 0 means "never run" to execute() + TEST_ASSERT_TRUE(Throttle::execute(&last, 1000, countExecute, countDefer)); + TEST_ASSERT_EQUAL(1, executeCount); + + // Immediately again: deferred. + TEST_ASSERT_FALSE(Throttle::execute(&last, 1000, countExecute, countDefer)); + TEST_ASSERT_EQUAL(1, executeCount); + TEST_ASSERT_EQUAL(1, deferCount); + + // After the interval: runs again. + Time::advanceTestMillis(1000); + TEST_ASSERT_TRUE(Throttle::execute(&last, 1000, countExecute, countDefer)); + TEST_ASSERT_EQUAL(2, executeCount); +} + +void test_execute_survives_millis_wrap() +{ + executeCount = 0; + Time::setTestMillis(0xFFFFFF00u); + + uint32_t last = 0; + TEST_ASSERT_TRUE(Throttle::execute(&last, 1000, countExecute)); // arms at 0xFFFFFF00 + TEST_ASSERT_EQUAL(1, executeCount); + + Time::advanceTestMillis(500); // wraps past 0 + TEST_ASSERT_FALSE(Throttle::execute(&last, 1000, countExecute)); // not due yet + TEST_ASSERT_EQUAL(1, executeCount); + + Time::advanceTestMillis(600); // 1100ms total + TEST_ASSERT_TRUE(Throttle::execute(&last, 1000, countExecute)); + TEST_ASSERT_EQUAL(2, executeCount); +} + +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + RUN_TEST(test_isWithinTimespan_true_inside_window); + RUN_TEST(test_isWithinTimespan_false_outside_window); + RUN_TEST(test_isWithinTimespan_boundary_is_exclusive); + RUN_TEST(test_hasElapsed_is_complement_of_isWithinTimespan); + RUN_TEST(test_hasElapsed_boundary_is_inclusive); + RUN_TEST(test_isWithinTimespan_survives_millis_wrap); + RUN_TEST(test_long_interval_survives_wrap); + RUN_TEST(test_deadlinePassed_basic); + RUN_TEST(test_deadlinePassed_survives_millis_wrap); + RUN_TEST(test_deadlinePassed_does_not_fire_early_when_deadline_wraps); + RUN_TEST(test_deadlinePassedAt_uses_the_supplied_now); + RUN_TEST(test_deadlinePassed_reads_disarmed_sentinels_as_passed); + RUN_TEST(test_execute_runs_first_time_then_throttles); + RUN_TEST(test_execute_survives_millis_wrap); + exit(UNITY_END()); +} + +void loop() {} diff --git a/test/test_uptime_clock/test_main.cpp b/test/test_uptime_clock/test_main.cpp new file mode 100644 index 0000000000..f950102c24 --- /dev/null +++ b/test/test_uptime_clock/test_main.cpp @@ -0,0 +1,356 @@ +// Unit tests for src/UptimeClock.{h,cpp} - the monotonic uptime seam. +// Covers: test-clock injection, stepping the injected clock, the real-clock fallback, and the +// single-writer wrap carry (readers derive, serviceMonotonic() publishes). getMillis() itself is a +// plain 32-bit read with no wrap handling of its own - its consumers' wrap arithmetic is tested in +// test_throttle/. +#include "Arduino.h" +#include "TestUtil.h" +#include "UptimeClock.h" +#include "gps/RTC.h" +#include +#include +#include +#include +#include +#include +#include + +namespace +{ +std::atomic publishPaused{false}; +std::atomic releasePublish{false}; + +void pauseMonotonicPublish() +{ + publishPaused.store(true, std::memory_order_release); + while (!releasePublish.load(std::memory_order_acquire)) + std::this_thread::yield(); +} +} // namespace + +void setUp(void) +{ + Time::resetMonotonicForTests(); // absolute uptime assertions must not depend on case order +} +void tearDown(void) +{ + Time::useRealClock(); // don't leak the fake clock into other suites + resetRTCStateForTests(); +} + +// Step the injected clock the way the firmware does: the main loop calls serviceMonotonic() every +// iteration, so any advance is followed by a publish. +static void advanceAndService(uint32_t deltaMs) +{ + Time::advanceTestMillis(deltaMs); + Time::serviceMonotonic(); +} + +// --- injection --- + +void test_getMillis_returns_injected_value() +{ + Time::setTestMillis(123456); + TEST_ASSERT_EQUAL_UINT32(123456, Time::getMillis()); +} + +void test_advanceTestMillis_steps_clock() +{ + Time::setTestMillis(1000); + Time::advanceTestMillis(500); + TEST_ASSERT_EQUAL_UINT32(1500, Time::getMillis()); +} + +// Advancing past 0xFFFFFFFF wraps like millis() does, rather than saturating. This is the property +// the Throttle wrap tests are built on, so it is worth pinning here too. +void test_advanceTestMillis_wraps_like_millis() +{ + Time::setTestMillis(0xFFFFFF00u); + Time::advanceTestMillis(0x200u); + TEST_ASSERT_EQUAL_UINT32(0x00000100u, Time::getMillis()); +} + +// --- getMillisMonotonic(): the published wrap carry --- + +void test_monotonic_matches_millis_before_any_wrap() +{ + Time::setTestMillis(123456); + TEST_ASSERT_EQUAL_UINT64(123456u, Time::getMillisMonotonic()); +} + +void test_monotonic_counts_a_wrap() +{ + Time::setTestMillis(0xFFFFFF00u); + Time::serviceMonotonic(); + TEST_ASSERT_EQUAL_UINT64(0xFFFFFF00u, Time::getMillisMonotonic()); + + advanceAndService(0x200u); // crosses the 32-bit wrap; low word is now 0x00000100 + TEST_ASSERT_EQUAL_UINT64(0x100000100ull, Time::getMillisMonotonic()); +} + +// The property that lets readers stay pure: a reader adds its own unsigned elapsed time to the +// published snapshot, so it is exact across a wrap that no publish has observed yet. Nothing here +// needs to detect the boundary, which is why concurrent readers cannot double-count it. +void test_monotonic_reader_crosses_the_wrap_without_a_publish() +{ + Time::setTestMillis(0xFFFFFF00u); + Time::serviceMonotonic(); // last publish before the wrap + + Time::advanceTestMillis(0x200u); // cross the wrap with no publish at all + TEST_ASSERT_EQUAL_UINT64(0x100000100ull, Time::getMillisMonotonic()); +} + +// Reads must not advance the carry. Under the old read-modify-write accessor each reader bumped +// the wrap counter itself, which is what made two of them able to count one wrap twice. +void test_monotonic_reads_do_not_advance_the_carry() +{ + Time::setTestMillis(0xFFFFFF00u); + Time::serviceMonotonic(); + + Time::advanceTestMillis(0x200u); + for (int i = 0; i < 8; i++) + TEST_ASSERT_EQUAL_UINT64(0x100000100ull, Time::getMillisMonotonic()); + + Time::serviceMonotonic(); // the eight reads must not have left eight wraps behind + TEST_ASSERT_EQUAL_UINT64(0x100000100ull, Time::getMillisMonotonic()); +} + +void test_monotonic_counts_every_wrap_when_serviced_each_window() +{ + Time::setTestMillis(0x80000000u); + Time::serviceMonotonic(); + TEST_ASSERT_EQUAL_UINT64(0x80000000ull, Time::getMillisMonotonic()); + + // Three full 2^32 cycles, published once per half-cycle - well inside the required + // one-publish-per-49.7-days window. + for (int wrap = 1; wrap <= 3; wrap++) { + advanceAndService(0x80000000u); // crosses the wrap; low word back to 0 + advanceAndService(0x80000000u); // completes the cycle; low word back to 0x80000000 + TEST_ASSERT_EQUAL_UINT64(0x80000000ull + ((uint64_t)wrap << 32), Time::getMillisMonotonic()); + } +} + +// The documented contract, pinned: a full 2^32 ms elapsing between two publishes is +// indistinguishable from no time passing, so the wrap is lost. This is why the main loop's +// per-iteration serviceMonotonic() matters - and it is now the only obligation, where before every +// reader had to participate. +void test_monotonic_misses_a_wrap_not_serviced_within_the_window() +{ + Time::setTestMillis(1000); + Time::serviceMonotonic(); + TEST_ASSERT_EQUAL_UINT64(1000u, Time::getMillisMonotonic()); + + Time::advanceTestMillis(0x80000000u); + advanceAndService(0x80000000u); // full cycle with no publish in between: low word is 1000 again + + TEST_ASSERT_EQUAL_UINT64(1000u, Time::getMillisMonotonic()); // the elapsed 2^32 ms is lost +} + +void test_getUptimeSecs_stays_exact_across_the_wrap() +{ + Time::setTestMillis(4294967000u); // 4294967 whole seconds, 296ms short of the wrap + Time::serviceMonotonic(); + TEST_ASSERT_EQUAL_UINT32(4294967u, Time::getUptimeSecs()); + + advanceAndService(1000); // crosses the wrap + TEST_ASSERT_EQUAL_UINT32(4294968u, Time::getUptimeSecs()); +} + +// --- concurrent readers --- + +// Readers run flat out while the clock is stepped across several wraps. Under the old accessor two +// readers interleaving inside the wrap window could each bump the counter, jumping every later +// reading 2^32 ms forward; here they only ever read, so the final value has to be exact. +// +// A one-instruction race is not something a test can hit on demand, so this is corroboration +// rather than the guarantee - the guarantee is structural, and test_monotonic_reads_do_not_advance +// _the_carry pins it. What this case does catch is any future change that puts a write back on the +// read path. +void test_monotonic_exact_with_concurrent_readers() +{ + constexpr int kReaders = 4; + constexpr int kWraps = 3; + constexpr uint32_t kStep = 0x40000000u; // quarter of a cycle, so each wrap is crossed mid-step + + Time::setTestMillis(0xFFFFF000u); + Time::serviceMonotonic(); + + std::atomic stop{false}; + std::atomic wentBackwards{false}; + std::vector readers; + for (int i = 0; i < kReaders; i++) { + readers.emplace_back([&stop, &wentBackwards]() { + uint64_t previous = 0; + while (!stop.load(std::memory_order_relaxed)) { + const uint64_t now = Time::getMillisMonotonic(); + if (now < previous) + wentBackwards.store(true, std::memory_order_relaxed); + previous = now; + } + }); + } + + uint64_t expected = 0xFFFFF000ull; + for (int i = 0; i < kWraps * 4; i++) { + advanceAndService(kStep); + expected += kStep; + } + + stop.store(true, std::memory_order_relaxed); + for (auto &reader : readers) + reader.join(); + + TEST_ASSERT_FALSE_MESSAGE(wentBackwards.load(std::memory_order_relaxed), "monotonic clock retreated for a reader"); + TEST_ASSERT_EQUAL_UINT64(expected, Time::getMillisMonotonic()); +} + +// nRF BLE callbacks run above the main loop. A reader that preempts publication must be able to +// consume the previous complete snapshot without waiting for the suspended writer. +void test_monotonic_reader_completes_while_publish_is_paused() +{ + Time::setTestMillis(100); + Time::serviceMonotonic(); + Time::advanceTestMillis(1); + + publishPaused.store(false, std::memory_order_relaxed); + releasePublish.store(false, std::memory_order_relaxed); + Time::setMonotonicPublishHookForTests(pauseMonotonicPublish); + + std::thread writer([]() { Time::serviceMonotonic(); }); + while (!publishPaused.load(std::memory_order_acquire)) + std::this_thread::yield(); + + std::atomic readerStarted{false}; + std::atomic readerDone{false}; + uint64_t readerValue = 0; + std::thread reader([&readerStarted, &readerDone, &readerValue]() { + readerStarted.store(true, std::memory_order_release); + readerValue = Time::getMillisMonotonic(); + readerDone.store(true, std::memory_order_release); + }); + while (!readerStarted.load(std::memory_order_acquire)) + std::this_thread::yield(); + const auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(100); + while (!readerDone.load(std::memory_order_acquire) && std::chrono::steady_clock::now() < deadline) + std::this_thread::yield(); + const bool completedWhilePaused = readerDone.load(std::memory_order_acquire); + + releasePublish.store(true, std::memory_order_release); + writer.join(); + reader.join(); + Time::setMonotonicPublishHookForTests(nullptr); + + TEST_ASSERT_TRUE_MESSAGE(completedWhilePaused, "reader waited for a lower-priority publisher"); + TEST_ASSERT_EQUAL_UINT64(101u, readerValue); +} + +// --- getTime(): the wall clock must not retreat at the millis() wrap --- + +// Epoch used by the wall-clock cases; must sit between BUILD_EPOCH (stamped at build time) and +// BUILD_EPOCH + 40 years or perhapsSetRTC() rejects it as implausible - so derive it. +#ifdef BUILD_EPOCH +static constexpr uint32_t kTestEpoch = (uint32_t)BUILD_EPOCH + 3600; +#else +static constexpr uint32_t kTestEpoch = 1800000000u; +#endif + +void test_getTime_stays_exact_across_the_wrap() +{ + resetRTCStateForTests(); + Time::setTestMillis(0xFFFFFF00u); // 256ms short of the wrap + Time::serviceMonotonic(); + + struct timeval tv = {}; + tv.tv_sec = kTestEpoch; + TEST_ASSERT_EQUAL_INT(RTCSetResultSuccess, perhapsSetRTC(RTCQualityFromNet, &tv)); + TEST_ASSERT_EQUAL_UINT32(kTestEpoch, getTime(false)); + + advanceAndService(400u * 1000u); // crosses the wrap partway through + // With a 32-bit anchor this read came back 49.7 days in the past. + TEST_ASSERT_EQUAL_UINT32(kTestEpoch + 400, getTime(false)); +} + +// The anchor must also be correct when the time-set itself happens after a counted wrap, i.e. +// when the monotonic clock is already past 32-bit range. +void test_getTime_anchored_after_a_wrap_is_exact() +{ + resetRTCStateForTests(); + Time::setTestMillis(0xFFFFFF00u); + Time::serviceMonotonic(); // latch the pre-wrap value + advanceAndService(0x200u); // cross the wrap; monotonic is now > 2^32 + + struct timeval tv = {}; + tv.tv_sec = kTestEpoch; + TEST_ASSERT_EQUAL_INT(RTCSetResultSuccess, perhapsSetRTC(RTCQualityFromNet, &tv)); + + advanceAndService(100u * 1000u); + TEST_ASSERT_EQUAL_UINT32(kTestEpoch + 100, getTime(false)); +} + +// A reader on another thread must not be able to perturb the wall clock. This is the user-visible +// shape of the race: getTime() is reached from the nRF52 BLE task and the portduino web server +// threads, and a double-counted wrap put every rx_time and last_heard ~49.7 days in the future. +void test_getTime_unaffected_by_concurrent_readers_across_the_wrap() +{ + resetRTCStateForTests(); + Time::setTestMillis(0xFFFFF800u); // exactly 0x800 short of the wrap, so the first advance lands on it + Time::serviceMonotonic(); + + struct timeval tv = {}; + tv.tv_sec = kTestEpoch; + TEST_ASSERT_EQUAL_INT(RTCSetResultSuccess, perhapsSetRTC(RTCQualityFromNet, &tv)); + + std::atomic stop{false}; + std::vector readers; + for (int i = 0; i < 4; i++) { + readers.emplace_back([&stop]() { + while (!stop.load(std::memory_order_relaxed)) + (void)getTime(false); // what the BLE / web-server threads actually call + }); + } + + advanceAndService(0x800u); // cross the wrap while the readers are running + advanceAndService(60u * 1000u); // and some ordinary time after it + + stop.store(true, std::memory_order_relaxed); + for (auto &reader : readers) + reader.join(); + + TEST_ASSERT_EQUAL_UINT32(kTestEpoch + 62, getTime(false)); // 0x800ms + 60s, rounded down +} + +// --- real clock fallback --- + +void test_real_clock_advances_when_not_injected() +{ + Time::useRealClock(); + uint32_t t0 = Time::getMillis(); + testDelay(5); + uint32_t t1 = Time::getMillis(); + TEST_ASSERT_TRUE(t1 >= t0); // real millis() is monotonic over a short delay +} + +void setup() +{ + initializeTestEnvironment(); + UNITY_BEGIN(); + RUN_TEST(test_getMillis_returns_injected_value); + RUN_TEST(test_advanceTestMillis_steps_clock); + RUN_TEST(test_advanceTestMillis_wraps_like_millis); + RUN_TEST(test_monotonic_matches_millis_before_any_wrap); + RUN_TEST(test_monotonic_counts_a_wrap); + RUN_TEST(test_monotonic_reader_crosses_the_wrap_without_a_publish); + RUN_TEST(test_monotonic_reads_do_not_advance_the_carry); + RUN_TEST(test_monotonic_counts_every_wrap_when_serviced_each_window); + RUN_TEST(test_monotonic_misses_a_wrap_not_serviced_within_the_window); + RUN_TEST(test_getUptimeSecs_stays_exact_across_the_wrap); + RUN_TEST(test_monotonic_exact_with_concurrent_readers); + RUN_TEST(test_monotonic_reader_completes_while_publish_is_paused); + RUN_TEST(test_getTime_stays_exact_across_the_wrap); + RUN_TEST(test_getTime_anchored_after_a_wrap_is_exact); + RUN_TEST(test_getTime_unaffected_by_concurrent_readers_across_the_wrap); + RUN_TEST(test_real_clock_advances_when_not_injected); + exit(UNITY_END()); +} + +void loop() {} diff --git a/userPrefs.jsonc b/userPrefs.jsonc index fc18c00978..eb9ff3faf9 100644 --- a/userPrefs.jsonc +++ b/userPrefs.jsonc @@ -25,6 +25,7 @@ // "USERPREFS_CONFIG_DEVICE_ROLE": "meshtastic_Config_DeviceConfig_Role_CLIENT", // Defaults to CLIENT. ROUTER*, and LOST AND FOUND roles are restricted. // "USERPREFS_EVENT_MODE": "1", // "USERPREFS_EVENT_MODE_HOP_LIMIT": "3", // Event-mode default and firmware-generated/relay hop cap (0-7; default 3) + // "USERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL": "1", // Block location TX + discard inbound location on channels keyed with USERPREFS_CHANNEL_0_PSK. Defaults off, and must be set explicitly. // "USERPREFS_TMM_APPLY_TO_PRIVATE_CHANNELS": "1", // Extend TMM position dedup and precision clamping to private/custom-key channels (default: well-known channels only) // "USERPREFS_FIRMWARE_EDITION": "meshtastic_FirmwareEdition_BURNING_MAN", // "USERPREFS_FIXED_BLUETOOTH": "121212", diff --git a/variants/esp32/chatter2/variant.h b/variants/esp32/chatter2/variant.h index d13db08c6a..0dc5cfaa95 100644 --- a/variants/esp32/chatter2/variant.h +++ b/variants/esp32/chatter2/variant.h @@ -5,7 +5,7 @@ ////////////////////////////////////////////////////////////////////////////////// // Debugging -// #define GPS_DEBUG +// #define GPS_DEBUG 1 // Lora #define USE_LLCC68 // Original Chatter2 with LLCC68 module diff --git a/variants/esp32/tbeam/variant.h b/variants/esp32/tbeam/variant.h index 1bab8c3c3d..3d13f9cbdb 100644 --- a/variants/esp32/tbeam/variant.h +++ b/variants/esp32/tbeam/variant.h @@ -43,7 +43,7 @@ #define GPS_UBLOX #define GPS_RX_PIN 34 #define GPS_TX_PIN 12 -// #define GPS_DEBUG +// #define GPS_DEBUG 1 // Used when the display shield is chosen #ifdef USE_ST7796 diff --git a/variants/esp32s3/ELECROW-ThinkNode-G3/platformio.ini b/variants/esp32s3/ELECROW-ThinkNode-G3/platformio.ini index f3d5e0f3b8..92236f638d 100644 --- a/variants/esp32s3/ELECROW-ThinkNode-G3/platformio.ini +++ b/variants/esp32s3/ELECROW-ThinkNode-G3/platformio.ini @@ -28,4 +28,4 @@ build_src_filter = lib_deps = ${esp32s3_base.lib_deps} # renovate: datasource=github-tags depName=ESP32-CH390 packageName=meshtastic/ESP32-CH390 - https://github.com/meshtastic/ESP32-CH390/archive/refs/tags/v1.1.0.zip + https://github.com/meshtastic/ESP32-CH390/archive/v1.1.1.zip diff --git a/variants/esp32s3/ELECROW-ThinkNode-M7/platformio.ini b/variants/esp32s3/ELECROW-ThinkNode-M7/platformio.ini index bfa69ab6c0..c1a872f89e 100644 --- a/variants/esp32s3/ELECROW-ThinkNode-M7/platformio.ini +++ b/variants/esp32s3/ELECROW-ThinkNode-M7/platformio.ini @@ -28,4 +28,4 @@ build_src_filter = lib_deps = ${esp32s3_base.lib_deps} # renovate: datasource=github-tags depName=ESP32-CH390 packageName=meshtastic/ESP32-CH390 - https://github.com/meshtastic/ESP32-CH390/archive/refs/tags/v1.1.0.zip + https://github.com/meshtastic/ESP32-CH390/archive/v1.1.1.zip diff --git a/variants/esp32s3/t-beam-bpf/variant.h b/variants/esp32s3/t-beam-bpf/variant.h index d4f316ae85..eaf5012d23 100644 --- a/variants/esp32s3/t-beam-bpf/variant.h +++ b/variants/esp32s3/t-beam-bpf/variant.h @@ -67,4 +67,5 @@ // PMU #define HAS_AXP2101 -// #define PMU_IRQ 4 // Leave disabled for now +#define PMU_IRQ 4 +#define PMU_POWER_BUTTON_IS_CANCEL // maps a short click of the power button to a cancel action (turning off the screen) diff --git a/variants/esp32s3/t-deck/platformio.ini b/variants/esp32s3/t-deck/platformio.ini index be0be7d023..047371db9e 100644 --- a/variants/esp32s3/t-deck/platformio.ini +++ b/variants/esp32s3/t-deck/platformio.ini @@ -69,7 +69,7 @@ build_flags = -D RADIOLIB_DEBUG_SPI=0 -D RADIOLIB_DEBUG_PROTOCOL=0 -D RADIOLIB_SPI_PARANOID=0 -; -D CALIBRATE_TOUCH=0 + -D CALIBRATE_TOUCH=0 -D LGFX_SCREEN_WIDTH=240 -D LGFX_SCREEN_HEIGHT=320 -D LGFX_BUFSIZE=153600 diff --git a/variants/native/portduino/platformio.ini b/variants/native/portduino/platformio.ini index feaff1c80e..37d5bf2a08 100644 --- a/variants/native/portduino/platformio.ini +++ b/variants/native/portduino/platformio.ini @@ -137,6 +137,18 @@ test_testing_command = ${platformio.build_dir}/${this.__env__}/meshtasticd -s +[env:coverage-event-policy] +extends = env:coverage +build_flags = ${env:coverage.build_flags} + -DUSERPREFS_BLOCK_POSITION_ON_EVENT_CHANNEL=1 + -DUSERPREFS_CHANNEL_0_PSK='{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}' +test_filter = + test_position_precision + test_event_channel_router + test_nexthop_routing + test_event_channel_phone_api + test_mqtt + ; --------------------------------------------------------------------------- ; Native build for macOS (Darwin / arm64 + x86_64). Headless meshtasticd that ; runs in SimRadio mode (`-s`) or against real LoRa hardware via a CH341 diff --git a/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h b/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h index 323873660b..5a6f0074e5 100644 --- a/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h +++ b/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h @@ -135,7 +135,7 @@ https://github.com/brad112358/easy_E22 #endif #define GPS_UBLOX -// define GPS_DEBUG +// #define GPS_DEBUG 1 // UART interfaces #define PIN_SERIAL1_TX GPS_TX_PIN diff --git a/variants/nrf52840/dls_Minimesh_Lite/variant.h b/variants/nrf52840/dls_Minimesh_Lite/variant.h index 32c16f06df..47c6727dd5 100644 --- a/variants/nrf52840/dls_Minimesh_Lite/variant.h +++ b/variants/nrf52840/dls_Minimesh_Lite/variant.h @@ -57,7 +57,7 @@ extern "C" { #define PIN_GPS_EN (0 + 24) #define GPS_UBLOX -// define GPS_DEBUG +// #define GPS_DEBUG 1 // UART interfaces #define PIN_SERIAL1_TX GPS_TX_PIN diff --git a/variants/nrf52840/seeed_wio_tracker_L1/variant.h b/variants/nrf52840/seeed_wio_tracker_L1/variant.h index 9e1df0fa34..aeaa8f44af 100644 --- a/variants/nrf52840/seeed_wio_tracker_L1/variant.h +++ b/variants/nrf52840/seeed_wio_tracker_L1/variant.h @@ -129,7 +129,7 @@ static const uint8_t SCL = PIN_WIRE_SCL; #define PIN_GPS_STANDBY D0 -// #define GPS_DEBUG +// #define GPS_DEBUG 1 // #define GPS_EN D18 // P1.05 #endif diff --git a/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h b/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h index 1ff18ec2fa..9dd92a5f5d 100644 --- a/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h +++ b/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h @@ -137,7 +137,7 @@ static const uint8_t SCL = PIN_WIRE_SCL; #define PIN_GPS_STANDBY D0 -// #define GPS_DEBUG +// #define GPS_DEBUG 1 // #define GPS_EN D18 // P1.05 #endif diff --git a/variants/nrf52840/t-echo-lite/variant.h b/variants/nrf52840/t-echo-lite/variant.h index 54c7bdfb51..fe2c3076c8 100644 --- a/variants/nrf52840/t-echo-lite/variant.h +++ b/variants/nrf52840/t-echo-lite/variant.h @@ -131,7 +131,7 @@ static const uint8_t A0 = PIN_A0; #define PIN_SPI1_SCK PIN_EINK_SCLK // GPS pins -// #define GPS_DEBUG +// #define GPS_DEBUG 1 #define GPS_L76K #define GPS_BAUDRATE 9600 #define HAS_GPS 1 diff --git a/variants/nrf54l15/nrf54l15.ini b/variants/nrf54l15/nrf54l15.ini index 31adaee102..45e997271e 100644 --- a/variants/nrf54l15/nrf54l15.ini +++ b/variants/nrf54l15/nrf54l15.ini @@ -1,5 +1,18 @@ [nrf54l15_base] platform = https://github.com/Seeed-Studio/platform-seeedboards.git +; Pin the Zephyr package explicitly. Seeed's platform script only maps their +; own "seeed-xiao-*" board ids to a framework-zephyr package; any other board +; -- nrf54l15dk included -- falls back to whatever platform.json declares as +; the default, which is now framework-zephyr-nrf54lm20 (Zephyr 4.4.0). Its +; west manifest pulls a CMSIS_6 whose cmsis_gcc.h calls the ACLE builtins +; __sxtb16/__sxtab16, and none of the GCC ARM toolchains PlatformIO ships +; (8.2.1/9.2.1/9.3.1) declare them in arm_acle.h. In C that is only an +; implicit-declaration warning, so the pure-C Zephyr core never notices; in +; C++ it is a hard error, and any .cpp pulling in zephyr/kernel.h hits it. +; Without the pin a fresh package cache breaks this build with nothing in the +; tree having changed. +platform_packages = + platformio/framework-zephyr-nrf54lm20@https://dl.registry.platformio.org/download/platformio/tool/framework-zephyr/3.40201.251021/framework-zephyr-3.40201.251021.tar.gz framework = zephyr extends = arduino_base diff --git a/variants/rp2350/rp2350.ini b/variants/rp2350/rp2350.ini index 3cff5534d6..0705ed8eca 100644 --- a/variants/rp2350/rp2350.ini +++ b/variants/rp2350/rp2350.ini @@ -7,7 +7,7 @@ platform = extends = arduino_base platform_packages = # TODO renovate - arduino-pico@https://github.com/earlephilhower/arduino-pico/releases/download/5.7.0/rp2040-5.7.0.zip + arduino-pico@https://github.com/earlephilhower/arduino-pico/releases/download/6.0.0/rp2040-6.0.0.zip board_build.core = earlephilhower board_build.filesystem_size = 0.5m