mirror of
https://github.com/meshtastic/firmware.git
synced 2026-11-07 23:04:49 -05:00
ee15508494
* time: add skipZero/safeMillis/timerEndsAtMillis helpers
skipZero() steps a millis value past 0, since stored stamps and deadlines
conventionally use 0 for "unset" and the one tick per ~49.7-day wrap that
lands on 0 would otherwise read as never-set.
safeMillis() covers a bare stamp; timerEndsAtMillis(delayMs) covers a
deadline, where the sum is what has to dodge 0 - a non-zero read plus a
delay lands there once per wrap - so it is not safeMillis() + delayMs.
* time: replace hand-rolled zero-dodging with the UptimeClock helpers
PacketHistory rxTimeMsec, EncryptedStorage s_lastFailMillis (stamps), and
SGM41562 lastRefreshMs_ / NextHopRouter learnedAtMsec (ternary stamps) each
hand-rolled skipZero() in place; swap in safeMillis()/skipZero() directly.
HapticFeedback pulseOffAt/delayedPulseAt and GPS fixHoldEnds hand-rolled the
deadline form - millis() + delay, then remap a 0 result to 1 - swap in
timerEndsAtMillis(delay).
No behavior change; each site keeps the value it already computed.
* time: guard the remaining 0-means-unset deadline/stamp writes
rebootAtMsec, shutdownAtMsec, and NotificationRenderer::alertBannerUntil are
all read back with a bare == 0 / != 0 check for 'not scheduled', but every
write site computed millis() + delay (or a bare millis() stamp) with no
guard against landing exactly on 0 - the same wrap hazard skipZero() exists
for, just never applied here.
Route every rebootAtMsec/shutdownAtMsec/alertBannerUntil write through
timerEndsAtMillis()/safeMillis(); RadioLibInterface's reboot-on-stuck-tx
sums an already-captured stamp rather than "now", so it goes through
skipZero() directly instead.
No behavior change outside the ~1-in-2^32 wrap window each site was
already exposed to.
* time: guard three more 0-means-unset deadline writes
ntp_renew (ethClient.cpp), suppressTouchTapUntilMs (Events.cpp), and tx_after
(RadioLibInterface.cpp) all read back 0 as a real state - forced NTP renewal,
no suppress window active, no TX delay armed, respectively - but each arm
site wrote a bare millis()/getMillis() + delay with no guard against the sum
landing exactly on 0.
Route each through Time::timerEndsAtMillis(). No behavior change outside the
wrap window each site was already exposed to.
Refresh the Throttle.h TODO list to note ntp_renew is converted too.
* motion: guard the calibration deadline and use Throttle::deadlinePassed
endCalibrationAt's arm site wrote millis() + calibrateFor with no guard
against landing on 0, the same value finishCalibrationIfExpired()/
drawFrameCalibration() treat as "not calibrating". Route it through
Time::timerEndsAtMillis().
Also swap finishCalibrationIfExpired()'s hand-rolled (int32_t)(now - deadline)
< 0 for Throttle::deadlinePassed(): same wrap-safe comparison the codebase
already provides, without the signed-cast pattern Throttle.h documents as
implementation-defined past INT32_MAX, and it drops the file's last direct
millis() call in favor of the Time:: wrapper the rest of it already uses.
* time: fix Throttle::execute()'s own zero-dodging
Both places execute() writes *lastExecutionMs - the first-ever-run branch
and the regular update - used bare Time::getMillis() with no guard against
landing on 0, which is the exact sentinel this function reads back as
"never run" one line above. A hit there makes the next call re-fire
immediately instead of respecting minumumIntervalMs.
Capture now via Time::safeMillis() once; every use downstream (the elapsed
comparison, the stored value) is then safe by construction instead of
needing the guard reapplied at each write.
* revert some safeMillis cases where overflow is a bad thing
* test(uptime): pin skipZero/safeMillis/timerEndsAtMillis at the wrap boundary
Covers the zero case, an ordinary nonzero value, and a sum that lands
exactly on 0 from a nonzero start - the case timerEndsAtMillis() exists
for, and the one the prior suite had no direct coverage of.
* time: restore the route-health write normalization and put it on one clock
noteRouteLearned()/noteRouteSuccess() lost their `now ? now : 1` normalization,
leaving learnedAtMsec able to store 0 - which getOrAllocRouteHealth() reads as an
ever-growing age, making the slot the first eviction candidate and permanently
stale. Normalize at the write, where the block comment already says it happens,
so every caller is covered rather than just today's two.
Both callers, the two isRouteStale() sites and doRetransmissions() now read
Time::getMillis(), so the stamp and every comparison against it share a clock.
doRetransmissions() goes back to getMillis(): its `now` feeds only comparisons,
never a 0-sentinel field, so skipping zero there only cost accuracy.
* time: read the haptic, InkHUD and calibration deadlines on the write's clock
These three deadlines were converted to Time::timerEndsAtMillis() on the write
side while their reads stayed on millis(), so each spanned two clocks and would
fire immediately or never under an injected test clock. Convert the reads to
match: HapticFeedback::scheduleNext()/runOnce(), the InkHUD tap-suppression
window, and the calibration countdown's read-back of screen->getEndCalibration().
MotionSensor's sampledAtMs is left alone - its write and read are both millis()
and consistent already.
* time: correct the sentinel notes to match what the code actually does
The Throttle.h enumeration claimed the remaining timerEndsAtMillis() callers
"already dodge the sentinel", which reads as a completeness claim the same branch
contradicts: RadioLibInterface's tx_after and activeReceiveStart are both 0=unarmed
and both still arm from bare millis(). Name them instead, so the deadline-type
conversion has the real list. The ntp_renew entry now separates a deliberate 0
("due now", forced at link-up) from a computed one, which is what changed there.
The three TODO(elapsed-stamp) blocks ran four and five lines against the repo's
one-or-two rule, and two of them argued their case wrongly. Throttle.cpp implied
safeMillis() simply doesn't help; in fact neither store is safe on the wrap tick -
the 1 underflows a same-instant read, the 0 re-takes the never-run branch - which
is the symmetry worth recording. PacketHistory.cpp called its dodge "reflecting
the previous pattern" when it is load-bearing: rxTimeMsec 0 means "empty slot"
(PacketHistory.h:21) and insert() drops a record stamped 0 outright, so without it
a packet arriving on the wrap tick is never stored and loses its dedup.
Also picks up trunk fmt's trailing-whitespace fix in Throttle.cpp and the comment
realignment in SGM41562.cpp that this branch's added comment knocked out.
* test(nexthop): pin the route-health stamp against the 0 sentinel
The uptime suite covers skipZero/safeMillis/timerEndsAtMillis themselves, but
nothing covered a call site, so the branch deleted noteRouteLearned()'s
normalization and stayed green. None of the existing route-health tests pass 0 as
`now` - they use 1000, learnAt, or millis() - (TTL + 5000) - which is exactly the
gap the regression went through.
Both new tests fail with "Expected 0 to be not equal to 0" when the skipZero() is
backed out of NextHopRouter, and pass with it. noteRouteSuccess() only refreshes
an existing record, so its twin learns a route first to reach the write.
Also drops a self-referential assertion in the uptime suite: comparing
getMillis() against safeMillis() passes even if safeMillis() does no dodge at
all, so it now asserts the literal.
* discard safemillis for skipzero (better semantics and therefore maintainability) and make consistent use of getmillis where it is called (to permit testing)
* more wrapzero safety
* STM gets some too
* time: stop the next 0-means-unset deadline being armed from raw millis()
The fields this branch armed through Time::timerEndsAtMillis() / Time::skipZero()
are the kind that get added by copy-paste: `rebootAtMsec = millis() + N` appears
at twenty-odd sites across six files, and the next module to defer a reboot will
be written from one of them. Nothing catches the mistake afterwards - the sum
lands on 0 for one tick per ~49.7-day wrap, so a test run, a soak and a bench
session all pass while a pending reboot, shutdown, DFU jump or banner expiry is
silently dropped.
Two guards, at the two places it can go wrong.
The helpers themselves: skipZero() is constexpr, so its contract is now pinned by
static_assert in the header rather than only by test_uptime_clock. The asserts are
chosen against the two plausible rewrites - `ms | 1` perturbs every even value and
`ms + 1` turns the last tick of the wrap into the 0 the function exists to avoid.
Both compile, and both pass a test that only checks skipZero(0); each trips a
distinct assert here, naming the failure mode.
The call sites: bin/lint-unset-sentinel-millis.sh flags a sentinel field in src/
assigned from a raw millis()/getMillis() read, and names the helper to use. It is
name-driven because the 0 contract is declared in src/main.h and enforced in six
other files, so no single-file scan can infer it; every one of the thirteen fields
was checked to actually test against 0 before being listed. nagCycleCutoff and
LinuxJoystick's nextRepeatX/nextRepeatY are deliberately absent - their unset state
is a separate bool - and the nine remaining `millis() + x` sites in src/ are locals
that never store 0 for anything to misread.
Blocking, unlike its note-level neighbours: there is no run-time enforcer to pair
with, and the tree has zero violations today, so gating costs nothing. Scoped to
src/ so test_uptime_clock can keep building raw wrap values on purpose.
bin/test-lint-unset-sentinel-millis.sh pins the scanner against 23 fixtures -
reads, disarms, shadowing locals, comments, string literals and the already-fixed
forms all have to stay quiet.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* time: guard the four 0-means-unset stamps this branch had missed
Sweeping src/ for the `if (stamp && <deadline check>)` idiom - the shape that
makes 0 mean "unset" - turned up four stamps still armed from a raw clock read,
so the new lint rule would have had to either ignore them or go red on checkout.
Each is the same one-tick-per-wrap hole the rest of the branch closes:
* TrackballInterruptBase lastInterruptTime, armed in all four ISR handlers and
explicitly disarmed to 0 at the threshold reset. getMillis() is the ISR-safe
read by construction - it compiles to millis() outside PIO_UNIT_TESTING - and
skipZero() is pure, so neither adds anything to interrupt context.
* NeighborInfoModule lastSentReply, read as `if (lastSentReply && ...)` before
the 3-minute reply throttle. Needed the UptimeClock.h include.
* PositionModule lastSentReply, same throttle; already on the injectable clock
but still missing the guard.
* NodeDB lastSort, whose own read spells the sentinel out as `lastSort == 0 ||`.
On the wrap tick each would read as never-stamped: a trackball debounce window
lost, a neighbour or position reply sent inside the throttle it was meant to
respect, one extra NodeDB sort. Cheap individually, which is why they were missed.
All four are now listed in bin/lint-unset-sentinel-millis.sh, so the rule covers
every field in the tree that actually tests against 0 rather than a subset, and
the header records the eight stamps left off for the opposite reason - their unset
state is a separate flag (isNagging, busyTx, heldX/heldY, formatted_this_boot,
heartbeat, gotwind, haveSample, lastIaqValid), so 0 is a value they may legally
hold. The rule is silent across src/ on this tree.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* lint: let a site opt out of the sentinel rule, with its reason on the record
The rule is blocking, so it needs an escape hatch for the site where 0 genuinely
is a legal timestamp - and the hatch should cost something, or it becomes the
first thing anyone reaches for. `unset-sentinel-ok: <reason>` in a comment on the
write, or on a comment line above it, suppresses that one statement:
// unset-sentinel-ok: busyTx carries the armed state, so 0 is a legal stamp here
lastTxStart = Time::getMillis();
The reason is mandatory. A bare `unset-sentinel-ok`, or a colon with nothing
after it, is reported instead of honoured - with a message saying so - so the
only way to silence a site is to write down why it is safe. trunk-ignore still
works, but this states the justification at the write and also applies when the
script runs outside trunk.
The marker is read from comment text collected during the same character-level
pass that strips comments and literals, not by re-scanning the raw line. That is
what keeps it out of reach of data: LOG_DEBUG("unset-sentinel-ok: ...") mutes
nothing, because a string literal is not a comment. It is also consumed by the
statement it was written for, so it cannot leak onto the next write - while still
carrying across any number of intervening comment lines to the statement below,
which is where a real justification wants to be written.
Twelve fixtures added for the new behaviour: both comment styles, block and
multi-line block comments, the bare form, the marker-in-a-string cases, and three
leak cases. 35 total, all green, under bash 3.2 as well.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* lint: watch the separate-flag stamps too, with their exemption stated at the write
The nine stamps whose armed state lives in a companion boolean were previously
just absent from the rule's list, which meant the reasoning for leaving them out
existed only as prose in a shell script. They are now listed and individually
opted out at the write, naming the flag that actually carries the armed state:
// unset-sentinel-ok: haveSample carries the armed state, so 0 is a legal stamp
lastSampleMs = Time::getMillis();
The point is what happens later. If someone rewrites `if (haveSample && ...)` as
`if (lastSampleMs && ...)`, the field has silently acquired the 0 contract; with
the opt-out sitting at the write, the claim to re-examine is in front of whoever
makes that edit instead of buried in bin/.
Every exemption was checked against its real read sites before being written, and
three candidates did not survive that check. They stay off the list, because
listing one would mean stamping an opt-out over a claim that does not hold:
* nagCycleCutoff. handleInputEvent reads `if (nagCycleCutoff != UINT32_MAX)`
without consulting isNagging, so at that read the field is its own armed flag
with UINT32_MAX as the sentinel - and the arm at ExternalNotificationModule
.cpp:521 can land exactly there. skipZero() cannot help: it lifts 0 to 1 and
leaves UINT32_MAX alone, which UptimeClock.h's own static_assert pins. There
is also a live boot-state bug behind this - the in-class initializer is 1
while isNagging starts false - and fixing the read is a behaviour change that
belongs in its own PR.
* TouchScreenBase::_start. Overloaded as an event stamp AND a `+ 30000`
suppression deadline compared by signed subtraction, so a near-zero value
reads as "long ago" rather than "armed 30s out" and LONG_PRESS re-fires.
skipZero() does not fix this one either: 1 reads as long-ago exactly as 0
does. It needs the stamp and the deadline held separately.
* StoreForwardModule::retry_delay. No reads at all today, so nothing misbehaves
yet; exempting it now would pre-approve the raw arm for whoever implements the
retry its own comment promises.
The rule is silent across src/ on this tree, and the header records all three
rejections so the next person does not have to re-derive them. The self-test's
negative fixture no longer uses nagCycleCutoff as its example of a safely
unlisted field - that would have encoded the opposite of what the header says.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* fix(time,lint): guard the recomputed tx_after, and judge one write at a time
Two review findings, both real.
setTransmitDelay() recomputes p->tx_after from a clamp of three candidates, and
that recomputation was still raw. Two lines above it, `if (p->tx_after)` is the read
that takes 0 as "no delay wanted", so a clamp landing on 0 drops the CSMA backoff
and the packet goes out immediately instead of after its computed delay. The first
arm site in this function was already guarded; this one was missed because the
value is not a plain `now + delay` and so does not fit timerEndsAtMillis() - it
takes skipZero() instead.
The narrowing order matters here and is spelled out at the site: add_delay is
unsigned long, 64-bit on the portduino host, so the clamp can exceed UINT32_MAX
there. skipZero() on the wide value would pass 0x100000000 through as non-zero and
the store to this uint32_t field would then truncate it back to the 0 being
avoided, so the cast comes first.
The lint rule judged each write by the wrong text. rhs was taken from the write to
the end of the accumulated statement, so a neighbour on the same line decided the
verdict - and it was wrong in both directions:
rebootAtMsec = millis() + 5; shutdownAtMsec = Time::timerEndsAtMillis(10);
the later helper call suppressed a genuine raw arm
rebootAtMsec = otherDeadline; shutdownAtMsec = millis();
the later millis() reported a safe copy
rhs is now cut at its own semicolon. Six fixtures cover it, including both cases
above, two raw writes on one line, two helper writes on one line, and a statement
split across lines, which must still see its whole right-hand side. 41 fixtures
total, green under bash 3.2.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* time: arm the remaining 0-means-unset stamps through the helpers
The follow-up sweep to the sixteen fields the previous commits covered. A field
here uses 0 to mean "unset" - some read spells `if (f)`, `f != 0`, `f == 0 ||` or
`f > 0`, or a site disarms it with `f = 0` - but it was armed from a raw clock read,
so once per ~49.7-day wrap it stores the value its own readers treat as never-set.
34 fields, 58 arm sites.
The rule could not have found most of them first. It treated `field = <variable>`
as inheriting whatever that variable did, which made the commonest shape in the tree
invisible: one `now = millis()` at the top of a runOnce(), then several
`xStartTime = now` below it. Listing those names would have bought no protection at
all, so the scanner now tracks a local assigned from a clock and treats a write from
it as the raw arm it is. One hop, one function, name-based, and it forgets a local
reassigned from anything else; taint is dropped at each function boundary. Twelve
fixtures pin it, including the negative cases - no leak across functions, `now` does
not match `nowMs`, and neither `==` nor `+=` records anything.
That pass immediately found a site the previous commits missed: setTransmitDelay()
recomputes p->tx_after from a tainted `now`, two lines under the `if (p->tx_after)`
read that takes 0 as "no delay wanted".
Three of the fields are worth naming because the consequence is not cosmetic:
* UpDownInterruptBase press/up/downStartTime - xDetected is only cleared INSIDE
the block guarded by `xDetected && xStartTime > 0`, so a stored 0 makes both the
entry and the exit condition unreachable and that button is dead for the rest of
the boot, not for one tick.
* PhoneAPI lastContactMsec - ServerAPI reads `lastContactMsec > 0` before the TCP
idle close, and the field stays 0 until the next inbound packet, so a client that
never speaks again leaks the socket for the life of the connection.
* EInkDisplay lastDrawMsec - `if (lastDrawMsec)` gates every plain display() call
on a keyframe having been shown, so a stored 0 stops the screen updating until
something calls Screen::forceDisplay() again.
TransmitHistory needed more than its arm sites. getLastSentToMeshMillis() returns 0
to mean "module has never sent", and besides the two stores, both reconstruction
helpers end in `millis() - msAgo`, which can produce a 0 of their own. All three
computed returns are guarded; the deliberate `return 0;` sentinels are untouched.
Judged and deliberately not changed:
* nRF54L15 connect_time_ms is armed from k_uptime_get_32(), not millis(). It is
guarded with skipZero() but keeps its own clock - swapping in Time::getMillis()
would have it compared against a k_uptime now at the watchdog read. The rule now
recognises that clock too, so listing the field is not an empty gesture.
* RotaryEncoderInterruptBase pressStartTime shares a name with the UpDown field and
has a different contract: no read here tests the stamp against 0, pressDetected
is the only armed flag. Opted out at the write. Its lastPressLongEventTime
sibling IS a `== 0` latch and is fixed.
* PositionModule line 38 copies a value the enclosing `if (restored != 0)` has
already proven non-zero. Opted out.
* pmMeasureStarted, adminKeyFallbackRefillMs, the two autosave stamps and
scrollStartDelay are lazy initialisations whose wrap behaviour costs at most one
interval and drops nothing. Left alone, and not listed.
47 lint fixtures green, the rule silent across src/, full native suite 1421/1421.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* time: dodge the wrap at the clock read, not only at the store
Review on #11830 made a point that was right and that this branch had wrong.
Applying skipZero() at the STORE while a reader measures elapsed time against a
raw clock splits the two sides apart for one tick per ~49.7-day wrap: the stamp
becomes 1 while `now` is still 0, so `now - stamp` is UINT32_MAX and a brand new
stamp reads as about 49.7 days old. Every elapsed-since guard then fires when it
must not. Concretely, UpDownInterruptBase computed `now - pressStartTime` and
emitted a long press for a fresh press, and TraceRouteModule read
`now - lastTraceRouteTime < cooldownMs` as false and bypassed its cooldown.
So the dodge moves to the read. Time::stampMillis() is getMillis() with the one 0
tick called 1; a site that both stores a stamp and measures against stamps reads
the clock once through it and stores that value directly. Nine files, and the 1 ms
skew is the same one skipZero() already documents.
Where the clock arrives as a PARAMETER the store keeps its own skipZero() as well,
because the function cannot assume the caller dodged anything. Removing that was a
real regression and test_nexthop_routing caught it: noteRouteLearned() and
noteRouteSuccess() are called with a literal 0 by
test_health_learn_never_stores_zero_sentinel and
test_health_success_never_stores_zero_sentinel, which assert the store normalises
it - 0 is the empty-slot marker getOrAllocRouteHealth() evicts on. The two guards
compose without shifting twice, since skipZero() of a non-zero value is itself.
trySmartBroadcast() and directResponseAllowed() have the same parameter shape and
keep their store-side guard for the same reason. Only stores fed by a stampMillis()
local in the same function are bare.
EInkParallelDisplay was missed the first time: the third class in the family, still
storing skipZero(getMillis()) while rate-limiting against a raw millis() local.
Normalised like its siblings.
The lint rule gained three false positives with the class-scope tracking, all of
them shapes that are not class bodies at all:
template <class T> void f(T x) { uint32_t lastSort = millis(); }
class Foo { void tick() { uint32_t lastSort = millis(); } };
void g(struct Bar *b) { uint32_t lastSort = millis(); }
Two causes. pending_class matched class/struct anywhere on the line, so a template
parameter list and an elaborated type in a parameter list both marked the following
FUNCTION body as class scope; it is anchored to the start of the line now. And
update_scope() runs at the end of a line, so a body opened earlier on the same line
had not been counted when the statement was judged; is_declaration() now also
counts unmatched braces earlier in the statement. The rule is blocking and
`template <class T>` is ordinary C++, so these would have reddened files nobody
touched.
note_taint() also never received the per-write `;` cut the judging path was given
earlier in review, so on a line holding two statements it learned taint from the
neighbour. Same cut applied.
Five tests in test_uptime_clock pin the contract, including one that asserts the
old store-only shape really does produce UINT32_MAX, and one that pins the 1 ms
skew at 399 rather than 400 so nobody "corrects" it back into a raw read. Lint
fixtures 53 -> 65. Full native suite 1426/1426, rule silent across src/.
Known residual, deliberately not changed: a store that dodges zero while its reader
measures through a Throttle:: helper still splits for that one tick, because those
helpers read the clock internally and raw. About eight sites tree-wide, including
PositionModule trySmartBroadcast and the lastContactMsec TCP idle check. Closing it
means making Throttle read through the dodge, which was proposed on #11692 and
declined there pending a caller audit, so fixing one site here would only make the
tree inconsistent. The direction is also the same one the un-dodged code already
took: a fresh stamp reads as old, and the guards involved were already passing on a
0 stamp.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* lint: a dodged value is safe to copy, not to do arithmetic on
Two more review findings on the rule, both real, both false negatives.
Arithmetic on an already-dodged value was excused. stampMillis() guarantees only
its own result, so `now + 5000` can carry a non-zero stamp straight back onto the
sentinel - 0xFFFFEC78 + 5000 is exactly 0. That sum is precisely what
Time::timerEndsAtMillis() exists to dodge, and the rule was waving it through
because a helper name appeared somewhere in the expression. Worse, a fixture
asserted that behaviour was correct, so the self-test was pinning the hole open.
A local holding a dodged value is now tracked separately from a tainted one: it may
be stored or copied straight through, but + or - applied at the OUTERMOST level is
reported and the message points at timerEndsAtMillis(). Depth-aware, so the operator
inside Time::skipZero(getMillis() - msAgo) is still fine, and so is the
`(d == 0) ? 0 : timerEndsAtMillis(d)` arming form, which has no top-level operator
at all. The wrong fixture is replaced by four: store-through, copy one more hop,
arithmetic on a dodged local, and arithmetic on a direct helper call.
A class body that opens and closes on one line was never recognised. The header
check rejected it because the line ends in a semicolon, which a one-liner body
always does, and even once armed the class brace counted as a function body and
excused the member. Both halves fixed: the header arms on the brace rather than on
the absence of a semicolon, and when the body opened on the statement being judged,
one unmatched brace is class scope while two is a method body inside it. Getting
that wrong first broke every multi-line class, because setting the per-statement
flag without also arming pending_class meant update_scope() never registered the
body - the three existing class fixtures caught it.
72 fixtures, green under bash 3.2, shellcheck clean, rule silent across src/.
No src/ or test/ file changes, so the native suite is untouched by this commit.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* style(time): trim comments to the house limit
---------
Co-authored-by: Tom <116762865+Nestpebble@users.noreply.github.com>
Co-authored-by: nomdetom <nomdetom@protonmail.com>
Co-authored-by: Tom <116762865+NomDeTom@users.noreply.github.com>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
2362 lines
76 KiB
C++
2362 lines
76 KiB
C++
/**
|
||
* @file Power.cpp
|
||
* @brief This file contains the implementation of the Power class, which is
|
||
* responsible for managing power-related functionality of the device. It
|
||
* includes battery level sensing, power management unit (PMU) control, and
|
||
* power state machine management. The Power class is used by the main device
|
||
* class to manage power-related functionality.
|
||
*
|
||
* The file also includes implementations of various battery level sensors, such
|
||
* as the AnalogBatteryLevel class, which assumes the battery voltage is
|
||
* attached via a voltage-divider to an analog input.
|
||
*
|
||
* This file is part of the Meshtastic project.
|
||
* For more information, see: https://meshtastic.org/
|
||
*/
|
||
#include "Power.h"
|
||
#include "BluetoothCommon.h"
|
||
#include "MessageStore.h"
|
||
#include "NodeDB.h"
|
||
#include "PowerFSM.h"
|
||
#include "Throttle.h"
|
||
#include "UptimeClock.h"
|
||
#include "WaypointStore.h"
|
||
#include "buzz/buzz.h"
|
||
#include "configuration.h"
|
||
#include "main.h"
|
||
#include "memory/MemAudit.h"
|
||
#include "meshUtils.h"
|
||
#include "power/PowerHAL.h"
|
||
#include "power/SGM41562.h"
|
||
#include "sleep.h"
|
||
#ifdef ARCH_ESP32
|
||
// #include <driver/adc.h>
|
||
#include <esp_adc/adc_cali.h>
|
||
#include <esp_adc/adc_cali_scheme.h>
|
||
#include <esp_adc/adc_oneshot.h>
|
||
#include <esp_err.h>
|
||
#endif
|
||
|
||
#if defined(ARCH_PORTDUINO)
|
||
#include "api/WiFiServerAPI.h"
|
||
#include "input/LinuxInputImpl.h"
|
||
#include "input/LinuxJoystick.h"
|
||
#endif
|
||
|
||
#ifdef HAS_ADS1115
|
||
#include <Adafruit_ADS1X15.h>
|
||
#endif
|
||
|
||
// Working USB detection for powered/charging states on the RAK platform
|
||
#ifdef NRF_APM
|
||
#include "nrfx_power.h"
|
||
#endif
|
||
|
||
#if defined(ARCH_NRF52)
|
||
#include "Nrf52SaadcLock.h"
|
||
#include "concurrency/LockGuard.h"
|
||
#endif
|
||
|
||
#if defined(ARCH_STM32) && defined(BATTERY_PIN)
|
||
#include "stm32yyxx_ll_adc.h"
|
||
|
||
/* Analog read resolution */
|
||
#if defined(LL_ADC_RESOLUTION_12B)
|
||
#define LL_ADC_RESOLUTION LL_ADC_RESOLUTION_12B
|
||
#define BATTERY_SENSE_RESOLUTION_BITS 12
|
||
#elif defined(LL_ADC_DS_DATA_WIDTH_12_BIT)
|
||
#define LL_ADC_RESOLUTION LL_ADC_DS_DATA_WIDTH_12_BIT
|
||
#define BATTERY_SENSE_RESOLUTION_BITS 12
|
||
#else
|
||
// The ST HAL headers that define these are outside cppcheck's include path (check_skip_packages), so static
|
||
// analysis always lands here even though real builds resolve one of the branches above.
|
||
// cppcheck-suppress preprocessorErrorDirective
|
||
#error "ADC resolution could not be defined!"
|
||
#endif
|
||
#define ADC_RANGE (1 << BATTERY_SENSE_RESOLUTION_BITS)
|
||
#endif
|
||
|
||
#if defined(DEBUG_HEAP_MQTT) && !MESHTASTIC_EXCLUDE_MQTT
|
||
#include "mqtt/MQTT.h"
|
||
#include "target_specific.h"
|
||
#if HAS_WIFI
|
||
#include <WiFi.h>
|
||
#endif
|
||
|
||
#if HAS_ETHERNET && defined(ARCH_ESP32)
|
||
#include <ETH.h>
|
||
#endif // HAS_ETHERNET
|
||
|
||
#endif
|
||
|
||
#ifndef DELAY_FOREVER
|
||
#define DELAY_FOREVER portMAX_DELAY
|
||
#endif
|
||
|
||
// How often the free-heap line is written to the debug log. The Power thread polls every
|
||
// 20s once it is initialized, so that is the effective granularity. Set to 0 to disable.
|
||
#ifndef HEAP_LOG_INTERVAL_MS
|
||
#define HEAP_LOG_INTERVAL_MS (5 * 60 * 1000)
|
||
#endif
|
||
|
||
#if defined(BATTERY_PIN) && defined(ARCH_ESP32)
|
||
|
||
#ifndef BAT_MEASURE_ADC_UNIT // ADC1 is default
|
||
static const adc_channel_t adc_channel = ADC_CHANNEL;
|
||
static const adc_unit_t unit = ADC_UNIT_1;
|
||
#else // ADC2
|
||
static const adc_channel_t adc_channel = ADC_CHANNEL;
|
||
static const adc_unit_t unit = ADC_UNIT_2;
|
||
#endif // BAT_MEASURE_ADC_UNIT
|
||
|
||
static adc_oneshot_unit_handle_t adc_handle = nullptr;
|
||
static adc_cali_handle_t adc_cali_handle = nullptr;
|
||
static bool adc_calibrated = false;
|
||
#ifndef ADC_ATTENUATION
|
||
static const adc_atten_t atten = ADC_ATTEN_DB_12;
|
||
#else
|
||
static const adc_atten_t atten = ADC_ATTENUATION;
|
||
#endif
|
||
#ifdef ADC_BITWIDTH
|
||
static const adc_bitwidth_t adc_width = ADC_BITWIDTH;
|
||
#else
|
||
static const adc_bitwidth_t adc_width = ADC_BITWIDTH_DEFAULT;
|
||
#endif
|
||
|
||
static int adcBitWidthToBits(adc_bitwidth_t width)
|
||
{
|
||
switch (width) {
|
||
case ADC_BITWIDTH_9:
|
||
return 9;
|
||
case ADC_BITWIDTH_10:
|
||
return 10;
|
||
case ADC_BITWIDTH_11:
|
||
return 11;
|
||
case ADC_BITWIDTH_12:
|
||
return 12;
|
||
#ifdef ADC_BITWIDTH_13
|
||
case ADC_BITWIDTH_13:
|
||
return 13;
|
||
#endif
|
||
default:
|
||
return 12;
|
||
}
|
||
}
|
||
|
||
static bool initAdcCalibration()
|
||
{
|
||
#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
|
||
adc_cali_curve_fitting_config_t cali_config = {
|
||
.unit_id = unit,
|
||
.atten = atten,
|
||
.bitwidth = adc_width,
|
||
};
|
||
esp_err_t ret = adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle);
|
||
if (ret == ESP_OK) {
|
||
LOG_INFO("ADC calibration: curve fitting enabled");
|
||
return true;
|
||
}
|
||
if (ret != ESP_ERR_NOT_SUPPORTED) {
|
||
LOG_WARN("ADC calibration: curve fitting failed: %s", esp_err_to_name(ret));
|
||
}
|
||
#endif
|
||
|
||
#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
|
||
adc_cali_line_fitting_config_t cali_config = {
|
||
.unit_id = unit,
|
||
.atten = atten,
|
||
.bitwidth = adc_width,
|
||
.default_vref = DEFAULT_VREF,
|
||
};
|
||
esp_err_t ret = adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle);
|
||
if (ret == ESP_OK) {
|
||
LOG_INFO("ADC calibration: line fitting enabled");
|
||
return true;
|
||
}
|
||
if (ret != ESP_ERR_NOT_SUPPORTED) {
|
||
LOG_WARN("ADC calibration: line fitting failed: %s", esp_err_to_name(ret));
|
||
}
|
||
#endif
|
||
|
||
LOG_INFO("ADC calibration unsupported; use approx scaling");
|
||
return false;
|
||
}
|
||
|
||
#endif // BATTERY_PIN && ARCH_ESP32
|
||
|
||
#ifdef EXT_PWR_DETECT
|
||
#ifndef EXT_PWR_DETECT_MODE
|
||
#define EXT_PWR_DETECT_MODE INPUT
|
||
// If using internal pull resistors, we can infer EXT_PWR_DETECT_VALUE
|
||
#elif EXT_PWR_DETECT_MODE == INPUT_PULLUP
|
||
#define EXT_PWR_DETECT_VALUE LOW
|
||
#elif EXT_PWR_DETECT_MODE == INPUT_PULLDOWN
|
||
#define EXT_PWR_DETECT_VALUE HIGH
|
||
#endif
|
||
#ifndef EXT_PWR_DETECT_VALUE
|
||
#define EXT_PWR_DETECT_VALUE HIGH
|
||
#endif
|
||
#endif
|
||
|
||
#ifdef EXT_CHRG_DETECT
|
||
#ifndef EXT_CHRG_DETECT_MODE
|
||
#define EXT_CHRG_DETECT_MODE INPUT
|
||
// If using internal pull resistors, we can infer EXT_CHRG_DETECT_VALUE
|
||
#elif EXT_CHRG_DETECT_MODE == INPUT_PULLUP
|
||
#define EXT_CHRG_DETECT_VALUE LOW
|
||
#elif EXT_CHRG_DETECT_MODE == INPUT_PULLDOWN
|
||
#define EXT_CHRG_DETECT_VALUE HIGH
|
||
#endif
|
||
#ifndef EXT_CHRG_DETECT_VALUE
|
||
#define EXT_CHRG_DETECT_VALUE HIGH
|
||
#endif
|
||
#endif
|
||
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
|
||
#if __has_include(<Adafruit_INA219.h>)
|
||
INA219Sensor ina219Sensor;
|
||
#else
|
||
NullSensor ina219Sensor;
|
||
#endif
|
||
|
||
#if __has_include(<INA226.h>)
|
||
INA226Sensor ina226Sensor;
|
||
#else
|
||
NullSensor ina226Sensor;
|
||
#endif
|
||
|
||
#if __has_include(<Adafruit_INA260.h>)
|
||
INA260Sensor ina260Sensor;
|
||
#else
|
||
NullSensor ina260Sensor;
|
||
#endif
|
||
|
||
#if __has_include(<INA3221.h>)
|
||
INA3221Sensor ina3221Sensor;
|
||
#else
|
||
NullSensor ina3221Sensor;
|
||
#endif
|
||
|
||
#endif
|
||
|
||
#if !MESHTASTIC_EXCLUDE_I2C
|
||
#include "modules/Telemetry/Sensor/MAX17048Sensor.h"
|
||
#include <utility>
|
||
extern std::pair<uint8_t, TwoWire *> nodeTelemetrySensorsMap[_meshtastic_TelemetrySensorType_MAX + 1];
|
||
#if HAS_TELEMETRY && (!MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR || !MESHTASTIC_EXCLUDE_POWER_TELEMETRY)
|
||
#if __has_include(<Adafruit_MAX1704X.h>)
|
||
MAX17048Sensor max17048Sensor;
|
||
#else
|
||
NullSensor max17048Sensor;
|
||
#endif
|
||
#endif
|
||
#endif
|
||
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && HAS_RAKPROT
|
||
RAK9154Sensor rak9154Sensor;
|
||
#endif
|
||
|
||
#ifdef HAS_PPM
|
||
// note: XPOWERS_CHIP_XXX must be defined in variant.h
|
||
#include <XPowersLib.h>
|
||
XPowersPPM *PPM = NULL;
|
||
#endif
|
||
|
||
#ifdef HAS_BQ27220
|
||
#include "bq27220.h"
|
||
#endif
|
||
|
||
#ifdef HAS_PMU
|
||
XPowersLibInterface *PMU = NULL;
|
||
#else
|
||
|
||
// Copy of the base class defined in axp20x.h.
|
||
// I'd rather not include axp20x.h as it brings Wire dependency.
|
||
class HasBatteryLevel
|
||
{
|
||
public:
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() { return -1; }
|
||
|
||
/**
|
||
* The raw voltage of the battery or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() { return 0; }
|
||
|
||
/**
|
||
* return true if there is a battery installed in this unit
|
||
*/
|
||
virtual bool isBatteryConnect() { return false; }
|
||
|
||
virtual bool isVbusIn() { return false; }
|
||
virtual bool isCharging() { return false; }
|
||
};
|
||
#endif
|
||
|
||
bool pmu_irq = false;
|
||
|
||
Power *power;
|
||
|
||
using namespace meshtastic;
|
||
|
||
// NRF52 has AREF_VOLTAGE defined in architecture.h but
|
||
// make sure it's included. If something is wrong with NRF52
|
||
// definition - compilation will fail on missing definition
|
||
#if !defined(AREF_VOLTAGE) && !defined(ARCH_NRF52)
|
||
#define AREF_VOLTAGE 3.3
|
||
#endif
|
||
|
||
/**
|
||
* If this board has a battery level sensor, set this to a valid implementation
|
||
*/
|
||
static HasBatteryLevel *batteryLevel; // Default to NULL for no battery level sensor
|
||
|
||
#ifdef BATTERY_PIN
|
||
|
||
void battery_adcEnable()
|
||
{
|
||
#ifdef ADC_CTRL // enable adc voltage divider when we need to read
|
||
#ifdef ADC_USE_PULLUP
|
||
pinMode(ADC_CTRL, INPUT_PULLUP);
|
||
#else
|
||
#ifdef HELTEC_V3
|
||
pinMode(ADC_CTRL, INPUT);
|
||
uint8_t adc_ctl_enable_value = !(digitalRead(ADC_CTRL));
|
||
pinMode(ADC_CTRL, OUTPUT);
|
||
digitalWrite(ADC_CTRL, adc_ctl_enable_value);
|
||
#else
|
||
pinMode(ADC_CTRL, OUTPUT);
|
||
digitalWrite(ADC_CTRL, ADC_CTRL_ENABLED);
|
||
#endif
|
||
#endif
|
||
delay(10);
|
||
#endif
|
||
}
|
||
|
||
static void battery_adcDisable()
|
||
{
|
||
#ifdef ADC_CTRL // disable adc voltage divider when we need to read
|
||
#ifdef ADC_USE_PULLUP
|
||
pinMode(ADC_CTRL, INPUT_PULLDOWN);
|
||
#else
|
||
#ifdef HELTEC_V3
|
||
pinMode(ADC_CTRL, ANALOG);
|
||
#else
|
||
digitalWrite(ADC_CTRL, !ADC_CTRL_ENABLED);
|
||
#endif
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
#endif
|
||
|
||
/**
|
||
* A simple battery level sensor that assumes the battery voltage is attached
|
||
* via a voltage-divider to an analog input
|
||
*/
|
||
class AnalogBatteryLevel : public HasBatteryLevel
|
||
{
|
||
public:
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() override
|
||
{
|
||
#if defined(HAS_RAKPROT) && !defined(HAS_PMU)
|
||
if (hasRAK()) {
|
||
return rak9154Sensor.getBusBatteryPercent();
|
||
}
|
||
#endif
|
||
|
||
float v = getBattVoltage();
|
||
|
||
if (v < noBatVolt)
|
||
return -1; // If voltage is super low assume no battery installed
|
||
|
||
#ifdef NO_BATTERY_LEVEL_ON_CHARGE
|
||
// This does not work on a RAK4631 with battery connected
|
||
if (v > chargingVolt)
|
||
return 0; // While charging we can't report % full on the battery
|
||
#endif
|
||
/**
|
||
* @brief Battery voltage lookup table interpolation to obtain a more
|
||
* precise percentage rather than the old proportional one.
|
||
* @author Gabriele Russo
|
||
* @date 06/02/2024
|
||
*/
|
||
float battery_SOC = 0.0;
|
||
uint16_t voltage = v / NUM_CELLS; // single cell voltage (average)
|
||
for (int i = 0; i < NUM_OCV_POINTS; i++) {
|
||
if (OCV[i] <= voltage) {
|
||
if (i == 0) {
|
||
battery_SOC = 100.0; // 100% full
|
||
} else {
|
||
// interpolate between OCV[i] and OCV[i-1]
|
||
battery_SOC = (float)100.0 / (NUM_OCV_POINTS - 1.0) *
|
||
(NUM_OCV_POINTS - 1.0 - i + ((float)voltage - OCV[i]) / (OCV[i - 1] - OCV[i]));
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#if defined(BATTERY_CHARGING_INV)
|
||
// bit of trickery to show 99% up until the charge finishes
|
||
if (!digitalRead(BATTERY_CHARGING_INV) && battery_SOC > 99)
|
||
battery_SOC = 99;
|
||
#endif
|
||
return clamp((int)(battery_SOC), 0, 100);
|
||
}
|
||
|
||
/**
|
||
* The raw voltage of the batteryin millivolts or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() override
|
||
{
|
||
|
||
#if HAS_TELEMETRY && defined(HAS_RAKPROT) && !defined(HAS_PMU) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
|
||
if (hasRAK()) {
|
||
return getRAKVoltage();
|
||
}
|
||
#endif
|
||
|
||
#if HAS_TELEMETRY && !defined(HAS_PMU) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
|
||
if (hasINA()) {
|
||
return getINAVoltage();
|
||
}
|
||
#endif
|
||
|
||
#ifndef ADC_MULTIPLIER
|
||
#define ADC_MULTIPLIER 2.0
|
||
#endif
|
||
|
||
#ifndef BATTERY_SENSE_SAMPLES
|
||
#define BATTERY_SENSE_SAMPLES \
|
||
15 // Set the number of samples, it has an effect of increasing sensitivity in
|
||
// complex electromagnetic environment.
|
||
#endif
|
||
|
||
#ifdef BATTERY_PIN
|
||
// Override variant or default ADC_MULTIPLIER if we have the override pref
|
||
float operativeAdcMultiplier =
|
||
config.power.adc_multiplier_override > 0 ? config.power.adc_multiplier_override : ADC_MULTIPLIER;
|
||
// Do not call analogRead() often.
|
||
const uint32_t min_read_interval = 5000;
|
||
if (!initial_read_done || !Throttle::isWithinTimespanMs(last_read_time_ms, min_read_interval)) {
|
||
last_read_time_ms = millis();
|
||
|
||
uint32_t raw = 0;
|
||
float scaled = 0;
|
||
|
||
battery_adcEnable();
|
||
#ifdef ARCH_STM32
|
||
// STM32 ADC with VREFINT runtime calibration
|
||
Vref = __LL_ADC_CALC_VREFANALOG_VOLTAGE(analogRead(AVREF), LL_ADC_RESOLUTION);
|
||
raw = analogRead(BATTERY_PIN);
|
||
scaled = __LL_ADC_CALC_DATA_TO_VOLTAGE(Vref, raw, LL_ADC_RESOLUTION);
|
||
scaled *= operativeAdcMultiplier;
|
||
#elif defined(ARCH_ESP32) // ADC block for espressif platforms
|
||
raw = espAdcRead();
|
||
int voltage_mv = 0;
|
||
if (adc_calibrated && adc_cali_handle) {
|
||
if (adc_cali_raw_to_voltage(adc_cali_handle, raw, &voltage_mv) != ESP_OK) {
|
||
LOG_WARN("ADC calibration read failed; using raw value");
|
||
voltage_mv = 0;
|
||
}
|
||
}
|
||
if (voltage_mv == 0) {
|
||
// Fallback approximate conversion without calibration
|
||
const int bits = adcBitWidthToBits(adc_width);
|
||
const float max_code = powf(2.0f, bits) - 1.0f;
|
||
voltage_mv = (int)((raw / max_code) * DEFAULT_VREF);
|
||
}
|
||
scaled = voltage_mv * operativeAdcMultiplier;
|
||
#else // block for all other platforms
|
||
#ifdef ARCH_NRF52
|
||
concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
|
||
#endif
|
||
for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
|
||
raw += analogRead(BATTERY_PIN);
|
||
}
|
||
raw = raw / BATTERY_SENSE_SAMPLES;
|
||
scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
|
||
#endif
|
||
battery_adcDisable();
|
||
|
||
if (!initial_read_done) {
|
||
// Flush the smoothing filter with an ADC reading, if the reading is
|
||
// plausibly correct
|
||
if (scaled > last_read_value)
|
||
last_read_value = scaled;
|
||
initial_read_done = true;
|
||
} else {
|
||
// Already initialized - filter this reading
|
||
last_read_value += (scaled - last_read_value) * 0.5; // Virtual LPF
|
||
}
|
||
|
||
// LOG_DEBUG("battery gpio %d raw val=%u scaled=%u filtered=%u",
|
||
// BATTERY_PIN, raw, (uint32_t)(scaled), (uint32_t) (last_read_value));
|
||
}
|
||
return last_read_value;
|
||
#endif // BATTERY_PIN
|
||
return 0;
|
||
}
|
||
|
||
#if defined(ARCH_ESP32) && !defined(HAS_PMU) && defined(BATTERY_PIN)
|
||
/**
|
||
* ESP32 specific function for getting calibrated ADC reads
|
||
*/
|
||
uint32_t espAdcRead()
|
||
{
|
||
|
||
uint32_t raw = 0;
|
||
uint8_t raw_c = 0; // raw reading counter
|
||
|
||
if (!adc_handle) {
|
||
LOG_ERROR("ADC oneshot handle not initialized");
|
||
return 0;
|
||
}
|
||
|
||
for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
|
||
int val = 0;
|
||
esp_err_t err = adc_oneshot_read(adc_handle, adc_channel, &val);
|
||
if (err == ESP_OK) {
|
||
raw += val;
|
||
raw_c++;
|
||
} else {
|
||
LOG_DEBUG("ADC read failed: %s", esp_err_to_name(err));
|
||
}
|
||
}
|
||
|
||
return (raw / (raw_c < 1 ? 1 : raw_c));
|
||
}
|
||
#endif
|
||
|
||
/**
|
||
* return true if there is a battery installed in this unit
|
||
*/
|
||
// if we have a integrated device with a battery, we can assume that the
|
||
// battery is always connected
|
||
#ifdef BATTERY_IMMUTABLE
|
||
virtual bool isBatteryConnect() override { return true; }
|
||
#elif defined(ADC_V)
|
||
virtual bool isBatteryConnect() override
|
||
{
|
||
int lastReading = digitalRead(ADC_V);
|
||
// 判断值是否变化
|
||
for (int i = 2; i < 500; i++) {
|
||
int reading = digitalRead(ADC_V);
|
||
if (reading != lastReading) {
|
||
return false; // 有变化，USB供电, 没接电池
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
#else
|
||
virtual bool isBatteryConnect() override { return getBatteryPercent() != -1; }
|
||
#endif
|
||
|
||
// Detect if an external power source is connected if we don’t have a PMIC;
|
||
// Firstly prefer EXT_PWR_DETECT GPIO if available,
|
||
// secondly try an nRF52-specific routine on some variants,
|
||
// lastly provide a fallback to indicate external power when fully charged.
|
||
virtual bool isVbusIn() override
|
||
{
|
||
#ifdef HAS_SGM41562
|
||
if (sgm41562 && sgm41562->refresh())
|
||
return sgm41562->isInputPowerGood();
|
||
#endif
|
||
#ifdef EXT_PWR_DETECT
|
||
if (digitalRead(EXT_PWR_DETECT) == EXT_PWR_DETECT_VALUE)
|
||
return true;
|
||
#ifdef EXT_CHRG_DETECT
|
||
// EXT_PWR_DETECT alone may not catch active charging (e.g. a charge-complete
|
||
// pin that only asserts once the battery is full) - CHRG being active implies
|
||
// power is present regardless.
|
||
return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
|
||
#else
|
||
return false;
|
||
#endif
|
||
|
||
// technically speaking this should work for all(?) NRF52 boards
|
||
// but needs testing across multiple devices. NRF52 USB would not even work if
|
||
// VBUS was not properly connected and detected by the CPU
|
||
#elif defined(MUZI_BASE) || defined(PROMICRO_DIY_TCXO) || defined(ELECROW_ThinkNode_M8)
|
||
return powerHAL_isVBUSConnected();
|
||
#endif
|
||
return getBattVoltage() > chargingVolt;
|
||
}
|
||
|
||
/// Assume charging if we have a battery and external power is connected.
|
||
/// we can't be smart enough to say 'full'?
|
||
virtual bool isCharging() override
|
||
{
|
||
#ifdef HAS_SGM41562
|
||
if (sgm41562 && sgm41562->refresh())
|
||
return sgm41562->isCharging();
|
||
#endif
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT) && !defined(HAS_PMU)
|
||
if (hasRAK()) {
|
||
return (rak9154Sensor.isCharging()) ? OptTrue : OptFalse;
|
||
}
|
||
#endif
|
||
// A configured INA outranks the board's own charge-status pin, as it does BATTERY_PIN in
|
||
// getBattVoltage(): an external charger leaves that pin idle, reading "not charging" forever.
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(DISABLE_INA_CHARGING_DETECTION)
|
||
if (hasINA()) {
|
||
// 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_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
|
||
return getINACurrent() < 0;
|
||
#endif
|
||
}
|
||
#endif
|
||
#if defined(ELECROW_ThinkNode_M6)
|
||
return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE || isVbusIn();
|
||
#elif defined(EXT_CHRG_DETECT)
|
||
return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
|
||
#elif defined(BATTERY_CHARGING_INV)
|
||
return !digitalRead(BATTERY_CHARGING_INV);
|
||
#else
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(DISABLE_INA_CHARGING_DETECTION)
|
||
// No charge-status pin and no INA: infer from battery presence plus external power.
|
||
return isBatteryConnect() && isVbusIn();
|
||
#endif
|
||
#endif
|
||
// by default, we check the battery voltage only
|
||
return isVbusIn();
|
||
}
|
||
|
||
private:
|
||
/// If we see a battery voltage higher than physics allows - assume charger is
|
||
/// pumping in power
|
||
|
||
/// For heltecs with no battery connected, the measured voltage is 2204, so
|
||
// need to be higher than that, in this case is 2500mV (3000-500)
|
||
const uint16_t OCV[NUM_OCV_POINTS] = {OCV_ARRAY};
|
||
const float chargingVolt = (OCV[0] + 10) * NUM_CELLS;
|
||
const float noBatVolt = (OCV[NUM_OCV_POINTS - 1] - 500) * NUM_CELLS;
|
||
// Start value from minimum voltage for the filter to not start from 0
|
||
// that could trigger some events.
|
||
// This value is over-written by the first ADC reading, it the voltage seems
|
||
// reasonable.
|
||
bool initial_read_done = false;
|
||
float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
|
||
uint32_t last_read_time_ms = 0;
|
||
#ifdef ARCH_STM32
|
||
// 3300mV placeholder for STM32 errata where VREFINT factory calibration may be missing
|
||
// (e.g. STM32U0, see DS14756 Rev 3 §2.4.1 "VREFINT offset")
|
||
uint32_t Vref = 3300;
|
||
#endif
|
||
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT)
|
||
|
||
uint16_t getRAKVoltage() { return rak9154Sensor.getBusVoltageMv(); }
|
||
|
||
bool hasRAK()
|
||
{
|
||
if (!rak9154Sensor.isInitialized())
|
||
return rak9154Sensor.runOnce() > 0;
|
||
return rak9154Sensor.isRunning();
|
||
}
|
||
#endif
|
||
|
||
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
|
||
uint16_t getINAVoltage()
|
||
{
|
||
if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
|
||
return ina219Sensor.getBusVoltageMv();
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA226].first ==
|
||
config.power.device_battery_ina_address) {
|
||
return ina226Sensor.getBusVoltageMv();
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first ==
|
||
config.power.device_battery_ina_address) {
|
||
return ina260Sensor.getBusVoltageMv();
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first ==
|
||
config.power.device_battery_ina_address) {
|
||
return ina3221Sensor.getBusVoltageMv();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int16_t getINACurrent()
|
||
{
|
||
if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
|
||
return ina219Sensor.getCurrentMa();
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA226].first ==
|
||
config.power.device_battery_ina_address) {
|
||
return ina226Sensor.getCurrentMa();
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first ==
|
||
config.power.device_battery_ina_address) {
|
||
return ina260Sensor.getCurrentMa();
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first ==
|
||
config.power.device_battery_ina_address) {
|
||
return ina3221Sensor.getCurrentMa();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// Open the sensor if it isn't open yet, then report whether it is actually running. runOnce()
|
||
// answers with a poll interval, so only isRunning() tells us the device replied.
|
||
static bool sensorReady(TelemetrySensor &sensor)
|
||
{
|
||
if (!sensor.isInitialized())
|
||
sensor.runOnce();
|
||
return sensor.isRunning();
|
||
}
|
||
|
||
bool hasINA()
|
||
{
|
||
const uint8_t inaAddress = config.power.device_battery_ina_address;
|
||
if (!inaAddress) {
|
||
return false;
|
||
}
|
||
if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == inaAddress) {
|
||
return sensorReady(ina219Sensor);
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA226].first == inaAddress) {
|
||
return sensorReady(ina226Sensor);
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first == inaAddress) {
|
||
return sensorReady(ina260Sensor);
|
||
} else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first == inaAddress) {
|
||
return sensorReady(ina3221Sensor);
|
||
}
|
||
return false;
|
||
}
|
||
#endif
|
||
};
|
||
|
||
static AnalogBatteryLevel analogLevel;
|
||
|
||
#ifdef HAS_ADS1115
|
||
#include "SPILock.h"
|
||
#include <AW35615.h>
|
||
|
||
/**
|
||
* @brief Battery level sensor using an ADS1115 16-bit ADC on I2C.
|
||
* Channel 0 measures battery voltage through a 1:2 resistive divider.
|
||
* USB / Charging status is managed via an AW35615 USB-C CC controller.
|
||
*/
|
||
class ADS1115BatteryLevel : public AnalogBatteryLevel
|
||
{
|
||
public:
|
||
bool init()
|
||
{
|
||
{
|
||
concurrency::LockGuard guard(spiLock);
|
||
if (!_ads.begin(ADS1115_ADDR, &Wire)) {
|
||
LOG_WARN("ADS1115 not found on I2C bus - battery sensor unavailable");
|
||
return false;
|
||
}
|
||
_ads.setGain(GAIN_ONE); // ±4.096 V FSR matches standard 1:2 voltage-divider
|
||
_ads.setDataRate(RATE_ADS1115_860SPS); // Maximize conversion speed to keep bus locking minimal
|
||
}
|
||
|
||
initialized = true;
|
||
LOG_INFO("[ADS1115] battery sensor initialized");
|
||
|
||
if (_aw35615.begin(Wire)) {
|
||
LOG_INFO("[AW35615] USB-C CC controller initialized");
|
||
} else {
|
||
LOG_WARN("[AW35615] not found at 0x22");
|
||
}
|
||
getBattVoltage(); // initial read cached_mv
|
||
return true;
|
||
}
|
||
|
||
virtual bool isBatteryConnect() override { return true; }
|
||
virtual uint16_t getBattVoltage() override
|
||
{
|
||
if (!initialized)
|
||
return 0;
|
||
|
||
static constexpr uint32_t MIN_READ_INTERVAL_MS = 30000;
|
||
if (!initial_read_done || !Throttle::isWithinTimespanMs(last_read_ms, MIN_READ_INTERVAL_MS)) {
|
||
last_read_ms = millis();
|
||
float sum = 0;
|
||
{
|
||
concurrency::LockGuard guard(spiLock);
|
||
for (uint8_t i = 0; i < SAMPLE_COUNT; i++) {
|
||
int16_t raw = _ads.readADC_SingleEnded(0);
|
||
sum += _ads.computeVolts(raw);
|
||
}
|
||
// Piggyback a toggle-engine watchdog on this same throttle interval.
|
||
// Only re-arm when VBUS is absent - calling this while attached
|
||
// would restart CC toggling and could glitch an active sink attach.
|
||
if (_aw35615.isReady() && !_aw35615.isVbusPresent()) {
|
||
_aw35615.rearmToggle();
|
||
}
|
||
}
|
||
|
||
// Voltage divider scales by 2.0; convert volts to millivolts
|
||
float v = (sum / (float)SAMPLE_COUNT) * 2.0f * 1000.0f;
|
||
|
||
if (!initial_read_done) {
|
||
cached_mv = static_cast<uint16_t>(v);
|
||
initial_read_done = true;
|
||
} else {
|
||
// Exponential moving average filter (50% smoothing)
|
||
cached_mv = static_cast<uint16_t>(cached_mv + (v - cached_mv) * 0.5f);
|
||
}
|
||
}
|
||
return cached_mv;
|
||
}
|
||
|
||
virtual bool isVbusIn() override
|
||
{
|
||
if (_aw35615.isReady()) {
|
||
concurrency::LockGuard guard(spiLock);
|
||
|
||
bool vbus = _aw35615.isVbusPresent();
|
||
if (!vbus) {
|
||
// VBUS just went away (or has been away) - make sure the CC
|
||
// toggle engine is re-armed so the next attach gets detected.
|
||
_aw35615.rearmToggle();
|
||
}
|
||
return vbus;
|
||
}
|
||
// Fallback to base GPIO/board checks (or false) if CC chip is absent
|
||
return false;
|
||
}
|
||
|
||
virtual bool isCharging() override
|
||
{
|
||
if (!isBatteryConnect())
|
||
return false;
|
||
|
||
if (_aw35615.isReady()) {
|
||
concurrency::LockGuard guard(spiLock);
|
||
// Charging == VBUS present AND we're attached as a sink.
|
||
// (isSinkAttached() is a latched result - safe to trust here since
|
||
// isVbusIn() above keeps re-arming toggle on every detach.)
|
||
return _aw35615.isVbusPresent() && _aw35615.isSinkAttached();
|
||
}
|
||
return isVbusIn();
|
||
}
|
||
|
||
private:
|
||
static constexpr uint8_t SAMPLE_COUNT = 3;
|
||
Adafruit_ADS1115 _ads;
|
||
AW35615 _aw35615;
|
||
|
||
bool initialized = false;
|
||
bool initial_read_done = false;
|
||
uint16_t cached_mv = 0;
|
||
uint32_t last_read_ms = 0;
|
||
};
|
||
|
||
static ADS1115BatteryLevel ads1115BattLevel;
|
||
|
||
bool Power::ads1115Init()
|
||
{
|
||
if (ads1115BattLevel.init()) {
|
||
batteryLevel = &ads1115BattLevel;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
#endif // HAS_ADS1115
|
||
|
||
Power::Power() : OSThread("Power")
|
||
{
|
||
statusHandler = {};
|
||
low_voltage_counter = 0;
|
||
#ifdef DEBUG_HEAP
|
||
lastheap = memGet.getFreeHeap();
|
||
#endif
|
||
}
|
||
|
||
bool Power::analogInit()
|
||
{
|
||
#ifdef EXT_PWR_DETECT
|
||
pinMode(EXT_PWR_DETECT, EXT_PWR_DETECT_MODE);
|
||
#endif
|
||
#ifdef EXT_CHRG_DETECT
|
||
pinMode(EXT_CHRG_DETECT, EXT_CHRG_DETECT_MODE);
|
||
#endif
|
||
|
||
#ifdef BATTERY_PIN
|
||
LOG_DEBUG("Use analog input %d for battery level", BATTERY_PIN);
|
||
|
||
// disable any internal pullups
|
||
pinMode(BATTERY_PIN, INPUT);
|
||
|
||
#ifndef BATTERY_SENSE_RESOLUTION_BITS
|
||
#define BATTERY_SENSE_RESOLUTION_BITS 10
|
||
#endif
|
||
|
||
#ifdef ARCH_STM32
|
||
analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
|
||
#elif defined(ARCH_ESP32) // ESP32 needs special analog stuff
|
||
adc_oneshot_unit_init_cfg_t init_config = {
|
||
.unit_id = unit,
|
||
};
|
||
|
||
if (!adc_handle) {
|
||
esp_err_t err = adc_oneshot_new_unit(&init_config, &adc_handle);
|
||
if (err != ESP_OK) {
|
||
LOG_ERROR("ADC oneshot init failed: %s", esp_err_to_name(err));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
adc_oneshot_chan_cfg_t chan_cfg = {
|
||
.atten = atten,
|
||
.bitwidth = adc_width,
|
||
};
|
||
|
||
esp_err_t err = adc_oneshot_config_channel(adc_handle, adc_channel, &chan_cfg);
|
||
if (err != ESP_OK) {
|
||
LOG_ERROR("ADC channel config failed: %s", esp_err_to_name(err));
|
||
return false;
|
||
}
|
||
|
||
adc_calibrated = initAdcCalibration();
|
||
#endif // ARCH_ESP32
|
||
|
||
// NRF52 ADC init moved to powerHAL_init in nrf52 platform
|
||
|
||
#if !defined(ARCH_ESP32) && !defined(ARCH_STM32)
|
||
analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
|
||
#endif
|
||
|
||
batteryLevel = &analogLevel;
|
||
return true;
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
/**
|
||
* Initializes the Power class.
|
||
*
|
||
* @return true if the setup was successful, false otherwise.
|
||
*/
|
||
bool Power::setup()
|
||
{
|
||
#ifdef HAS_SGM41562
|
||
// Initialize the charger early so AnalogBatteryLevel can read charging
|
||
// state from it. The charger does not provide battery voltage / percent -
|
||
// those still come from the platform ADC via analogInit() below.
|
||
initSGM41562(SGM41562_WIRE);
|
||
#endif
|
||
bool found = false;
|
||
if (axpChipInit()) {
|
||
found = true;
|
||
} else if (cw2015Init()) {
|
||
found = true;
|
||
} else if (max17048Init()) {
|
||
found = true;
|
||
} else if (lipoChargerInit()) {
|
||
found = true;
|
||
} else if (serialBatteryInit()) {
|
||
found = true;
|
||
} else if (meshSolarInit()) {
|
||
found = true;
|
||
#ifdef HAS_ADS1115
|
||
} else if (ads1115Init()) {
|
||
found = true;
|
||
#endif
|
||
} else if (analogInit()) {
|
||
found = true;
|
||
} else {
|
||
#ifdef NRF_APM
|
||
found = true;
|
||
#endif
|
||
}
|
||
attachPowerInterrupts();
|
||
enabled = found;
|
||
low_voltage_counter = 0;
|
||
|
||
#ifdef ARCH_ESP32
|
||
// Register callbacks for before and after lightsleep
|
||
// Used to detach and reattach interrupts
|
||
lsObserver.observe(¬ifyLightSleep);
|
||
lsEndObserver.observe(¬ifyLightSleepEnd);
|
||
#endif
|
||
|
||
return found;
|
||
}
|
||
|
||
void Power::powerCommandsCheck()
|
||
{
|
||
// 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 && Throttle::deadlinePassed(shutdownAtMsec)) {
|
||
shutdownAtMsec = 0;
|
||
shutdown();
|
||
}
|
||
|
||
#ifdef ARCH_STM32
|
||
// Deferred DFU entry; the delay is armed by AdminModule's enter_dfu handler (rationale there).
|
||
if (enterDfuAtMsec && Throttle::deadlinePassed(enterDfuAtMsec)) {
|
||
enterDfuAtMsec = 0;
|
||
enterDfuMode(); // never returns
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void Power::reboot()
|
||
{
|
||
notifyReboot.notifyObservers(NULL);
|
||
#if !MESHTASTIC_EXCLUDE_WAYPOINT
|
||
waypointStore.saveToFlash();
|
||
#endif
|
||
#if defined(ARCH_ESP32)
|
||
ESP.restart();
|
||
#elif defined(ARCH_NRF52)
|
||
NVIC_SystemReset();
|
||
#elif defined(ARCH_RP2040)
|
||
rp2040.reboot();
|
||
#elif defined(ARCH_PORTDUINO_WASM)
|
||
// Browser/headless WASM node: no in-process restart. notifyReboot above
|
||
// already let modules persist; hand off to the host (reboot() ->
|
||
// location.reload() in a tab, or Module.onReboot() headless). Deliberately
|
||
// skip the ARCH_PORTDUINO SPI/Wire/Serial teardown below - it would kill the
|
||
// radio with no actual restart to follow, leaving a wedged node. Must come
|
||
// before the ARCH_PORTDUINO arm: the wasm build defines both macros.
|
||
::reboot();
|
||
#elif defined(ARCH_PORTDUINO)
|
||
deInitApiServer();
|
||
#ifdef __linux__
|
||
if (aLinuxInputImpl)
|
||
aLinuxInputImpl->deInit();
|
||
if (aLinuxJoystick)
|
||
aLinuxJoystick->deInit();
|
||
#endif
|
||
SPI.end();
|
||
Wire.end();
|
||
Serial1.end();
|
||
if (screen) {
|
||
screen = nullptr;
|
||
}
|
||
LOG_DEBUG("final reboot");
|
||
::reboot();
|
||
#elif defined(ARCH_STM32)
|
||
HAL_NVIC_SystemReset();
|
||
#else
|
||
// 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
|
||
}
|
||
|
||
void Power::shutdown()
|
||
{
|
||
|
||
#if HAS_SCREEN
|
||
if (screen) {
|
||
#ifdef T_DECK_PRO
|
||
screen->showSimpleBanner("Device is powered off.\nConnect USB to start!",
|
||
0); // T-Deck Pro has no power button
|
||
#elif defined(USE_EINK)
|
||
screen->showSimpleBanner("Shutting Down...",
|
||
2250); // dismiss after 3 seconds to avoid the
|
||
// banner on the sleep screen
|
||
#else
|
||
screen->showSimpleBanner("Shutting Down...", 0); // stays on screen
|
||
#endif
|
||
}
|
||
#endif
|
||
#if !defined(ARCH_STM32WL)
|
||
playShutdownMelody();
|
||
#endif
|
||
nodeDB->saveToDisk();
|
||
#if HAS_SCREEN
|
||
messageStore.saveToFlash();
|
||
#endif
|
||
#if !MESHTASTIC_EXCLUDE_WAYPOINT
|
||
waypointStore.saveToFlash();
|
||
#endif
|
||
#if defined(ARCH_NRF52) || defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_STM32WL)
|
||
#ifdef PIN_LED1
|
||
ledOff(PIN_LED1);
|
||
#endif
|
||
#ifdef PIN_LED2
|
||
ledOff(PIN_LED2);
|
||
#endif
|
||
#ifdef PIN_LED3
|
||
ledOff(PIN_LED3);
|
||
#endif
|
||
#ifdef LED_NOTIFICATION
|
||
ledOff(LED_NOTIFICATION);
|
||
#endif
|
||
doDeepSleep(DELAY_FOREVER, true, true);
|
||
#elif defined(ARCH_PORTDUINO)
|
||
exit(EXIT_SUCCESS);
|
||
#else
|
||
LOG_WARN("FIXME implement shutdown for this platform");
|
||
#endif
|
||
}
|
||
|
||
// Consecutive readings only: a battery-less board's floating divider drifts in and out of the
|
||
// "battery present" window, and a count that survived the gaps would deep-sleep a USB-powered node.
|
||
bool updateLowVoltageCounter(uint8_t &counter, bool hasBattery, bool hasUsb, uint16_t battMv, uint16_t cutoffMv)
|
||
{
|
||
if (!hasBattery || hasUsb || battMv >= cutoffMv) {
|
||
counter = 0;
|
||
return false;
|
||
}
|
||
|
||
if (counter < UINT8_MAX)
|
||
counter++;
|
||
return counter > LOW_VOLTAGE_READINGS_BEFORE_SHUTDOWN;
|
||
}
|
||
|
||
/// Reads power status to powerStatus singleton.
|
||
//
|
||
// TODO(girts): move this and other axp stuff to power.h/power.cpp.
|
||
void Power::readPowerStatus()
|
||
{
|
||
int32_t batteryVoltageMv = -1; // Assume unknown
|
||
int8_t batteryChargePercent = -1;
|
||
OptionalBool usbPowered = OptUnknown;
|
||
OptionalBool hasBattery = OptUnknown; // These must be static because NRF_APM
|
||
// code doesn't run every time
|
||
OptionalBool isChargingNow = OptUnknown;
|
||
|
||
if (batteryLevel) {
|
||
hasBattery = batteryLevel->isBatteryConnect() ? OptTrue : OptFalse;
|
||
#ifndef NRF_APM
|
||
usbPowered = batteryLevel->isVbusIn() ? OptTrue : OptFalse;
|
||
isChargingNow = batteryLevel->isCharging() ? OptTrue : OptFalse;
|
||
#endif
|
||
if (hasBattery) {
|
||
batteryVoltageMv = batteryLevel->getBattVoltage();
|
||
// If the AXP192 returns a valid battery percentage, use it
|
||
if (batteryLevel->getBatteryPercent() >= 0) {
|
||
batteryChargePercent = batteryLevel->getBatteryPercent();
|
||
} else {
|
||
// If the AXP192 returns a percentage less than 0, the feature is either
|
||
// not supported or there is an error In that case, we compute an
|
||
// estimate of the charge percent based on open circuit voltage table
|
||
// defined in power.h
|
||
batteryChargePercent = clamp((int)(((batteryVoltageMv - (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS)) * 1e2) /
|
||
((OCV[0] * NUM_CELLS) - (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS))),
|
||
0, 100);
|
||
}
|
||
}
|
||
}
|
||
|
||
// FIXME: IMO we shouldn't be littering our code with all these ifdefs. Way
|
||
// better instead to make a Nrf52IsUsbPowered subclass (which shares a
|
||
// superclass with the BatteryLevel stuff) that just provides a few methods. But
|
||
// in the interest of fixing this bug I'm going to follow current practice.
|
||
#ifdef NRF_APM // Section of code detects USB power on the RAK4631 and updates
|
||
// the power states. Takes 20 seconds or so to detect changes.
|
||
|
||
nrfx_power_usb_state_t nrf_usb_state = nrfx_power_usbstatus_get();
|
||
// LOG_DEBUG("NRF Power %d", nrf_usb_state);
|
||
|
||
// If changed to DISCONNECTED
|
||
if (nrf_usb_state == NRFX_POWER_USB_STATE_DISCONNECTED)
|
||
isChargingNow = usbPowered = OptFalse;
|
||
// If changed to CONNECTED / READY
|
||
else
|
||
isChargingNow = usbPowered = OptTrue;
|
||
|
||
#endif
|
||
|
||
// Notify any status instances that are observing us
|
||
const PowerStatus powerStatus2 = PowerStatus(hasBattery, usbPowered, isChargingNow, batteryVoltageMv, batteryChargePercent);
|
||
|
||
// Log battery-presence transitions once; skip OptUnknown so we don't lie before the first probe.
|
||
static OptionalBool prevHasBattery = OptUnknown;
|
||
if (hasBattery != OptUnknown && hasBattery != prevHasBattery) {
|
||
LOG_INFO("Power: battery hardware %s", hasBattery == OptTrue ? "detected" : "absent (USB-only)");
|
||
prevHasBattery = hasBattery;
|
||
}
|
||
|
||
// Periodic telemetry only emits when a battery is actually present (otherwise values are constant -1/0).
|
||
if (hasBattery == OptTrue && !Throttle::isWithinTimespanMs(lastLogTime, 50 * 1000)) {
|
||
LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(),
|
||
powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
|
||
lastLogTime = millis();
|
||
}
|
||
newStatus.notifyObservers(&powerStatus2);
|
||
|
||
// Mirror battery level to the BLE Battery Service (0x2A19); the platform layer clamps and dedupes.
|
||
if (hasBattery == OptTrue)
|
||
updateBatteryLevel(powerStatus2.getBatteryChargePercent());
|
||
#ifdef DEBUG_HEAP
|
||
if (lastheap != memGet.getFreeHeap()) {
|
||
// Use stack-allocated buffer to avoid heap allocations in monitoring code
|
||
char threadlist[256] = "Threads running:";
|
||
int threadlistLen = strlen(threadlist);
|
||
int running = 0;
|
||
for (int i = 0; i < MAX_THREADS; i++) {
|
||
auto thread = concurrency::mainController.get(i);
|
||
if ((thread != nullptr) && (thread->enabled)) {
|
||
// Use snprintf to safely append to stack buffer without heap allocation
|
||
int remaining = sizeof(threadlist) - threadlistLen - 1;
|
||
if (remaining > 0) {
|
||
int written = snprintf(threadlist + threadlistLen, remaining, " %s", thread->ThreadName.c_str());
|
||
if (written > 0 && written < remaining) {
|
||
threadlistLen += written;
|
||
}
|
||
}
|
||
running++;
|
||
}
|
||
}
|
||
LOG_HEAP(threadlist);
|
||
LOG_HEAP("Heap status: %d/%d bytes free (%d), running %d/%d threads", memGet.getFreeHeap(), memGet.getHeapSize(),
|
||
memGet.getFreeHeap() - lastheap, running, concurrency::mainController.size(false));
|
||
lastheap = memGet.getFreeHeap();
|
||
}
|
||
#ifdef DEBUG_HEAP_MQTT
|
||
if (mqtt) {
|
||
// send MQTT-Packet with Heap-Size
|
||
uint8_t dmac[6];
|
||
getMacAddr(dmac); // Get our hardware ID
|
||
char mac[18];
|
||
sprintf(mac, "!%02x%02x%02x%02x", dmac[2], dmac[3], dmac[4], dmac[5]);
|
||
|
||
auto newHeap = memGet.getFreeHeap();
|
||
// Use stack-allocated buffers to avoid heap allocations in monitoring code
|
||
char heapTopic[128];
|
||
snprintf(heapTopic, sizeof(heapTopic), "%s/2/heap/%s", (*moduleConfig.mqtt.root ? moduleConfig.mqtt.root : "msh"), mac);
|
||
char heapString[16];
|
||
snprintf(heapString, sizeof(heapString), "%u", newHeap);
|
||
mqtt->pubSub.publish(heapTopic, heapString, false);
|
||
|
||
auto wifiRSSI = WiFi.RSSI();
|
||
char wifiTopic[128];
|
||
snprintf(wifiTopic, sizeof(wifiTopic), "%s/2/wifi/%s", (*moduleConfig.mqtt.root ? moduleConfig.mqtt.root : "msh"), mac);
|
||
char wifiString[16];
|
||
snprintf(wifiString, sizeof(wifiString), "%d", wifiRSSI);
|
||
mqtt->pubSub.publish(wifiTopic, wifiString, false);
|
||
}
|
||
#endif
|
||
|
||
#endif
|
||
|
||
// If we have a battery at all and it is less than 0%, force deep sleep if we
|
||
// have more than 10 low readings in a row. NOTE: min LiIon/LiPo voltage
|
||
// is 2.0 to 2.5V, current OCV min is set to 3100 that is large enough.
|
||
//
|
||
|
||
if (batteryLevel) {
|
||
// getBattVoltage() reports pack voltage; the OCV table is per cell.
|
||
const bool shutdownNow =
|
||
updateLowVoltageCounter(low_voltage_counter, powerStatus2.getHasBattery(), powerStatus2.getHasUSB(),
|
||
batteryLevel->getBattVoltage(), OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
|
||
if (low_voltage_counter)
|
||
LOG_DEBUG("Low voltage counter: %d/%d", low_voltage_counter, LOW_VOLTAGE_READINGS_BEFORE_SHUTDOWN);
|
||
if (shutdownNow) {
|
||
LOG_INFO("Low voltage detected, trigger deep sleep");
|
||
powerFSM.trigger(EVENT_LOW_BATTERY);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Emit a free-heap line to the debug log every HEAP_LOG_INTERVAL_MS, so a slow leak shows up
|
||
* as a trend in a field log instead of only as an out-of-memory reboot. Unlike the DEBUG_HEAP
|
||
* instrumentation above this is always on, and costs one line per interval.
|
||
*/
|
||
void Power::logHeapUsage()
|
||
{
|
||
#if HEAP_LOG_INTERVAL_MS > 0
|
||
if (Throttle::isWithinTimespanMs(lastHeapLogTime, HEAP_LOG_INTERVAL_MS))
|
||
return;
|
||
|
||
const uint32_t heapTotal = memGet.getHeapSize();
|
||
// Platforms without heap accounting report UINT32_MAX (or 0) - nothing worth logging
|
||
if (heapTotal == 0 || heapTotal == UINT32_MAX)
|
||
return;
|
||
|
||
const uint32_t heapFree = memGet.getFreeHeap();
|
||
// The first line has no earlier sample to difference against
|
||
const int32_t delta = lastHeapLogTime ? (int32_t)(heapFree - lastHeapLogFree) : 0;
|
||
|
||
// min only ever falls: one step down is a transient alloc, repeated new lows are a leak.
|
||
// A steady min with a shrinking largest block is fragmentation. Empty where unsupported.
|
||
char detail[64] = "";
|
||
const uint32_t minFree = memGet.getMinFreeHeap();
|
||
const uint32_t maxAlloc = memGet.getMaxAllocHeap();
|
||
if (minFree || maxAlloc)
|
||
snprintf(detail, sizeof(detail), ", min %u, largest block %u", minFree, maxAlloc);
|
||
|
||
const uint32_t psramTotal = memGet.getPsramSize();
|
||
if (psramTotal)
|
||
LOG_INFO("Heap: %u/%u bytes free (%d since last)%s, PSRAM: %u/%u bytes free", heapFree, heapTotal, delta, detail,
|
||
memGet.getFreePsram(), psramTotal);
|
||
else
|
||
LOG_INFO("Heap: %u/%u bytes free (%d since last)%s", heapFree, heapTotal, delta, detail);
|
||
|
||
// Which tagged subsystem moved since boot
|
||
memaudit::logBreakdown("periodic");
|
||
|
||
lastHeapLogFree = heapFree;
|
||
lastHeapLogTime = Time::skipZero(Time::getMillis());
|
||
#endif
|
||
}
|
||
|
||
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
|
||
// sleep), but we do poll the IRQ status by reading the registers over I2C
|
||
if (PMU) {
|
||
|
||
PMU->getIrqStatus();
|
||
|
||
if (PMU->isVbusRemoveIrq()) {
|
||
LOG_INFO("USB unplugged");
|
||
powerFSM.trigger(EVENT_POWER_DISCONNECTED);
|
||
}
|
||
|
||
if (PMU->isVbusInsertIrq()) {
|
||
LOG_INFO("USB plugged In");
|
||
powerFSM.trigger(EVENT_POWER_CONNECTED);
|
||
}
|
||
|
||
#ifdef PMU_POWER_BUTTON_IS_CANCEL
|
||
// cancel action also turns the screen on and off.
|
||
if (PMU->isPekeyShortPressIrq()) {
|
||
LOG_INFO("Input: Corona Button Click");
|
||
if (inputBroker) {
|
||
InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_CANCEL, .kbchar = 0, .touchX = 0, .touchY = 0};
|
||
inputBroker->injectInputEvent(&event);
|
||
}
|
||
}
|
||
#endif
|
||
/*
|
||
Other things we could check if we cared...
|
||
|
||
if (PMU->isBatChagerStartIrq()) {
|
||
LOG_DEBUG("Battery start charging");
|
||
}
|
||
if (PMU->isBatChagerDoneIrq()) {
|
||
LOG_DEBUG("Battery fully charged");
|
||
}
|
||
if (PMU->isBatInsertIrq()) {
|
||
LOG_DEBUG("Battery inserted");
|
||
}
|
||
if (PMU->isBatRemoveIrq()) {
|
||
LOG_DEBUG("Battery removed");
|
||
}
|
||
*/
|
||
|
||
PMU->clearIrqStatus();
|
||
}
|
||
#endif
|
||
// Only read once every 20 seconds once the power status for the app has been
|
||
// initialized
|
||
return (statusHandler && statusHandler->isInitialized()) ? (1000 * 20) : RUN_SAME;
|
||
}
|
||
|
||
#ifdef ARCH_ESP32
|
||
|
||
// Detach our class' interrupts before lightsleep
|
||
// Allows sleep.cpp to configure its own interrupts, which wake the device on user-button press
|
||
int Power::beforeLightSleep(void *unused)
|
||
{
|
||
LOG_WARN("Detaching power interrupts for sleep");
|
||
detachPowerInterrupts();
|
||
return 0; // Indicates success
|
||
}
|
||
|
||
// Reconfigure our interrupts
|
||
// Our class' interrupts were disconnected during sleep, to allow the user button to wake the device from sleep
|
||
int Power::afterLightSleep(esp_sleep_wakeup_cause_t cause)
|
||
{
|
||
attachPowerInterrupts();
|
||
return 0; // Indicates success
|
||
}
|
||
|
||
#endif
|
||
|
||
/*
|
||
* Attach (or re-attach) hardware interrupts for power management
|
||
* Public method. Used outside class when waking from MCU sleep
|
||
*/
|
||
void Power::attachPowerInterrupts()
|
||
{
|
||
#ifdef EXT_PWR_DETECT
|
||
attachInterrupt(
|
||
EXT_PWR_DETECT,
|
||
[]() {
|
||
power->setIntervalFromNow(0);
|
||
runASAP = true;
|
||
},
|
||
CHANGE);
|
||
#endif
|
||
#ifdef BATTERY_CHARGING_INV
|
||
attachInterrupt(
|
||
BATTERY_CHARGING_INV,
|
||
[]() {
|
||
power->setIntervalFromNow(0);
|
||
runASAP = true;
|
||
},
|
||
CHANGE);
|
||
#endif
|
||
#ifdef EXT_CHRG_DETECT
|
||
attachInterrupt(
|
||
EXT_CHRG_DETECT,
|
||
[]() {
|
||
power->setIntervalFromNow(0);
|
||
runASAP = true;
|
||
BaseType_t higherWake = 0;
|
||
},
|
||
CHANGE);
|
||
#endif
|
||
#ifdef PMU_IRQ
|
||
if (PMU) {
|
||
attachInterrupt(
|
||
PMU_IRQ,
|
||
[]() {
|
||
pmu_irq = true;
|
||
power->setIntervalFromNow(0);
|
||
runASAP = true;
|
||
},
|
||
FALLING);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/*
|
||
* Detach the "normal" button interrupts.
|
||
* Public method. Used before attaching a "wake-on-button" interrupt for MCU sleep
|
||
*/
|
||
void Power::detachPowerInterrupts()
|
||
{
|
||
#ifdef EXT_PWR_DETECT
|
||
detachInterrupt(EXT_PWR_DETECT);
|
||
#endif
|
||
#ifdef BATTERY_CHARGING_INV
|
||
detachInterrupt(BATTERY_CHARGING_INV);
|
||
#endif
|
||
#ifdef EXT_CHRG_DETECT
|
||
detachInterrupt(EXT_CHRG_DETECT);
|
||
#endif
|
||
#ifdef PMU_IRQ
|
||
if (PMU) {
|
||
detachInterrupt(PMU_IRQ);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/**
|
||
* Init the power manager chip
|
||
*
|
||
* axp192 power
|
||
DCDC1 0.7-3.5V @ 1200mA max -> OLED // If you turn this off you'll lose
|
||
comms to the axp192 because the OLED and the axp192 share the same i2c bus,
|
||
instead use ssd1306 sleep mode DCDC2 -> unused DCDC3 0.7-3.5V @ 700mA max ->
|
||
ESP32 (keep this on!) LDO1 30mA -> charges GPS backup battery // charges the
|
||
tiny J13 battery by the GPS to power the GPS ram (for a couple of days), can
|
||
not be turned off LDO2 200mA -> LORA LDO3 200mA -> GPS
|
||
*
|
||
*/
|
||
bool Power::axpChipInit()
|
||
{
|
||
|
||
#ifdef HAS_PMU
|
||
|
||
TwoWire *w = NULL;
|
||
|
||
// Use macro to distinguish which wire is used by PMU
|
||
#ifdef PMU_USE_WIRE1
|
||
w = &Wire1;
|
||
#else
|
||
w = &Wire;
|
||
#endif
|
||
|
||
/**
|
||
* It is not necessary to specify the wire pin,
|
||
* just input the wire, because the wire has been initialized in main.cpp
|
||
*/
|
||
if (!PMU) {
|
||
PMU = new XPowersAXP2101(*w);
|
||
if (!PMU->init()) {
|
||
LOG_WARN("No AXP2101 power management");
|
||
delete PMU;
|
||
PMU = NULL;
|
||
} else {
|
||
LOG_INFO("AXP2101 PMU init succeeded");
|
||
}
|
||
}
|
||
|
||
if (!PMU) {
|
||
PMU = new XPowersAXP192(*w);
|
||
if (!PMU->init()) {
|
||
LOG_WARN("No AXP192 power management");
|
||
delete PMU;
|
||
PMU = NULL;
|
||
} else {
|
||
LOG_INFO("AXP192 PMU init succeeded");
|
||
}
|
||
}
|
||
|
||
if (!PMU) {
|
||
/*
|
||
* In XPowersLib, if the XPowersAXPxxx object is released, Wire.end() will
|
||
* be called at the same time. In order not to affect other devices, if the
|
||
* initialization of the PMU fails, Wire needs to be re-initialized once, if
|
||
* there are multiple devices sharing the bus.
|
||
* * */
|
||
#ifndef PMU_USE_WIRE1
|
||
w->begin(I2C_SDA, I2C_SCL);
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
batteryLevel = PMU;
|
||
|
||
if (PMU->getChipModel() == XPOWERS_AXP192) {
|
||
|
||
// lora radio power channel
|
||
PMU->setPowerChannelVoltage(XPOWERS_LDO2, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_LDO2);
|
||
|
||
// oled module power channel,
|
||
// disable it will cause abnormal communication between boot and AXP power
|
||
// supply, do not turn it off
|
||
PMU->setPowerChannelVoltage(XPOWERS_DCDC1, 3300);
|
||
// enable oled power
|
||
PMU->enablePowerOutput(XPOWERS_DCDC1);
|
||
|
||
// gnss module power channel - now turned on in setGpsPower
|
||
PMU->setPowerChannelVoltage(XPOWERS_LDO3, 3300);
|
||
// PMU->enablePowerOutput(XPOWERS_LDO3);
|
||
|
||
// protected oled power source
|
||
PMU->setProtectedChannel(XPOWERS_DCDC1);
|
||
// protected esp32 power source
|
||
PMU->setProtectedChannel(XPOWERS_DCDC3);
|
||
|
||
// disable not use channel
|
||
PMU->disablePowerOutput(XPOWERS_DCDC2);
|
||
|
||
// disable all axp chip interrupt
|
||
PMU->disableIRQ(XPOWERS_AXP192_ALL_IRQ);
|
||
|
||
// Set constant current charging current
|
||
PMU->setChargerConstantCurr(XPOWERS_AXP192_CHG_CUR_450MA);
|
||
|
||
// Set up the charging voltage
|
||
PMU->setChargeTargetVoltage(XPOWERS_AXP192_CHG_VOL_4V2);
|
||
} else if (PMU->getChipModel() == XPOWERS_AXP2101) {
|
||
|
||
/*The alternative version of T-Beam 1.1 differs from T-Beam V1.1 in that it
|
||
* uses an AXP2101 power chip*/
|
||
if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
|
||
// Unuse power channel
|
||
PMU->disablePowerOutput(XPOWERS_DCDC2);
|
||
PMU->disablePowerOutput(XPOWERS_DCDC3);
|
||
PMU->disablePowerOutput(XPOWERS_DCDC4);
|
||
PMU->disablePowerOutput(XPOWERS_DCDC5);
|
||
PMU->disablePowerOutput(XPOWERS_ALDO1);
|
||
PMU->disablePowerOutput(XPOWERS_ALDO4);
|
||
PMU->disablePowerOutput(XPOWERS_BLDO1);
|
||
PMU->disablePowerOutput(XPOWERS_BLDO2);
|
||
PMU->disablePowerOutput(XPOWERS_DLDO1);
|
||
PMU->disablePowerOutput(XPOWERS_DLDO2);
|
||
|
||
// GNSS RTC PowerVDD 3300mV
|
||
PMU->setPowerChannelVoltage(XPOWERS_VBACKUP, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_VBACKUP);
|
||
|
||
// ESP32 VDD 3300mV
|
||
// ! No need to set, automatically open , Don't close it
|
||
// PMU->setPowerChannelVoltage(XPOWERS_DCDC1, 3300);
|
||
// PMU->setProtectedChannel(XPOWERS_DCDC1);
|
||
|
||
// LoRa VDD 3300mV
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO2);
|
||
|
||
// GNSS VDD 3300mV
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO3);
|
||
} else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE ||
|
||
HW_VENDOR == meshtastic_HardwareModel_T_WATCH_S3) {
|
||
// t-beam s3 core
|
||
/**
|
||
* gnss module power channel
|
||
* The default ALDO4 is off, you need to turn on the GNSS power first,
|
||
* otherwise it will be invalid during initialization
|
||
*/
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO4);
|
||
|
||
// lora radio power channel
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO3);
|
||
|
||
// m.2 interface
|
||
PMU->setPowerChannelVoltage(XPOWERS_DCDC3, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_DCDC3);
|
||
|
||
/**
|
||
* ALDO2 cannot be turned off.
|
||
* It is a necessary condition for sensor communication.
|
||
* It must be turned on to properly access the sensor and screen
|
||
* It is also responsible for the power supply of PCF8563
|
||
*/
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO2);
|
||
|
||
// 6-axis , magnetometer ,bme280 , oled screen power channel
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO1, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO1);
|
||
|
||
// sdcard (T-Beam S3) / gnns (T-Watch S3 Plus) power channel
|
||
PMU->setPowerChannelVoltage(XPOWERS_BLDO1, 3300);
|
||
#ifndef T_WATCH_S3
|
||
PMU->enablePowerOutput(XPOWERS_BLDO1);
|
||
#else
|
||
// DRV2605 power channel
|
||
PMU->setPowerChannelVoltage(XPOWERS_BLDO2, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_BLDO2);
|
||
#endif
|
||
|
||
// PMU->setPowerChannelVoltage(XPOWERS_DCDC4, 3300);
|
||
// PMU->enablePowerOutput(XPOWERS_DCDC4);
|
||
|
||
// not use channel
|
||
PMU->disablePowerOutput(XPOWERS_DCDC2); // not elicited
|
||
PMU->disablePowerOutput(XPOWERS_DCDC5); // not elicited
|
||
PMU->disablePowerOutput(XPOWERS_DLDO1); // Invalid power channel, it does not exist
|
||
PMU->disablePowerOutput(XPOWERS_DLDO2); // Invalid power channel, it does not exist
|
||
PMU->disablePowerOutput(XPOWERS_VBACKUP);
|
||
} else if (HW_VENDOR == meshtastic_HardwareModel_T_WATCH_ULTRA) {
|
||
PMU->clearIrqStatus();
|
||
|
||
// Turn off the PMU charging indicator light, no physical connection
|
||
PMU->setChargingLedMode(XPOWERS_CHG_LED_OFF); // NO LED
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO1, 3300); // SD Card
|
||
PMU->enablePowerOutput(XPOWERS_ALDO1);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300); // Display
|
||
PMU->enablePowerOutput(XPOWERS_ALDO2);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300); // LoRa
|
||
PMU->enablePowerOutput(XPOWERS_ALDO3);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 1800); // Sensor
|
||
PMU->enablePowerOutput(XPOWERS_ALDO4);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_BLDO1, 3300); // GPS
|
||
PMU->enablePowerOutput(XPOWERS_BLDO1);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_BLDO2, 3300); // Speaker
|
||
PMU->enablePowerOutput(XPOWERS_BLDO2);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_VBACKUP, 3300); // RTC Button battery
|
||
PMU->enablePowerOutput(XPOWERS_VBACKUP);
|
||
|
||
// PMU->enablePowerOutput(XPOWERS_DLDO1); // NFC
|
||
|
||
// UNUSED POWER CHANNEL
|
||
PMU->disablePowerOutput(XPOWERS_DCDC2);
|
||
PMU->disablePowerOutput(XPOWERS_DCDC3);
|
||
PMU->disablePowerOutput(XPOWERS_DCDC4);
|
||
PMU->disablePowerOutput(XPOWERS_DCDC5);
|
||
PMU->disablePowerOutput(XPOWERS_CPULDO);
|
||
|
||
// Enable Measure
|
||
PMU->enableBattDetection();
|
||
PMU->enableVbusVoltageMeasure();
|
||
PMU->enableBattVoltageMeasure();
|
||
PMU->enableSystemVoltageMeasure();
|
||
PMU->enableTemperatureMeasure();
|
||
} else if (HW_VENDOR == meshtastic_HardwareModel_TBEAM_BPF) {
|
||
// T-Beam BPF rail map (per schematic LilyGo_TBeam_BPF r2025-05-08):
|
||
// DCDC1 -> ESP32 + OLED 3V3 (always on, protected)
|
||
// ALDO2 -> MicroSD 3V3 (OFF at reset, must enable)
|
||
// ALDO4 -> L76K GNSS 3V3 (OFF at reset, must enable)
|
||
// ALDO1/3, BLDO1/2, DLDO1 -> user headers / unused at boot, leave at reset defaults.
|
||
// LoRa power is outside the PMU (external P-MOSFET switched by RF95_POWER_EN / IO16).
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO4);
|
||
|
||
PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300);
|
||
PMU->enablePowerOutput(XPOWERS_ALDO2);
|
||
|
||
// Make sure nothing's driving into an unused rail
|
||
PMU->disablePowerOutput(XPOWERS_DCDC5);
|
||
PMU->disablePowerOutput(XPOWERS_DLDO1);
|
||
}
|
||
|
||
// disable all axp chip interrupt
|
||
PMU->disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
|
||
|
||
// Set the constant current charging current of AXP2101, temporarily use
|
||
// 500mA by default
|
||
PMU->setChargerConstantCurr(XPOWERS_AXP2101_CHG_CUR_500MA);
|
||
|
||
// Set up the charging voltage
|
||
PMU->setChargeTargetVoltage(XPOWERS_AXP2101_CHG_VOL_4V2);
|
||
}
|
||
|
||
PMU->clearIrqStatus();
|
||
|
||
// TBeam1.1 /T-Beam S3-Core has no external TS detection,
|
||
// it needs to be disabled, otherwise it will cause abnormal charging
|
||
PMU->disableTSPinMeasure();
|
||
|
||
// PMU->enableSystemVoltageMeasure();
|
||
PMU->enableVbusVoltageMeasure();
|
||
PMU->enableBattVoltageMeasure();
|
||
|
||
if (PMU->isChannelAvailable(XPOWERS_DCDC1)) {
|
||
LOG_DEBUG("DC1 : %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_DCDC1) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_DCDC1));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_DCDC2)) {
|
||
LOG_DEBUG("DC2 : %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_DCDC2) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_DCDC2));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_DCDC3)) {
|
||
LOG_DEBUG("DC3 : %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_DCDC3) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_DCDC3));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_DCDC4)) {
|
||
LOG_DEBUG("DC4 : %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_DCDC4) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_DCDC4));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_LDO2)) {
|
||
LOG_DEBUG("LDO2 : %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_LDO2) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_LDO2));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_LDO3)) {
|
||
LOG_DEBUG("LDO3 : %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_LDO3) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_LDO3));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_ALDO1)) {
|
||
LOG_DEBUG("ALDO1: %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_ALDO1) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_ALDO1));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_ALDO2)) {
|
||
LOG_DEBUG("ALDO2: %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_ALDO2) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_ALDO2));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_ALDO3)) {
|
||
LOG_DEBUG("ALDO3: %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_ALDO3) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_ALDO3));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_ALDO4)) {
|
||
LOG_DEBUG("ALDO4: %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_ALDO4) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_ALDO4));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_BLDO1)) {
|
||
LOG_DEBUG("BLDO1: %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_BLDO1) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_BLDO1));
|
||
}
|
||
if (PMU->isChannelAvailable(XPOWERS_BLDO2)) {
|
||
LOG_DEBUG("BLDO2: %s Voltage:%u mV ", PMU->isPowerChannelEnable(XPOWERS_BLDO2) ? "+" : "-",
|
||
PMU->getPowerChannelVoltage(XPOWERS_BLDO2));
|
||
}
|
||
|
||
// We can safely ignore this approach for most (or all) boards because MCU
|
||
// turned off earlier than battery discharged to 2.6V.
|
||
//
|
||
// Unfortunately for now we can't use this killswitch for RAK4630-based boards
|
||
// because they have a bug with battery voltage measurement. Probably it
|
||
// sometimes drops to low values.
|
||
#ifndef RAK4630
|
||
// Set PMU shutdown voltage at 2.6V to maximize battery utilization
|
||
PMU->setSysPowerDownVoltage(2600);
|
||
#endif
|
||
|
||
#ifdef PMU_IRQ
|
||
uint64_t pmuIrqMask = 0;
|
||
|
||
if (PMU->getChipModel() == XPOWERS_AXP192) {
|
||
pmuIrqMask = XPOWERS_AXP192_VBUS_INSERT_IRQ | XPOWERS_AXP192_VBUS_REMOVE_IRQ | XPOWERS_AXP192_PKEY_SHORT_IRQ;
|
||
} else if (PMU->getChipModel() == XPOWERS_AXP2101) {
|
||
pmuIrqMask = XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_VBUS_REMOVE_IRQ | XPOWERS_AXP2101_PKEY_SHORT_IRQ;
|
||
}
|
||
|
||
pinMode(PMU_IRQ, INPUT);
|
||
|
||
// We wake on IRQ, so only enable the IRQs that we care about.
|
||
// we want USB plug and unplug to update the screen and LED status,
|
||
// and short press on the power button to trigger the "cancel" action in the UI (which also turns the screen on and off).
|
||
PMU->enableIRQ(pmuIrqMask);
|
||
|
||
PMU->clearIrqStatus();
|
||
#endif /*PMU_IRQ*/
|
||
|
||
readPowerStatus();
|
||
|
||
pmu_found = true;
|
||
|
||
return pmu_found;
|
||
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
#if !MESHTASTIC_EXCLUDE_I2C && __has_include(<Adafruit_MAX1704X.h>)
|
||
|
||
/**
|
||
* Wrapper class for an I2C MAX17048 Lipo battery sensor.
|
||
*/
|
||
class MAX17048BatteryLevel : public HasBatteryLevel
|
||
{
|
||
private:
|
||
MAX17048Singleton *max17048 = nullptr;
|
||
|
||
public:
|
||
/**
|
||
* Init the I2C MAX17048 Lipo battery level sensor
|
||
*/
|
||
bool runOnce()
|
||
{
|
||
if (max17048 == nullptr) {
|
||
max17048 = MAX17048Singleton::GetInstance();
|
||
}
|
||
|
||
// try to start if the sensor has been detected
|
||
if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX17048].first != 0) {
|
||
return max17048->runOnce(nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX17048].second);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() override { return max17048->getBusBatteryPercent(); }
|
||
|
||
/**
|
||
* The raw voltage of the battery in millivolts, or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() override { return max17048->getBusVoltageMv(); }
|
||
|
||
/**
|
||
* return true if there is a battery installed in this unit
|
||
*/
|
||
virtual bool isBatteryConnect() override { return max17048->isBatteryConnected(); }
|
||
|
||
/**
|
||
* return true if there is an external power source detected
|
||
*/
|
||
virtual bool isVbusIn() override { return max17048->isExternallyPowered(); }
|
||
|
||
/**
|
||
* return true if the battery is currently charging
|
||
*/
|
||
virtual bool isCharging() override { return max17048->isBatteryCharging(); }
|
||
};
|
||
|
||
MAX17048BatteryLevel max17048Level;
|
||
|
||
/**
|
||
* Init the Lipo battery level sensor
|
||
*/
|
||
bool Power::max17048Init()
|
||
{
|
||
bool result = max17048Level.runOnce();
|
||
LOG_DEBUG("Power::max17048Init lipo sensor is %s", result ? "ready" : "not ready yet");
|
||
if (!result)
|
||
return false;
|
||
batteryLevel = &max17048Level;
|
||
return true;
|
||
}
|
||
|
||
#else
|
||
/**
|
||
* The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel
|
||
*/
|
||
bool Power::max17048Init()
|
||
{
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
#if !MESHTASTIC_EXCLUDE_I2C && HAS_CW2015
|
||
|
||
class CW2015BatteryLevel : public AnalogBatteryLevel
|
||
{
|
||
public:
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() override
|
||
{
|
||
int data = -1;
|
||
Wire.beginTransmission(CW2015_ADDR);
|
||
Wire.write(0x04);
|
||
if (Wire.endTransmission() == 0) {
|
||
if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
|
||
data = Wire.read();
|
||
}
|
||
}
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* The raw voltage of the battery in millivolts, or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() override
|
||
{
|
||
uint16_t mv = 0;
|
||
Wire.beginTransmission(CW2015_ADDR);
|
||
Wire.write(0x02);
|
||
if (Wire.endTransmission() == 0) {
|
||
if (Wire.requestFrom(CW2015_ADDR, (uint8_t)2)) {
|
||
mv = Wire.read();
|
||
mv <<= 8;
|
||
mv |= Wire.read();
|
||
// Voltage is read in 305uV units, convert to mV
|
||
mv = mv * 305 / 1000;
|
||
}
|
||
}
|
||
return mv;
|
||
}
|
||
};
|
||
|
||
CW2015BatteryLevel cw2015Level;
|
||
|
||
/**
|
||
* Init the CW2015 battery level sensor
|
||
*/
|
||
bool Power::cw2015Init()
|
||
{
|
||
|
||
Wire.beginTransmission(CW2015_ADDR);
|
||
uint8_t getInfo[] = {0x0a, 0x00};
|
||
Wire.write(getInfo, 2);
|
||
Wire.endTransmission();
|
||
delay(10);
|
||
Wire.beginTransmission(CW2015_ADDR);
|
||
Wire.write(0x00);
|
||
bool result = false;
|
||
if (Wire.endTransmission() == 0) {
|
||
if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
|
||
uint8_t data = Wire.read();
|
||
LOG_DEBUG("CW2015 init read data: 0x%x", data);
|
||
if (data == 0x73) {
|
||
result = true;
|
||
batteryLevel = &cw2015Level;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
#else
|
||
/**
|
||
* The CW2015 battery level sensor is unavailable - default to AnalogBatteryLevel
|
||
*/
|
||
bool Power::cw2015Init()
|
||
{
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
#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:
|
||
/**
|
||
* Init the I2C BQ25896 Lipo battery charger
|
||
*/
|
||
bool runOnce()
|
||
{
|
||
if (PPM == nullptr) {
|
||
PPM = new XPowersPPM;
|
||
bool result = PPM->init(Wire, I2C_SDA, I2C_SCL, BQ25896_ADDR);
|
||
if (result) {
|
||
LOG_INFO("PPM BQ25896 init succeeded");
|
||
// Set the minimum operating voltage. Below this voltage, the PPM will
|
||
// protect PPM->setSysPowerDownVoltage(3100);
|
||
|
||
// Set input current limit, default is 500mA
|
||
// PPM->setInputCurrentLimit(800);
|
||
|
||
// Disable current limit pin
|
||
// PPM->disableCurrentLimitPin();
|
||
|
||
// Set the charging target voltage, Range:3840 ~ 4608mV ,step:16 mV
|
||
PPM->setChargeTargetVoltage(4288);
|
||
|
||
// Set the precharge current , Range: 64mA ~ 1024mA ,step:64mA
|
||
// PPM->setPrechargeCurr(64);
|
||
|
||
// The premise is that limit pin is disabled, or it will
|
||
// only follow the maximum charging current set by limit pin.
|
||
// Set the charging current , Range:0~5056mA ,step:64mA
|
||
PPM->setChargerConstantCurr(1024);
|
||
|
||
// To obtain voltage data, the ADC must be enabled first
|
||
PPM->enableMeasure();
|
||
|
||
// Turn on charging function
|
||
// If there is no battery connected, do not turn on the charging
|
||
// function
|
||
PPM->enableCharge();
|
||
} else {
|
||
LOG_WARN("PPM BQ25896 init failed");
|
||
delete PPM;
|
||
PPM = nullptr;
|
||
return false;
|
||
}
|
||
}
|
||
gaugeRunOnce();
|
||
// Ready on the charger alone, so Power stays enabled and can retry the gauge later.
|
||
return true;
|
||
}
|
||
|
||
/// 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;
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() override
|
||
{
|
||
return -1;
|
||
// return bq->getChargePercent(); // don't use BQ27220 for battery percent,
|
||
// it is not calibrated
|
||
}
|
||
|
||
/**
|
||
* The raw voltage of the battery in millivolts, or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() override { return bq ? bq->getVoltage() : PPM->getBattVoltage(); }
|
||
|
||
/**
|
||
* return true if there is a battery installed in this unit
|
||
*/
|
||
virtual bool isBatteryConnect() override { return PPM->getBattVoltage() > 0; }
|
||
|
||
/**
|
||
* return true if there is an external power source detected
|
||
*/
|
||
virtual bool isVbusIn() override { return PPM->isVbusIn(); }
|
||
|
||
/**
|
||
* return true if the battery is currently charging
|
||
*/
|
||
virtual bool isCharging() override
|
||
{
|
||
bool isCharging = PPM->isCharging();
|
||
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;
|
||
}
|
||
};
|
||
|
||
LipoCharger lipoCharger;
|
||
|
||
/**
|
||
* Init the Lipo battery charger
|
||
*/
|
||
bool Power::lipoChargerInit()
|
||
{
|
||
bool result = lipoCharger.runOnce();
|
||
LOG_DEBUG("Power::lipoChargerInit lipo sensor is %s", result ? "ready" : "not ready yet");
|
||
if (!result)
|
||
return false;
|
||
batteryLevel = &lipoCharger;
|
||
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
|
||
*/
|
||
bool Power::lipoChargerInit()
|
||
{
|
||
return false;
|
||
}
|
||
|
||
void Power::lipoChargerRetry() {}
|
||
#endif
|
||
|
||
#ifdef HELTEC_MESH_SOLAR
|
||
#include "meshSolarApp.h"
|
||
|
||
/**
|
||
* meshSolar class for an SMBUS battery sensor.
|
||
*/
|
||
class meshSolarBatteryLevel : public HasBatteryLevel
|
||
{
|
||
|
||
public:
|
||
/**
|
||
* Init the I2C meshSolar battery level sensor
|
||
*/
|
||
bool runOnce()
|
||
{
|
||
meshSolarStart();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() override { return meshSolarGetBatteryPercent(); }
|
||
|
||
/**
|
||
* The raw voltage of the battery in millivolts, or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() override { return meshSolarGetBattVoltage(); }
|
||
|
||
/**
|
||
* return true if there is a battery installed in this unit
|
||
*/
|
||
virtual bool isBatteryConnect() override { return meshSolarIsBatteryConnect(); }
|
||
|
||
/**
|
||
* return true if there is an external power source detected
|
||
*/
|
||
virtual bool isVbusIn() override { return meshSolarIsVbusIn(); }
|
||
|
||
/**
|
||
* return true if the battery is currently charging
|
||
*/
|
||
virtual bool isCharging() override { return meshSolarIsCharging(); }
|
||
};
|
||
|
||
meshSolarBatteryLevel meshSolarLevel;
|
||
|
||
/**
|
||
* Init the meshSolar battery level sensor
|
||
*/
|
||
bool Power::meshSolarInit()
|
||
{
|
||
bool result = meshSolarLevel.runOnce();
|
||
LOG_DEBUG("Power::meshSolarInit sensor is %s", result ? "ready" : "not ready yet");
|
||
if (!result)
|
||
return false;
|
||
batteryLevel = &meshSolarLevel;
|
||
return true;
|
||
}
|
||
|
||
#else
|
||
/**
|
||
* The meshSolar battery level sensor is unavailable - default to
|
||
* AnalogBatteryLevel
|
||
*/
|
||
bool Power::meshSolarInit()
|
||
{
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
#ifdef HAS_SERIAL_BATTERY_LEVEL
|
||
#include <SoftwareSerial.h>
|
||
|
||
/**
|
||
* SerialBatteryLevel class for pulling battery information from a secondary MCU over serial.
|
||
*/
|
||
class SerialBatteryLevel : public HasBatteryLevel
|
||
{
|
||
|
||
public:
|
||
/**
|
||
* Init the I2C meshSolar battery level sensor
|
||
*/
|
||
bool runOnce()
|
||
{
|
||
BatterySerial.begin(4800);
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Battery state of charge, from 0 to 100 or -1 for unknown
|
||
*/
|
||
virtual int getBatteryPercent() override { return v_percent; }
|
||
|
||
/**
|
||
* The raw voltage of the battery in millivolts, or NAN if unknown
|
||
*/
|
||
virtual uint16_t getBattVoltage() override { return voltage * 1000; }
|
||
|
||
/**
|
||
* return true if there is a battery installed in this unit
|
||
*/
|
||
virtual bool isBatteryConnect() override
|
||
{
|
||
// definitely need to gobble up more bytes at once
|
||
if (BatterySerial.available() > 5) {
|
||
// LOG_WARN("SerialBatteryLevel: %u bytes available", BatterySerial.available());
|
||
while (BatterySerial.available() > 11) {
|
||
BatterySerial.read(); // flush old data
|
||
}
|
||
// LOG_WARN("SerialBatteryLevel: %u bytes now available", BatterySerial.available());
|
||
int tries = 0;
|
||
while (BatterySerial.read() != 0xFE) {
|
||
tries++; // wait for start byte
|
||
if (tries > 10) {
|
||
LOG_WARN("SerialBatteryLevel: no start byte found");
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
Data[1] = BatterySerial.read();
|
||
Data[2] = BatterySerial.read();
|
||
Data[3] = BatterySerial.read();
|
||
Data[4] = BatterySerial.read();
|
||
Data[5] = BatterySerial.read();
|
||
if (Data[5] != 0xFD) {
|
||
LOG_WARN("SerialBatteryLevel: invalid end byte %02x", Data[5]);
|
||
return true;
|
||
}
|
||
v_percent = Data[1];
|
||
voltage = Data[2] + (((float)Data[3]) / 100) + (((float)Data[4]) / 10000);
|
||
voltage *= 2;
|
||
// LOG_WARN("SerialBatteryLevel: received data %u, %f, %02x", v_percent, voltage, Data[5]);
|
||
return true;
|
||
}
|
||
// This function runs first, so use it to grab the latest data from the secondary MCU
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* return true if there is an external power source detected
|
||
*/
|
||
virtual bool isVbusIn() override
|
||
{
|
||
#if defined(EXT_CHRG_DETECT)
|
||
|
||
return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
|
||
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
virtual bool isCharging() override
|
||
{
|
||
#ifdef EXT_CHRG_DETECT
|
||
return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
|
||
|
||
#endif
|
||
// by default, we check the battery voltage only
|
||
return isVbusIn();
|
||
}
|
||
|
||
private:
|
||
SoftwareSerial BatterySerial = SoftwareSerial(SERIAL_BATTERY_RX, SERIAL_BATTERY_TX);
|
||
uint8_t Data[6] = {0};
|
||
int v_percent = 0;
|
||
float voltage = 0.0;
|
||
};
|
||
|
||
SerialBatteryLevel serialBatteryLevel;
|
||
|
||
/**
|
||
* Init the serial battery level sensor
|
||
*/
|
||
bool Power::serialBatteryInit()
|
||
{
|
||
#ifdef EXT_PWR_DETECT
|
||
pinMode(EXT_PWR_DETECT, EXT_PWR_DETECT_MODE);
|
||
#endif
|
||
#ifdef EXT_CHRG_DETECT
|
||
pinMode(EXT_CHRG_DETECT, EXT_CHRG_DETECT_MODE);
|
||
#endif
|
||
|
||
bool result = serialBatteryLevel.runOnce();
|
||
LOG_DEBUG("Power::serialBatteryInit sensor is %s", result ? "ready" : "not ready yet");
|
||
if (!result)
|
||
return false;
|
||
batteryLevel = &serialBatteryLevel;
|
||
return true;
|
||
}
|
||
|
||
#else
|
||
/**
|
||
* If this device has no serial battery level sensor, don't try to use it.
|
||
*/
|
||
bool Power::serialBatteryInit()
|
||
{
|
||
return false;
|
||
}
|
||
#endif
|