dandri/HaloKeymind
1
0
Fork 0
mirror of https://github.com/mikecarper/MeshCore.git synced 2026-09-16 05:22:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
e76da0fefa6d65f9724300aaf5f94cae44a4ea5a
HaloKeymind/test/test_rx_power_saving/test_rx_power_saving.cpp
T

801 lines
34 KiB
C++
Raw Blame History

#include <gtest/gtest.h>
#include <cstring>
#include "helpers/radiolib/RXPowerSaving.h"
#include "helpers/radiolib/RXPowerSavingCLI.h"
class FakeRxPowerSavingControl : public RxPowerSavingControl {
public:
bool accept = true;
bool set_called = false;
bool requested_enabled = false;
uint32_t requested_rx_us = 0;
uint32_t requested_sleep_us = 0;
RxPowerSavingStatus status;
bool setRxPowerSaving(bool enabled, uint32_t rx_us, uint32_t sleep_us) override {
set_called = true;
requested_enabled = enabled;
requested_rx_us = rx_us;
requested_sleep_us = sleep_us;
return accept;
}
RxPowerSavingStatus getRxPowerSavingStatus() const override { return status; }
};
TEST(RxPowerSaving, DefaultsKeepRepeaterDisabledWithBalancedIntent) {
const RxPowerSavingConfig config;
EXPECT_EQ(config.enabled, 0);
EXPECT_EQ(config.level, RX_POWERSAVING_BALANCED_LEVEL);
EXPECT_EQ(config.preamble, RX_POWERSAVING_PROFILE_PREAMBLE);
EXPECT_EQ(config.rx_us, RX_POWERSAVING_DEFAULT_RX_US);
EXPECT_EQ(config.sleep_us, RX_POWERSAVING_DEFAULT_SLEEP_US);
}
TEST(RxPowerSaving, BaseControlRejectsEnableAndAcceptsContinuousRx) {
RxPowerSavingControl control;
EXPECT_FALSE(control.setRxPowerSaving(true, 12345, 23456));
EXPECT_TRUE(control.setRxPowerSaving(false, 12345, 23456));
const RxPowerSavingStatus status = control.getRxPowerSavingStatus();
EXPECT_FALSE(status.supported);
EXPECT_FALSE(status.armed);
EXPECT_EQ(status.arm_failures, 0U);
EXPECT_EQ(status.effective_rx_us, 0U);
EXPECT_EQ(status.effective_sleep_us, 0U);
}
TEST(RxPowerSaving, ArmRetryStopsAfterThreeFailuresAndSuccessResetsIt) {
RxPowerSavingArmRetryState retry;
EXPECT_TRUE(retry.canAttempt());
for (uint8_t expected = 1; expected <= RX_POWERSAVING_MAX_CONSEC_ARM_FAILURES; expected++) {
retry.recordFailure();
EXPECT_EQ(retry.consecutiveFailures(), expected);
}
EXPECT_FALSE(retry.canAttempt());
// Saturate instead of wrapping if a caller records another failure.
retry.recordFailure();
EXPECT_EQ(retry.consecutiveFailures(), RX_POWERSAVING_MAX_CONSEC_ARM_FAILURES);
retry.recordSuccess();
EXPECT_EQ(retry.consecutiveFailures(), 0);
EXPECT_TRUE(retry.canAttempt());
}
TEST(RxPowerSaving, ClearingRetryStateGrantsThreeFreshAttempts) {
RxPowerSavingArmRetryState retry;
for (uint8_t i = 0; i < RX_POWERSAVING_MAX_CONSEC_ARM_FAILURES; i++) {
retry.recordFailure();
}
ASSERT_FALSE(retry.canAttempt());
retry.reset();
EXPECT_TRUE(retry.canAttempt());
EXPECT_EQ(retry.consecutiveFailures(), 0);
}
TEST(RxPowerSaving, RejectsInvalidProfileInputs) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
EXPECT_FALSE(calcRxPowerSavingLevel(0, 10, 250.0f, 16, &rx_us, &sleep_us));
// 8 is the top of the guarded scale, 9 overdrive, 10 the practical maximum.
EXPECT_TRUE(calcRxPowerSavingLevel(8, 10, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_TRUE(calcRxPowerSavingLevel(9, 10, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_TRUE(calcRxPowerSavingLevel(10, 10, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_FALSE(calcRxPowerSavingLevel(11, 10, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_FALSE(calcRxPowerSavingLevel(5, 4, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_FALSE(calcRxPowerSavingLevel(5, 10, 0.0f, 16, &rx_us, &sleep_us));
EXPECT_FALSE(calcRxPowerSavingLevel(5, 10, 250.0f, 24, &rx_us, &sleep_us));
}
TEST(RxPowerSaving, AcceptsPeriodBoundariesOnly) {
EXPECT_FALSE(isValidRxPowerSavingPeriod(RX_POWERSAVING_MIN_PERIOD_US - 1));
EXPECT_TRUE(isValidRxPowerSavingPeriod(RX_POWERSAVING_MIN_PERIOD_US));
EXPECT_TRUE(isValidRxPowerSavingPeriod(RX_POWERSAVING_MAX_PERIOD_US));
EXPECT_FALSE(isValidRxPowerSavingPeriod(RX_POWERSAVING_MAX_PERIOD_US + 1));
}
TEST(RxPowerSaving, RepairsInvalidPersistedPeriodsIndependently) {
uint32_t rx_us = 0;
uint32_t sleep_us = 12345;
ensureRxPowerSavingDefaults(&rx_us, &sleep_us);
EXPECT_EQ(rx_us, RX_POWERSAVING_DEFAULT_RX_US);
EXPECT_EQ(sleep_us, 12345U);
rx_us = 23456;
sleep_us = RX_POWERSAVING_MAX_PERIOD_US + 1;
ensureRxPowerSavingDefaults(&rx_us, &sleep_us);
EXPECT_EQ(rx_us, 23456U);
EXPECT_EQ(sleep_us, RX_POWERSAVING_DEFAULT_SLEEP_US);
}
TEST(RxPowerSaving, NormalizesPersistedConfigBeforeApplying) {
RxPowerSavingConfig config;
config.enabled = 7;
config.level = 255;
config.preamble = 24;
config.rx_us = 0;
config.sleep_us = 0;
normalizeRxPowerSavingConfig(&config, 10, 250.0f);
EXPECT_EQ(config.enabled, 1);
EXPECT_EQ(config.level, RX_POWERSAVING_BALANCED_LEVEL);
EXPECT_EQ(config.preamble, RX_POWERSAVING_PROFILE_PREAMBLE);
EXPECT_EQ(config.rx_us, 49329U);
EXPECT_EQ(config.sleep_us, 23757U);
}
TEST(RxPowerSaving, NumericInputIsStrictDecimal) {
EXPECT_TRUE(isRxPowerSavingNumeric("0"));
EXPECT_TRUE(isRxPowerSavingNumeric("123456"));
EXPECT_FALSE(isRxPowerSavingNumeric(nullptr));
EXPECT_FALSE(isRxPowerSavingNumeric(""));
EXPECT_FALSE(isRxPowerSavingNumeric("-1"));
EXPECT_FALSE(isRxPowerSavingNumeric("1.5"));
EXPECT_FALSE(isRxPowerSavingNumeric("12x"));
EXPECT_FALSE(isRxPowerSavingNumeric(" 12"));
}
TEST(RxPowerSaving, CompanionProfileIsBalancedPreambleSixteen) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_BALANCED_LEVEL, 10, 250.0f, 16,
&rx_us, &sleep_us));
EXPECT_EQ(rx_us, 49329U);
EXPECT_EQ(sleep_us, 23757U);
}
TEST(RxPowerSaving, NamedProfilesSitWhereTheScaleSaysTheyDo) {
EXPECT_EQ(RX_POWERSAVING_CONSERVATIVE_LEVEL, 3);
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_CONSERVATIVE_LEVEL, 16), 13.0f);
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_CONSERVATIVE_LEVEL, 32), 16.0f);
EXPECT_EQ(RX_POWERSAVING_BALANCED_LEVEL, 6);
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_BALANCED_LEVEL, 16), 10.0f);
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_BALANCED_LEVEL, 32), 10.0f);
// The floor is shared by both profiles, and is what makes a level mean the
// same geometry on an SX126x and an LR11x0.
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_MAX_LEVEL, 16),
RX_POWERSAVING_MIN_CATCH_SYMBOLS);
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_MAX_LEVEL, 32),
RX_POWERSAVING_MIN_CATCH_SYMBOLS);
EXPECT_EQ(RX_POWERSAVING_PROFILE_PREAMBLE, 16);
// Margins fall monotonically and end at zero; nothing outside the guarded
// scale reports one.
for (uint8_t lv = 2; lv <= RX_POWERSAVING_GUARDED_LEVELS; lv++) {
EXPECT_LT(rxPowerSavingLevelCatch(lv, 16), rxPowerSavingLevelCatch(lv - 1, 16));
EXPECT_LT(rxPowerSavingLevelCatch(lv, 32), rxPowerSavingLevelCatch(lv - 1, 32));
}
EXPECT_EQ(rxPowerSavingLevelCatch(RX_POWERSAVING_OVERDRIVE_LEVEL, 16), 0.0f);
EXPECT_EQ(rxPowerSavingLevelCatch(0, 16), 0.0f);
}
TEST(RxPowerSaving, HigherLevelTradesListenTimeForSleepTime) {
uint32_t conservative_rx_us = 0;
uint32_t conservative_sleep_us = 0;
uint32_t aggressive_rx_us = 0;
uint32_t aggressive_sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(1, 10, 250.0f, 16,
&conservative_rx_us, &conservative_sleep_us));
ASSERT_TRUE(calcRxPowerSavingLevel(10, 10, 250.0f, 16,
&aggressive_rx_us, &aggressive_sleep_us));
EXPECT_GT(conservative_rx_us, aggressive_rx_us);
EXPECT_LT(conservative_sleep_us, aggressive_sleep_us);
}
TEST(RxPowerSaving, AutoPreambleTracksSpreadingFactor) {
EXPECT_EQ(rxPowerSavingPreambleForSF(7), 32);
EXPECT_EQ(rxPowerSavingPreambleForSF(8), 32);
EXPECT_EQ(rxPowerSavingPreambleForSF(9), 16);
EXPECT_EQ(rxPowerSavingPreambleForSF(12), 16);
}
TEST(RxPowerSaving, LevelIntentRetunesAfterRadioChange) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
ASSERT_TRUE(recalcRxPowerSavingFromLevel(5, 8, 62.5f, 16, &rx_us, &sleep_us));
uint32_t old_rx_us = rx_us;
uint32_t old_sleep_us = sleep_us;
ASSERT_TRUE(recalcRxPowerSavingFromLevel(5, 9, 62.5f, 16, &rx_us, &sleep_us));
// Sleep is pure symbols, so it doubles with the symbol time. The listen
// window no longer does: the SetRxDutyCycle timer guard adds half of the
// sleep->RX transition, which is a fixed number of microseconds and does not
// scale with SF. So the window grows, but by less than a factor of two.
EXPECT_NEAR((double)sleep_us, (double)old_sleep_us * 2.0, 32.0);
EXPECT_GT(rx_us, old_rx_us);
EXPECT_LT((double)rx_us, (double)old_rx_us * 2.0);
}
TEST(RxPowerSaving, AutomaticPreambleRetunesAcrossSfBoundary) {
uint32_t automatic_rx_us = 0;
uint32_t automatic_sleep_us = 0;
uint32_t explicit_rx_us = 0;
uint32_t explicit_sleep_us = 0;
ASSERT_TRUE(recalcRxPowerSavingFromLevel(5, 8, 250.0f, 0,
&automatic_rx_us, &automatic_sleep_us));
ASSERT_TRUE(calcRxPowerSavingLevel(5, 8, 250.0f, 32,
&explicit_rx_us, &explicit_sleep_us));
EXPECT_EQ(automatic_rx_us, explicit_rx_us);
EXPECT_EQ(automatic_sleep_us, explicit_sleep_us);
ASSERT_TRUE(recalcRxPowerSavingFromLevel(5, 9, 250.0f, 0,
&automatic_rx_us, &automatic_sleep_us));
ASSERT_TRUE(calcRxPowerSavingLevel(5, 9, 250.0f, 16,
&explicit_rx_us, &explicit_sleep_us));
EXPECT_EQ(automatic_rx_us, explicit_rx_us);
EXPECT_EQ(automatic_sleep_us, explicit_sleep_us);
}
TEST(RxPowerSaving, ManualTimingsAreNotRetuned) {
uint32_t rx_us = 12345;
uint32_t sleep_us = 23456;
EXPECT_FALSE(recalcRxPowerSavingFromLevel(0, 10, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_EQ(rx_us, 12345U);
EXPECT_EQ(sleep_us, 23456U);
}
TEST(RxPowerSavingCLI, AppliesNamedAndManualProfiles) {
RxPowerSavingConfig config;
FakeRxPowerSavingControl control;
char reply[192];
ASSERT_TRUE(RXPowerSavingCLI::set("conservative", 10, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.level, 3);
EXPECT_EQ(config.preamble, 16);
ASSERT_TRUE(RXPowerSavingCLI::set("balanced", 10, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_TRUE(control.set_called);
EXPECT_TRUE(control.requested_enabled);
EXPECT_EQ(config.enabled, 1);
EXPECT_EQ(config.level, RX_POWERSAVING_BALANCED_LEVEL);
EXPECT_EQ(config.level, 6);
EXPECT_EQ(config.preamble, RX_POWERSAVING_PROFILE_PREAMBLE);
EXPECT_EQ(config.rx_us, 49329U);
EXPECT_EQ(config.sleep_us, 23757U);
control.set_called = false;
ASSERT_TRUE(RXPowerSavingCLI::set("12345 23456", 10, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_TRUE(control.set_called);
EXPECT_EQ(config.level, 0);
EXPECT_EQ(config.preamble, 0);
EXPECT_EQ(config.rx_us, 12345U);
EXPECT_EQ(config.sleep_us, 23456U);
}
TEST(RxPowerSavingCLI, StoresAutomaticPreambleIntentForLevel) {
RxPowerSavingConfig config;
FakeRxPowerSavingControl control;
char reply[192];
ASSERT_TRUE(RXPowerSavingCLI::set("level 5", 8, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.level, 5);
EXPECT_EQ(config.preamble, 0);
uint32_t expected_rx_us = 0;
uint32_t expected_sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(5, 8, 250.0f, 32,
&expected_rx_us, &expected_sleep_us));
EXPECT_EQ(config.rx_us, expected_rx_us);
EXPECT_EQ(config.sleep_us, expected_sleep_us);
}
TEST(RxPowerSavingCLI, DoesNotPersistRejectedOrInvalidChanges) {
RxPowerSavingConfig config;
RxPowerSavingConfig original = config;
FakeRxPowerSavingControl control;
char reply[192];
EXPECT_FALSE(RXPowerSavingCLI::set("level 0", 10, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.enabled, original.enabled);
EXPECT_EQ(config.level, original.level);
EXPECT_STREQ(reply, "ERROR: level range is 1-10 (or max|overdrive|riskyWorkingMax); preamble is 16 or 32");
control.accept = false;
EXPECT_FALSE(RXPowerSavingCLI::set("balanced", 10, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.enabled, original.enabled);
EXPECT_EQ(config.level, original.level);
EXPECT_STREQ(reply, "ERROR: RX powersaving unsupported");
}
TEST(RxPowerSavingCLI, RejectsValuesBeforeNarrowingOrOverflow) {
RxPowerSavingConfig config;
const RxPowerSavingConfig original = config;
FakeRxPowerSavingControl control;
char reply[192];
const char* invalid_values[] = {
"261", // used to alias to level 5 after uint8_t truncation
"level 266", // used to alias to level 10
"level 5 preamble 272", // used to alias to preamble 16
"4294967296 1000", // one above UINT32_MAX
"999999999999999999999999999", // must not wrap during parsing
};
for (const char* value : invalid_values) {
control.set_called = false;
EXPECT_FALSE(RXPowerSavingCLI::set(value, 10, 250.0f, &config, &control,
reply, sizeof(reply))) << value;
EXPECT_FALSE(control.set_called) << value;
EXPECT_EQ(config.enabled, original.enabled) << value;
EXPECT_EQ(config.level, original.level) << value;
EXPECT_EQ(config.preamble, original.preamble) << value;
EXPECT_EQ(config.rx_us, original.rx_us) << value;
EXPECT_EQ(config.sleep_us, original.sleep_us) << value;
}
}
TEST(RxPowerSavingCLI, DisablingKeepsTimingIntent) {
RxPowerSavingConfig config;
config.enabled = 1;
config.level = 7;
config.preamble = 32;
config.rx_us = 34567;
config.sleep_us = 45678;
FakeRxPowerSavingControl control;
char reply[192];
ASSERT_TRUE(RXPowerSavingCLI::set("off", 10, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_FALSE(control.requested_enabled);
EXPECT_EQ(config.enabled, 0);
EXPECT_EQ(config.level, 7);
EXPECT_EQ(config.preamble, 32);
EXPECT_EQ(config.rx_us, 34567U);
EXPECT_EQ(config.sleep_us, 45678U);
}
TEST(RxPowerSavingCLI, FormatsDesiredAndEffectiveStateSeparately) {
RxPowerSavingConfig config;
config.enabled = 1;
FakeRxPowerSavingControl control;
control.status = {true, false, -706, 2, 0, 0};
char reply[192];
RXPowerSavingCLI::get(&config, &control, 10, 250.0f, reply, sizeof(reply));
EXPECT_NE(std::strstr(reply, "desired=on,effective=continuous,supported=yes"), nullptr);
EXPECT_NE(std::strstr(reply, "err=-706,fail=2"), nullptr);
EXPECT_EQ(std::strstr(reply, "erx="), nullptr); // nothing armed, nothing to report
}
TEST(RxPowerSavingCLI, ReportsClampedPeriodsOnlyWhenTheyDiffer) {
RxPowerSavingConfig config;
config.enabled = 1;
FakeRxPowerSavingControl control;
char reply[192];
// driver armed exactly what was asked for -> no extra fields
control.status = {true, true, 0, 0, config.rx_us, config.sleep_us};
RXPowerSavingCLI::get(&config, &control, 10, 250.0f, reply, sizeof(reply));
EXPECT_NE(std::strstr(reply, "effective=armed"), nullptr);
EXPECT_EQ(std::strstr(reply, "erx="), nullptr);
// driver had to stretch the RX window -> surface the real values
control.status = {true, true, 0, 0, config.rx_us + 4000, config.sleep_us};
RXPowerSavingCLI::get(&config, &control, 10, 250.0f, reply, sizeof(reply));
EXPECT_NE(std::strstr(reply, "erx=69625,eslp=60000"), nullptr);
}
TEST(RxPowerSavingCLI, GetDoesNotMutateStoredConfig) {
RxPowerSavingConfig config;
config.rx_us = 0; // invalid, e.g. from an older persisted prefs file
config.sleep_us = 999;
FakeRxPowerSavingControl control;
char reply[192];
RXPowerSavingCLI::get(&config, &control, 10, 250.0f, reply, sizeof(reply));
EXPECT_EQ(config.rx_us, 0U);
EXPECT_EQ(config.sleep_us, 999U);
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
// Measured on SX1262 at SF6/BW62.5: the P16 profile's own sleep is below the
// driver's arming floor on levels 1-5 (and on levels 1-2 at SF7), where
// startReceiveDutyCycle answers -708 and the wrapper falls back to continuous
// RX while the config still reports power saving as on.
TEST(RxPowerSaving, ShortSleepIsRaisedToTheArmingFloor) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
// SF6/BW62.5: level 1 of the P16 profile asks for 2 symbols = 2048 us.
ASSERT_TRUE(calcRxPowerSavingLevel(1, 6, 62.5f, 16, &rx_us, &sleep_us));
EXPECT_EQ(sleep_us, RX_POWERSAVING_MIN_SLEEP_US);
// Raising it must not break capture: the budget is preamble - cost symbols.
EXPECT_LE(sleep_us, (uint32_t)((16.0f - RX_POWERSAVING_CAPTURE_COST_SYMBOLS) * 1024.0f));
// Only level 2 still lands under the floor. Before MC_TCXO_DELAY_US dropped
// the transition from 6000 to 2600 us the floor was 6250 us and swallowed
// levels 2-6 as well, so most of the 16-symbol ladder collapsed onto one
// point at SF6 - the node quietly slept longer, and caught fewer symbols,
// than the level it was set to promised.
for (uint8_t lv = 2; lv <= 2; lv++) {
uint32_t rx_n = 0;
uint32_t sleep_n = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(lv, 6, 62.5f, 16, &rx_n, &sleep_n)) << (int)lv;
EXPECT_EQ(sleep_n, RX_POWERSAVING_MIN_SLEEP_US) << (int)lv;
EXPECT_EQ(rx_n, rx_us) << (int)lv;
}
// Level 4 sleeps 3.8 symbols, which now fits above the floor, so it gets its
// own point and saves more power than the collapsed ones.
uint32_t rx5_us = 0;
uint32_t sleep5_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(4, 6, 62.5f, 16, &rx5_us, &sleep5_us));
EXPECT_GT(sleep5_us, RX_POWERSAVING_MIN_SLEEP_US);
EXPECT_LT((double)rx5_us / (rx5_us + sleep5_us),
(double)rx_us / (rx_us + sleep_us));
}
TEST(RxPowerSaving, RejectsProfilesWhoseFloorWouldBreakCapture) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
// SF6/BW250: the symbol is 256 us, so the whole P16 capture budget is
// 10 symbols = 2560 us - under the arming floor. No level can duty cycle
// here, and the caller has to hear that rather than get a silent fallback.
//
// This used to be SF7/BW250, which the lower transition has since brought
// within reach: its budget is 5120 us against a floor that fell from 6250 to
// 2850, so the whole P16 ladder became armable there. The refusal path still
// needs a setting that is genuinely out of reach, so the example moved down
// one SF rather than away.
EXPECT_FALSE(calcRxPowerSavingLevel(1, 6, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_FALSE(calcRxPowerSavingLevel(RX_POWERSAVING_MAX_LEVEL, 6, 250.0f, 16,
&rx_us, &sleep_us));
// The P32 profile has 26 symbols of budget at the same setting and survives.
EXPECT_TRUE(calcRxPowerSavingLevel(1, 6, 250.0f, 32, &rx_us, &sleep_us));
EXPECT_GE(sleep_us, RX_POWERSAVING_MIN_SLEEP_US);
// And the setting that moved: SF7/BW250 with P16 now arms on every level.
EXPECT_TRUE(calcRxPowerSavingLevel(1, 7, 250.0f, 16, &rx_us, &sleep_us));
EXPECT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_MAX_LEVEL, 7, 250.0f, 16,
&rx_us, &sleep_us));
}
TEST(RxPowerSaving, TransitionTimeComesFromTheRadioLikeCaptureCost) {
class SlowTcxoControl : public RxPowerSavingControl {
public:
uint32_t rxPowerSavingTransitionUs() const override { return 11750; }
} slow;
EXPECT_EQ(rxPowerSavingTransition(nullptr), RX_POWERSAVING_TRANSITION_US);
EXPECT_EQ(rxPowerSavingTransition(&slow), 11750u);
// SF7 rather than SF6: a 12 ms floor does not fit inside the 10-symbol
// capture budget of a 1024 us symbol, which is the rejection case above.
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(1, 7, 62.5f, 16, &rx_us, &sleep_us,
RX_POWERSAVING_CAPTURE_COST_SYMBOLS,
rxPowerSavingTransition(&slow)));
// Floor is transition + margin, snapped to a whole 15.625 us tick.
EXPECT_GE(sleep_us, 12000u);
EXPECT_LT(sleep_us, 12020u);
}
TEST(RxPowerSavingCLI, ReportsWhenNoLevelCanDutyCycleAtThisRadioSetting) {
RxPowerSavingConfig config;
FakeRxPowerSavingControl control;
char reply[160];
// SF6/BW250 with the P16 profile: nothing between the arming floor and the
// capture budget, so the level must be refused with a message that names the
// real reason instead of blaming the level range.
EXPECT_FALSE(RXPowerSavingCLI::set("level 5 preamble 16", 6, 250.0f, &config, &control,
reply, sizeof(reply)));
EXPECT_NE(strstr(reply, "SF/BW"), nullptr);
EXPECT_FALSE(control.set_called);
EXPECT_EQ(config.enabled, 0);
}
// SX1261/2 datasheet, SetRxDutyCycle: on preamble detection the radio restarts
// its timer with 2*rxPeriod + sleepPeriod and requires
// Tpreamble + Theader <= 2 * rxPeriod + sleepPeriod
// Measured on two SX1262 boards: when that holds nothing goes wrong, and when
// it is broken the chip usually gets away with it - except at isolated register
// values one tick wide (rxPeriod 320 and 640) where it loses 35-100% of the
// packets it has already latched. Satisfying the condition is the only defence
// that does not depend on knowing every bad tick.
TEST(RxPowerSaving, EveryLevelSatisfiesTheDutyCycleTimerCondition) {
const uint8_t sfs[] = {6, 7, 8, 10, 12};
const float bws[] = {62.5f, 250.0f};
const uint8_t preambles[] = {16, 32};
for (uint8_t sf : sfs) {
for (float bw : bws) {
for (uint8_t preamble : preambles) {
for (uint8_t level = 1; level <= RX_POWERSAVING_GUARDED_LEVELS; level++) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
if (!calcRxPowerSavingLevel(level, sf, bw, preamble, &rx_us, &sleep_us)) {
continue; // rejected outright; nothing is armed, nothing to check
}
const float symbol_us = (1000.0f * (float)(1UL << sf)) / bw;
const float sync = sf <= 6 ? RX_POWERSAVING_SYNC_SYMBOLS_LOW_SF
: RX_POWERSAVING_SYNC_SYMBOLS;
const float need =
((float)preamble + sync + RX_POWERSAVING_HEADER_SYMBOLS) * symbol_us;
// Compare on the register values the radio really runs, not on the
// microseconds we asked for: the driver truncates to 15.625 us ticks.
const uint32_t rx_ticks = (rx_us * 8) / 125;
const uint32_t sleep_ticks =
((sleep_us - RX_POWERSAVING_TRANSITION_US) * 8) / 125;
const float restarted = (2.0f * rx_ticks + sleep_ticks) * 15.625f;
EXPECT_GE(restarted, need)
<< "SF" << (int)sf << " BW" << bw << " P" << (int)preamble
<< " level " << (int)level;
// And the periods handed out must themselves be whole ticks, so the
// CLI reports what the hardware runs.
EXPECT_EQ((rx_ticks * 125 + 7) / 8, rx_us);
}
}
}
}
}
// Level 11 is the measured maximum: the geometry the bench ran before the timer
// guard existed, kept because the guard costs 4 to 12 percentage points of duty
// cycle. 8 symbols of listening, sleep right at the capture budget.
TEST(RxPowerSaving, OverdriveIsTheMeasuredGeometryAtEverySf) {
const uint8_t sfs[] = {6, 7, 8, 10};
for (uint8_t sf : sfs) {
for (uint8_t preamble : {16, 32}) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_OVERDRIVE_LEVEL, sf, 62.5f,
(uint8_t)preamble, &rx_us, &sleep_us))
<< "SF" << (int)sf << " P" << preamble;
const float symbol_us = (1000.0f * (float)(1UL << sf)) / 62.5f;
EXPECT_NEAR(rx_us / symbol_us, 8.0f /* rx_edge_symbols */, 0.02f);
EXPECT_NEAR(sleep_us / symbol_us,
preamble - RX_POWERSAVING_CAPTURE_COST_SYMBOLS, 0.02f);
// The whole point: 23.5% duty on P32, 44.4% on P16, at every SF.
const double duty = 100.0 * rx_us / (rx_us + sleep_us);
EXPECT_NEAR(duty, preamble == 32 ? 23.5 : 44.4, 0.2);
}
}
}
TEST(RxPowerSaving, OverdriveDeliberatelyBreaksTheTimerCondition) {
// Stated as a test so nobody later "fixes" it into compliance by accident:
// level 11 exists precisely because it sits outside the datasheet rule, and
// it was measured lossless there on three boards across SF6, SF7 and SF8.
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_OVERDRIVE_LEVEL, 6, 62.5f, 32,
&rx_us, &sleep_us));
const float symbol_us = (1000.0f * 64.0f) / 62.5f;
const float need = (32.0f + RX_POWERSAVING_SYNC_SYMBOLS_LOW_SF +
RX_POWERSAVING_HEADER_SYMBOLS) * symbol_us;
const uint32_t rx_ticks = (rx_us * 8) / 125;
const uint32_t sleep_ticks = ((sleep_us - RX_POWERSAVING_TRANSITION_US) * 8) / 125;
EXPECT_LT((2.0f * rx_ticks + sleep_ticks) * RX_POWERSAVING_TICK_US, need);
// and the top of the guarded scale must still satisfy it
uint32_t g_rx = 0;
uint32_t g_sleep = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_MAX_LEVEL, 6, 62.5f, 32, &g_rx, &g_sleep));
const uint32_t g_rx_ticks = (g_rx * 8) / 125;
const uint32_t g_sleep_ticks = ((g_sleep - RX_POWERSAVING_TRANSITION_US) * 8) / 125;
EXPECT_GE((2.0f * g_rx_ticks + g_sleep_ticks) * RX_POWERSAVING_TICK_US, need);
EXPECT_LT(rx_us, g_rx); // and it really does listen less
}
TEST(RxPowerSaving, OverdriveStepsOffTheKnownBadRegisterTicks) {
// 8 symbols land on rxPeriod tick 320 when the symbol is 625 us. No standard
// bandwidth produces that, which is why production never hit it - but the
// unguarded path has no other protection, so the check has to work.
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_OVERDRIVE_LEVEL, 6, 102.4f, 32,
&rx_us, &sleep_us));
EXPECT_EQ((rx_us * 8) / 125, 321u); // nudged one tick clear of 320
EXPECT_EQ(rx_us, 5016u);
// The guarded scale needs no such help and must be left alone.
uint32_t g_rx = 0;
uint32_t g_sleep = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(10, 6, 102.4f, 32, &g_rx, &g_sleep));
EXPECT_NE((g_rx * 8) / 125, 320u);
}
TEST(RxPowerSavingCLI, OverdriveAndMaxPresetsSelectTheRightLevels) {
RxPowerSavingConfig config;
FakeRxPowerSavingControl control;
char reply[160];
// `max` is the top of the guarded scale, and like every named preset it
// assumes a 16-symbol sender, so at SF<=8 it is deliberately less economical
// than `level 8`, which follows the SF onto the 32-symbol profile.
ASSERT_TRUE(RXPowerSavingCLI::set("max", 8, 62.5f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.level, RX_POWERSAVING_MAX_LEVEL);
EXPECT_EQ(config.level, 8);
EXPECT_EQ(rxPowerSavingLevelCatch(config.level, 16), RX_POWERSAVING_MIN_CATCH_SYMBOLS);
EXPECT_EQ(config.preamble, 16);
EXPECT_EQ(strstr(reply, "overdrive"), nullptr);
const uint32_t max_rx = config.rx_us;
const uint32_t max_sleep = config.sleep_us;
ASSERT_TRUE(RXPowerSavingCLI::set("level 8", 8, 62.5f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.preamble, 0);
EXPECT_LT((double)config.rx_us / (config.rx_us + config.sleep_us),
(double)max_rx / (max_rx + max_sleep));
// `overdrive` is one step past it, on the same worst-case preamble.
ASSERT_TRUE(RXPowerSavingCLI::set("overdrive", 8, 62.5f, &config, &control,
reply, sizeof(reply)));
EXPECT_EQ(config.level, RX_POWERSAVING_OVERDRIVE_LEVEL);
EXPECT_EQ(config.preamble, 16);
EXPECT_NE(strstr(reply, "overdrive"), nullptr);
EXPECT_LT(config.rx_us, max_rx); // and really does listen less
control.status.supported = true;
control.status.armed = true;
RXPowerSavingCLI::get(&config, &control, 10, 250.0f, reply, sizeof(reply));
EXPECT_NE(strstr(reply, "(overdrive)"), nullptr);
// Both names take an explicit preamble, which is how the 32-symbol profile
// is reached without giving up the preset.
ASSERT_TRUE(RXPowerSavingCLI::set("overdrive preamble 32", 8, 62.5f, &config,
&control, reply, sizeof(reply)));
EXPECT_EQ(config.level, RX_POWERSAVING_OVERDRIVE_LEVEL);
EXPECT_EQ(config.preamble, 32);
ASSERT_TRUE(RXPowerSavingCLI::set("max preamble 32", 8, 62.5f, &config,
&control, reply, sizeof(reply)));
EXPECT_EQ(config.level, RX_POWERSAVING_MAX_LEVEL);
EXPECT_EQ(config.preamble, 32);
EXPECT_FALSE(RXPowerSavingCLI::set("overdrive preamble 24", 8, 62.5f, &config,
&control, reply, sizeof(reply)));
EXPECT_FALSE(RXPowerSavingCLI::set("max preamble", 8, 62.5f, &config,
&control, reply, sizeof(reply)));
EXPECT_FALSE(RXPowerSavingCLI::set("level 11", 8, 62.5f, &config, &control,
reply, sizeof(reply)));
}
TEST(RxPowerSaving, RiskyWorkingMaxIsTheMeasuredEdgeAndCostsDelivery) {
// The bench walked the profile past level 10 until delivery came back:
// virtual 11.0 for P32, 10.25 for P16. Both put the sleep beyond the capture
// budget, which is the whole reason they lose packets - 196/200 and 197/200
// at SF8 with an LR1110 witnessing every transmission.
const float symbol_us = (1000.0f * 256.0f) / 62.5f; // SF8 / BW62.5
uint32_t rx32 = 0;
uint32_t sleep32 = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_RISKY_WORKING_MAX_LEVEL, 8, 62.5f, 32,
&rx32, &sleep32));
EXPECT_NEAR(rx32 / symbol_us, 7.111f, 0.02f);
EXPECT_NEAR(sleep32 / symbol_us, 27.222f, 0.02f);
EXPECT_GT(sleep32 / symbol_us, 32.0f - RX_POWERSAVING_CAPTURE_COST_SYMBOLS);
uint32_t rx16 = 0;
uint32_t sleep16 = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_RISKY_WORKING_MAX_LEVEL, 8, 62.5f, 16,
&rx16, &sleep16));
EXPECT_NEAR(rx16 / symbol_us, 7.889f, 0.02f);
EXPECT_NEAR(sleep16 / symbol_us, 10.222f, 0.02f);
EXPECT_GT(sleep16 / symbol_us, 16.0f - RX_POWERSAVING_CAPTURE_COST_SYMBOLS);
// It must sleep more than overdrive, or it would have no reason to exist.
uint32_t o_rx = 0;
uint32_t o_sleep = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(RX_POWERSAVING_OVERDRIVE_LEVEL, 8, 62.5f, 32,
&o_rx, &o_sleep));
EXPECT_GT((double)sleep32 / (rx32 + sleep32), (double)o_sleep / (o_rx + o_sleep));
// Both levels past the guarded scale skip the timer guard.
EXPECT_TRUE(isRxPowerSavingUnguardedLevel(RX_POWERSAVING_RISKY_WORKING_MAX_LEVEL));
EXPECT_TRUE(isRxPowerSavingUnguardedLevel(RX_POWERSAVING_OVERDRIVE_LEVEL));
EXPECT_FALSE(isRxPowerSavingUnguardedLevel(RX_POWERSAVING_MAX_LEVEL));
}
TEST(RxPowerSavingCLI, RiskyWorkingMaxUsesOneNameEverywhere) {
RxPowerSavingConfig config;
FakeRxPowerSavingControl control;
char reply[160];
ASSERT_TRUE(RXPowerSavingCLI::set("riskyWorkingMax", 8, 62.5f, &config,
&control, reply, sizeof(reply)));
EXPECT_EQ(config.level, RX_POWERSAVING_RISKY_WORKING_MAX_LEVEL);
EXPECT_EQ(config.preamble, 16);
EXPECT_NE(strstr(reply, "(riskyWorkingMax)"), nullptr);
ASSERT_TRUE(RXPowerSavingCLI::set("riskyWorkingMax preamble 32", 8, 62.5f,
&config, &control, reply, sizeof(reply)));
EXPECT_EQ(config.preamble, 32);
control.status.supported = true;
control.status.armed = true;
RXPowerSavingCLI::get(&config, &control, 10, 250.0f, reply, sizeof(reply));
EXPECT_NE(strstr(reply, "(riskyWorkingMax)"), nullptr);
// The name remains case-sensitive and has no shortcut.
EXPECT_FALSE(RXPowerSavingCLI::set("riskyworkingmax", 8, 62.5f, &config, &control,
reply, sizeof(reply)));
}
// The whole point of the scale: level N means "a sender's preamble may be N
// symbols shorter than this profile assumes and still be caught". That has to
// hold on every SF, bandwidth and profile, because being dimensionless is the
// reason the scale is expressed this way rather than in microseconds or in
// milliamperes - both of which differ per board.
TEST(RxPowerSaving, EveryGuardedLevelDeliversTheMarginItPromises) {
const uint8_t sfs[] = {7, 8, 9, 10, 12};
const float bws[] = {62.5f, 125.0f, 250.0f};
const uint8_t preambles[] = {16, 32};
for (uint8_t sf : sfs) {
for (float bw : bws) {
for (uint8_t preamble : preambles) {
for (uint8_t level = 1; level <= RX_POWERSAVING_GUARDED_LEVELS; level++) {
uint32_t rx_us = 0;
uint32_t sleep_us = 0;
if (!calcRxPowerSavingLevel(level, sf, bw, preamble, &rx_us, &sleep_us)) {
continue; // rejected outright, nothing to check
}
if (sleep_us == RX_POWERSAVING_MIN_SLEEP_US) {
continue; // the floor ate the margin; reported by the CLI, not a bug
}
const float symbol_us = (1000.0f * (float)(1UL << sf)) / bw;
const float caught = (float)preamble - (float)sleep_us / symbol_us;
// The delivered catch is the ladder value plus the pad that keeps
// every generated geometry off the defective register pairs.
EXPECT_NEAR(caught,
rxPowerSavingLevelCatch(level, preamble) + RX_POWERSAVING_MARGIN_PAD_SYMBOLS,
0.05f)
<< "SF" << (int)sf << " BW" << bw << " P" << (int)preamble
<< " level " << (int)level;
}
}
}
}
}
TEST(RxPowerSaving, ALevelMeansTheSameGeometryOnBothRadioFamilies) {
// This is what the catch scale buys that the old margin scale could not: the
// capture cost is no longer part of the arithmetic, so a level produces the
// same periods whether the driver declares 6 symbols (SX126x) or 8 (LR11x0).
// Before, the same level number meant two different sleeps on the two chips.
for (uint8_t level = 1; level <= RX_POWERSAVING_GUARDED_LEVELS; level++) {
for (uint8_t preamble : {16, 32}) {
uint32_t rx_sx = 0, sleep_sx = 0, rx_lr = 0, sleep_lr = 0;
ASSERT_TRUE(calcRxPowerSavingLevel(level, 8, 62.5f, preamble, &rx_sx, &sleep_sx,
RX_POWERSAVING_CAPTURE_COST_SYMBOLS));
ASSERT_TRUE(calcRxPowerSavingLevel(level, 8, 62.5f, preamble, &rx_lr, &sleep_lr,
RX_POWERSAVING_CAPTURE_COST_SYMBOLS_LR11X0));
EXPECT_EQ(sleep_sx, sleep_lr) << "level " << (int)level << " P" << (int)preamble;
EXPECT_EQ(rx_sx, rx_lr) << "level " << (int)level << " P" << (int)preamble;
}
}
}
Reference in New Issue View Git Blame Copy Permalink