Qualify RAK repeater RAM and retire stale channel-busy waits

This commit is contained in:
mikecarper committed 2026-10-22 22:59:23 -07:00
1 parent e34e83e6b4
commit adb11e7b41
18 files changed
+535 -110

No files matched your search

+50 -10
View File
@@ -438,7 +438,7 @@ int main() {
"ENABLE_OTA": 1, "OTA_HEAP_CONTEXT": 1,
}, "GEPRC_Linkflow_900_repeater")
self.assertEqual(policy["components"]["client_table"], 32 * 320 + 16)
self.assertEqual(policy["components"]["flood_filter_table"], 63 * 336 + 16)
self.assertEqual(policy["components"]["flood_filter_table"], 63 * 304 + 16)
self.assertEqual(policy["components"]["ota_context"], 16384 + 16)
self.assertGreaterEqual(policy["required_contiguous_bytes"], 16384 + 16)
reduced = ram.requirements("STM32_PLATFORM", {
@@ -681,9 +681,9 @@ int main() {
self.assertNotIn("ota_encoder_workspace", components)
self.assertNotIn("ota_self_source_scratch", components)
self.assertEqual(components["display_pixels_and_driver"], 2048)
self.assertEqual(combined["required_heap_bytes"] - legacy["required_heap_bytes"], 3072 - 2048)
self.assertEqual(combined["required_heap_bytes"] - legacy["required_heap_bytes"], 3072)
self.assertEqual(components["loop_and_callback_stacks"], 8192 + 3072)
self.assertEqual(components["flood_filter_table"], 63 * 336 + 16)
self.assertEqual(components["flood_filter_table"], 63 * 304 + 16)
# An alternate port selects the same bridge instead of allocating two.
alternate = ram.requirements("NRF52_PLATFORM", {
**defines, "RAK4631_COMBINED_ETHERNET": 1,
@@ -794,7 +794,7 @@ int main() {
alias = ram.requirements("ESP32_PLATFORM", {"MESH_CLIENT_REPEATER_ONLY": 1},
"custom_companion_alias")
self.assertEqual(alias["components"]["client_table"], 32 * 284 + 16)
self.assertEqual(alias["components"]["flood_filter_table"], 63 * 336 + 16)
self.assertEqual(alias["components"]["flood_filter_table"], 63 * 304 + 16)
self.assertEqual(alias["components"]["neighbor_history"], 2048 * 9 + 16)
self.assertEqual(alias["components"]["radio_packet_pool"], 10240)
@@ -838,7 +838,46 @@ int main() {
self.assertEqual(legacy["required_contiguous_bytes"],
selected["required_contiguous_bytes"])
def test_combined_rak_oled_bound_does_not_change_other_display_budgets(self):
def test_rak_repeater_compact_rule_and_oled_budgets_keep_every_other_reserve(self):
flags = {
"ENABLE_OTA": 1, "OTA_RAK_AUTO_STORE": 1, "OTA_QSPI_STORE": 1,
"OTA_RAK15002_SD_STORE": 1, "OTA_FLASH_STORE": 1,
"MESHCORE_OTA_DEVICE_DEFLATE": 1, "MESH_CLIENT_REPEATER_ONLY": 1,
"DISPLAY_CLASS": "SSD1306Display",
}
selected = ram.requirements("NRF52_PLATFORM", flags, "RAK_4631_repeater")
self.assertEqual(selected["components"], {
"loop_and_callback_stacks": 11264,
"core_usb_filesystems_sensors": 12288,
"sd_fat_volume_and_files": 2048,
"radio_packet_pool": 10240,
"client_table": 9104,
"flood_filter_table": 63 * 304 + 16,
"ota_generic_source_buffers": 3616,
"ota_encoder_workspace": 1040,
"ota_self_source_scratch": 4128,
"display_pixels_and_driver": 2048,
"screen_objects_and_history": 2048,
"allocation_and_transient_margin": 4096,
})
self.assertEqual(selected["required_heap_bytes"], 81088)
self.assertEqual(selected["required_contiguous_bytes"], 19168)
# The fresh Full baseline's 81,668 bytes passed only after the real
# 32-byte per-row reduction and same-driver OLED accounting proof.
# Neither a one-byte deficit nor the old failed capacity can bypass
# the existing real-ELF gate.
with tempfile.TemporaryDirectory() as temporary:
path = Path(temporary) / "firmware.elf"
for available, expected in ((81087, False), (81088, True), (81668, True)):
with self.subTest(available=available):
elf32(path, {"__HeapBase": (0x20010000, 0),
"__HeapLimit": (0x20010000 + available, 0)})
with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
passed = ram.check_firmware(path, "NRF52_PLATFORM", "nrf52840",
flags, "RAK_4631_repeater") == 0
self.assertEqual(passed, expected)
def test_nrf52_oled_bound_matches_same_source_guard_without_changing_other_displays(self):
defines = {
"RAK_4631": 1, "ETHERNET_ENABLED": 1, "OTA_RAK_AUTO_STORE": 1,
"RAK4631_COMBINED_ETHERNET": 1,
@@ -853,7 +892,7 @@ int main() {
ordinary = ram.requirements("NRF52_PLATFORM", {
"DISPLAY_CLASS": "SSD1306Display",
}, "RAK_4631_repeater")
self.assertEqual(ordinary["components"]["display_pixels_and_driver"], 4096)
self.assertEqual(ordinary["components"]["display_pixels_and_driver"], 2048)
def test_esp32_fixed_oled_and_uart_bounds_preserve_full_runtime_reserves(self):
defines = {
@@ -866,13 +905,13 @@ int main() {
}
full = ram.requirements("ESP32_PLATFORM", defines, "Heltec_v3_repeater_observer_mqtt")
parts = full["components"]
self.assertEqual(full["required_heap_bytes"], 203920)
self.assertEqual(full["required_heap_bytes"], 201904)
self.assertEqual(parts["display_pixels_and_driver"], 2048)
self.assertEqual(parts["uart_bridge_and_driver"], 3072 + 4096)
self.assertEqual(parts["wireless_stacks"], 49152)
self.assertEqual(parts["mqtt_startup_allowance"], 24576)
self.assertEqual(parts["allocation_and_transient_margin"], 16384)
self.assertEqual(full["required_contiguous_bytes"], 21184)
self.assertEqual(full["required_contiguous_bytes"], 19168)
for driver, expected in (("SH1106Display", 2048), ("SH1107Display", 4096),
("ST7735Display", 25602)):
with self.subTest(driver=driver):
@@ -883,7 +922,7 @@ int main() {
self.assertEqual(other["components"], {
**parts, "display_pixels_and_driver": expected,
})
self.assertEqual(other["required_contiguous_bytes"], max(21184, expected))
self.assertEqual(other["required_contiguous_bytes"], max(19168, expected))
def test_sh1106_full_mqtt_release_profile_is_linked_in_ci(self):
workflow = (ROOT / ".github/workflows/run-unit-tests.yml").read_text()
@@ -933,7 +972,8 @@ int main() {
"-DWITH_RS232_BRIDGE=1", "-DWITH_UDP_BRIDGE=1", f"-DOBJECT_BYTES={size}",
f"-DFRAME_BYTES={frame}", *["-D" + flag for flag in platform],
], input=stand_in + prefix, text=True, capture_output=True)
enforced = "ESP32=1" in platform or (
enforced = "ESP32=1" in platform or ("NRF52_PLATFORM=1" in platform
and path.endswith("SSD1306Display.cpp")) or (
"RAK4631_COMBINED_ETHERNET=1" in platform
and not path.endswith(("SH1106Display.cpp", "UDPBridge.cpp")))
self.assertEqual(result.returncode == 0, bounded or not enforced,
+35 -1
View File
@@ -93,10 +93,17 @@ static const char RULE_TEMP_FILE[] = "/flood_filter.tmp";
static const char RULE_BACKUP_FILE[] = "/flood_filter.bak";
'''
SCENARIOS = r'''
template<class Entry>
auto setScope(Entry& row, const char* name, int) -> decltype(row.target_name, void()) {
row.target_is_region = false;
std::strcpy(row.target_name, name);
}
template<class Entry>
void setScope(Entry& row, const char* name, long) { std::strcpy(row.scope_name,name); }
template<class Entry> void canonicalRule(Entry& row) {
row.active=true;row.payload_type=PAYLOAD_TYPE_ADVERT;
row.min_hops=2;row.max_hops=63;row.suspend_on_temp_radio=true;
std::strcpy(row.scope_name,"#Town");row.match_blacklisted_path=true;
setScope(row,"#Town",0);row.match_blacklisted_path=true;
row.scope_uses_slow_timing=true;row.incoming_scope_kind=FloodFilterPolicy::RULE_IN_ALLOWED;
row.path_hash_size=3;row.rate_limit_enabled=true;row.rate_per_minute=1234;
row.priority=7;row.stop_on_match=true;row.retry_on_match=true;
@@ -216,6 +223,33 @@ int main() {
assert(writer.saveFloodPacketFilters());MyMesh drop(fs,63);assert(drop.loadFloodPacketFilters());
assert(drop.storage[0].active && drop.storage[0].drop_on_match && !drop.storage[0].retry_on_match);
}
{
MemoryFS fs;MyMesh writer(fs,63);auto& row=writer.storage[62];
row.active=true;row.payload_type=PAYLOAD_TYPE_ADVERT;row.max_hops=63;
row.target_is_region=true;
std::strcpy(row.target_name,"1234567890123456789012345678901");
assert(writer.saveFloodPacketFilters());
const auto image=fs.get(FLOOD_PACKET_FILTER_FILE);
MyMesh reader(fs,63);assert(reader.loadFloodPacketFilters());
assert(reader.storage[62].active && reader.storage[62].target_is_region);
assert(!std::strcmp(reader.storage[62].regionName(), row.target_name));
assert(reader.storage[62].scopeName()[0]==0);
assert(reader.saveFloodPacketFilters() && fs.get(FLOOD_PACKET_FILTER_FILE)==image);
// The stored region field starts at byte 153 of a 187-byte FPF7 row.
// A direct scope and region target in one old-format row is invalid;
// compaction must never silently choose one.
const size_t stride=(image.size()-5-9)/63;
assert(stride==187);
for(bool terminate : {true,false}) {
auto malformed=image;
const size_t scope=5+62*stride+5;
malformed[scope]='#';malformed[scope+1]='X';
if(!terminate)std::fill_n(malformed.begin()+scope,32,'X');
MemoryFS bad;bad.put(FLOOD_PACKET_FILTER_FILE,malformed);
MyMesh boot(bad,63);assert(boot.loadFloodPacketFilters());
assert(boot.seeded==1 && !boot.storage[62].active);
}
}
const auto large=fixture(63,62),small=fixture(4,2);
// Older writers stored every slot, including inactive trailing entries.
// Build the exact production wire format and replace the final active row
+34 -5
View File
@@ -24,8 +24,8 @@ static constexpr uint8_t NAME_LEN = 32, PATH_PREFIX_BYTES_MAX = 9;
'''
SCENARIOS = r'''
static_assert(sizeof(RepeaterEntry) == 332 && sizeof(RoomEntry) == 332,
"extended rows retain the reviewed 332-byte RAM bound");
static_assert(sizeof(RepeaterEntry) == 300 && sizeof(RoomEntry) == 332,
"compact repeater rows save 32 bytes; room layout stays unchanged");
static_assert(sizeof(LegacyEntry) == 40, "retain legacy STM32 rule layout");
static_assert(alignof(RepeaterEntry) >= alignof(uint32_t));
static_assert(alignof(RoomEntry) >= alignof(uint32_t));
@@ -37,6 +37,16 @@ static_assert(alignof(RoomEntry) >= alignof(uint32_t));
CHECK_ALIGNED(RepeaterEntry);
CHECK_ALIGNED(RoomEntry);
template<class Entry>
auto setTargetByte(Entry& e, bool region, size_t offset, char value, int)
-> decltype(e.target_name, void()) {
e.target_is_region = region;
e.target_name[offset] = value;
}
template<class Entry>
void setTargetByte(Entry& e, bool region, size_t offset, char value, long) {
(region ? e.target_region_name : e.scope_name)[offset] = value;
}
template<class Entry> void setFlags(Entry& e, unsigned flags) {
e.active = flags & 1;
e.suspend_on_temp_radio = flags & 2;
@@ -108,7 +118,7 @@ template<class Entry> void exerciseConfigurationEquality() {
case 2: changed.min_hops = 1; break;
case 3: changed.max_hops = 1; break;
case 4: changed.suspend_on_temp_radio = true; break;
case 5: changed.scope_name[sizeof(changed.scope_name)-1] = 1; break;
case 5: setTargetByte(changed, false, 31, 1, 0); break;
case 6: changed.match_blacklisted_path = true; break;
case 7: changed.scope_uses_slow_timing = true; break;
case 8: changed.incoming_scope_kind = 1; break;
@@ -120,7 +130,7 @@ template<class Entry> void exerciseConfigurationEquality() {
case 14: changed.path_hash_size = 1; break;
case 15: changed.path_hops = 1; break;
case 16: changed.path[sizeof(changed.path)-1] = 1; break;
case 17: changed.target_region_name[sizeof(changed.target_region_name)-1] = 1; break;
case 17: setTargetByte(changed, true, 31, 1, 0); break;
case 18: changed.drop_on_match = true; break;
case 19: changed.rate_limit_enabled = false; break;
case 20: changed.rate_per_minute = 6; break;
@@ -128,7 +138,7 @@ template<class Entry> void exerciseConfigurationEquality() {
case 22: changed.stop_on_match = true; break;
case 23: changed.retry_on_match = true; break;
case 24: changed.transport_modes = 2; break;
case 25: changed.scope_name[0] = '#'; break;
case 25: setTargetByte(changed, false, 0, '#', 0); break;
}
assert(!FloodFilterPolicy::sameRuleConfiguration(original, changed));
assert(!FloodFilterPolicy::sameRuleConfiguration(changed, original));
@@ -171,6 +181,25 @@ template<class Rules, class Entry> void exerciseProductionSlotSelection() {
assert(rules.select(candidate, 3) == 3); // Explicit index remains authoritative.
}
int main() {
// Every old flag combination can coexist with either target kind. Neither
// the tag nor name views may corrupt independent flags or leak a stale name.
for (unsigned flags = 0; flags < 512; ++flags) {
for (unsigned region = 0; region < 2; ++region) {
RepeaterEntry e{};
setFlags(e, flags);
e.target_is_region = region;
std::strcpy(e.target_name, "1234567890123456789012345678901");
assert(flagsOf(e) == flags);
const auto& selected = region ? e.regionName() : e.scopeName();
const auto& inactive = region ? e.scopeName() : e.regionName();
assert(!std::strcmp(selected, e.target_name));
for (char byte : inactive) assert(byte == 0);
RepeaterEntry copied = e;
assert(copied.target_is_region == region);
assert(!std::memcmp(copied.target_name, e.target_name, 32));
assert(flagsOf(copied) == flags);
}
}
exerciseFlags<RepeaterEntry>();
exerciseFlags<RoomEntry>();
exerciseConfigurationEquality<RepeaterEntry>();
+6
View File
@@ -139,6 +139,12 @@ int main() {
{ Fixture f;f.radio.receiving=true;assert(f.d.queue(bytes));f.tick();f.tick(201);
assert(f.radio.sends==0 && f.d.hasOutbound());f.radio.receiving=false;f.tick(201);assert(f.radio.sends==1);
}
{ Fixture f;f.radio.receiving=true;assert(f.d.queue(bytes));f.tick();
// The empty MeshCore queue must not retire a foreign frame's live CAD
// wait. Its existing bounded escape still records sustained contention.
f.tick(201);assert(!f.radio.sends && f.d.hasOutbound());
f.tick(3800);assert(f.radio.sends==1 && (f.d.getErrFlags() & ERR_EVENT_CAD_TIMEOUT));
}
{ Fixture f;auto* p=newPacket(f.d);f.radio.p.cross=RadioCrossMode::On;
assert(!f.radio.p.canCross() && f.d.getTransmitProfileMask(p)==1);
assert(f.d.sendPacket(p,0));assert(f.manager.getOutboundTotal()==1);f.tick();
+24
View File
@@ -286,6 +286,30 @@ int main() {
assert(f.d.getTotalAirTime()==1151 && !f.d.getNumSentDirect() && f.d.done.empty());
}
}
'''
self.compile_run(code, ["-DENABLE_OTA", "-DMESH_ENABLE_MESHTEXT_CHAT=0",
"-DMESH_ENABLE_ETHERNET_TUNNEL=0"], dispatcher=True)
def test_channel_wait_retirement_preserves_direct_ota_owner(self):
code = dispatcher_harness() + r'''
int main() {
{ Fixture f;directProfile(f);f.radio.receiving=true;
auto* old=newPacket(f.d,RADIO_TX_SECONDARY);assert(f.d.sendPacket(old,0));
f.tick();assert(!f.radio.sends && f.manager.getOutboundTotal()==1);
f.manager.free(f.manager.removeOutboundByIdx(0));
f.clock.now=10000;assert(enqueue(f));f.tick();
// New raw/direct ownership cannot inherit a cancelled MeshCore wait.
assert(!f.radio.sends && !(f.d.getErrFlags() & ERR_EVENT_CAD_TIMEOUT));
}
{ Fixture f;directProfile(f);f.radio.receiving=true;assert(enqueue(f));
f.tick();assert(!f.radio.sends && !f.manager.getOutboundTotal());
f.clock.now=10000;auto* next=newPacket(f.d,RADIO_TX_SECONDARY);
assert(f.d.sendPacket(next,0));f.tick();
// Conversely, a still-owned direct frame keeps its original ceiling even
// when another queued packet arrives for the same profile.
assert(f.radio.sends==1 && (f.d.getErrFlags() & ERR_EVENT_CAD_TIMEOUT));
}
}
'''
self.compile_run(code, ["-DENABLE_OTA", "-DMESH_ENABLE_MESHTEXT_CHAT=0",
"-DMESH_ENABLE_ETHERNET_TUNNEL=0"], dispatcher=True)
@@ -1317,6 +1317,190 @@ TEST(Dispatcher, GrowingQueueShortensCADBusyCeiling) {
EXPECT_TRUE(dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
}
TEST(Dispatcher, CancelledBusyQueueDoesNotAgeLaterChannelWait) {
RxReservePacketManager manager(8, 1);
TestClock clock;
clock.now = 100;
TestRadio radio;
radio.receiving = true;
TestDispatcher dispatcher(radio, clock, manager);
dispatcher.begin();
auto queuePacket = [&]() {
mesh::Packet* packet = dispatcher.obtainNewPacket();
EXPECT_NE(packet, nullptr);
packet->header = ROUTE_TYPE_DIRECT | (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT);
packet->payload[0] = 0x40;
packet->payload_len = 1;
EXPECT_TRUE(dispatcher.sendPacket(packet, 0));
};
queuePacket();
clock.now = 101;
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
// Echo suppression, cancellation and stale-work expiry can retire the last
// queued packet without a successful send or a free-channel observation.
manager.free(manager.removeOutboundByIdx(0));
clock.now = 302;
dispatcher.loop();
EXPECT_EQ(0, manager.getOutboundTotal());
clock.now = 10000;
queuePacket();
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
EXPECT_EQ(0, dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
// A genuinely continuous busy channel still reaches the original ceiling.
clock.now = 14001;
dispatcher.loop();
EXPECT_EQ(1, radio.send_starts);
EXPECT_TRUE(dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
}
TEST(Dispatcher, BeginStartsFreshCADBusyObservation) {
RxReservePacketManager manager(8, 1);
TestClock clock;
clock.now = 100;
TestRadio radio;
radio.receiving = true;
TestDispatcher dispatcher(radio, clock, manager);
dispatcher.begin();
mesh::Packet* packet = dispatcher.obtainNewPacket();
ASSERT_NE(packet, nullptr);
packet->header = ROUTE_TYPE_DIRECT | (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT);
packet->payload[0] = 0x40;
packet->payload_len = 1;
ASSERT_TRUE(dispatcher.sendPacket(packet, 0));
clock.now = 101;
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
clock.now = 10000;
dispatcher.begin();
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
EXPECT_EQ(0, dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
clock.now = 14001;
dispatcher.loop();
EXPECT_EQ(1, radio.send_starts);
EXPECT_TRUE(dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
}
TEST(Dispatcher, ImmediateReplacementStartsFreshCADBusyObservation) {
RxReservePacketManager manager(8, 1);
TestClock clock;
clock.now = 100;
TestRadio radio;
radio.receiving = true;
TestDispatcher dispatcher(radio, clock, manager);
dispatcher.begin();
auto queuePacket = [&]() {
mesh::Packet* packet = dispatcher.obtainNewPacket();
EXPECT_NE(packet, nullptr);
packet->header = ROUTE_TYPE_DIRECT | (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT);
packet->payload[0] = 0x40;
packet->payload_len = 1;
EXPECT_TRUE(dispatcher.sendPacket(packet, 0));
};
queuePacket();
clock.now = 101;
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
// There need not be an intervening Dispatcher loop with an empty queue.
// A cancellation callback can enqueue the replacement immediately.
clock.now = 10000;
manager.free(manager.removeOutboundByIdx(0));
queuePacket();
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
EXPECT_EQ(0, dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
}
TEST(Dispatcher, OtherProfilesQueuedWorkDoesNotPreserveRetiredCADWait) {
class DualProfileRadio : public TestRadio {
public:
mesh::RadioProfiles config;
DualProfileRadio() {
config.secondary.params = config.primary;
config.secondary.mode = mesh::RadioProfileMode::RxTx;
}
mesh::RadioProfiles* profiles() override { return &config; }
const mesh::RadioProfiles* profiles() const override { return &config; }
mesh::RadioParamApplyResult prepareTransmitProfile(uint8_t) override {
return mesh::RadioParamApplyResult::APPLIED;
}
} radio;
RxReservePacketManager manager(8, 1);
TestClock clock;
clock.now = 100;
radio.receiving = true;
TestDispatcher dispatcher(radio, clock, manager);
dispatcher.begin();
auto queuePacket = [&](uint8_t policy, uint32_t delay = 0) {
mesh::Packet* packet = dispatcher.obtainNewPacket();
EXPECT_NE(packet, nullptr);
packet->header = ROUTE_TYPE_DIRECT | (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT);
packet->payload[0] = 0x40;
packet->payload_len = 1;
packet->tx_radio = policy;
EXPECT_TRUE(dispatcher.sendPacket(packet, 0, delay));
};
queuePacket(mesh::RADIO_TX_SECONDARY);
clock.now = 101;
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
manager.free(manager.removeOutboundByIdx(0));
// Future work on primary keeps the whole queue nonempty, but cannot own
// the secondary profile's previous, cancelled channel wait.
queuePacket(mesh::RADIO_TX_PRIMARY, 100000);
clock.now = 10000;
queuePacket(mesh::RADIO_TX_SECONDARY);
dispatcher.loop();
EXPECT_EQ(0, radio.send_starts);
EXPECT_EQ(0, dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
}
TEST(Dispatcher, NewQueuedWorkPreservesRetainedRetryCADWait) {
RxReservePacketManager manager(8, 1);
TestClock clock;
clock.now = 100;
TestRadio radio;
radio.start_success = false;
TestDispatcher dispatcher(radio, clock, manager);
dispatcher.begin();
auto queuePacket = [&]() {
mesh::Packet* packet = dispatcher.obtainNewPacket();
EXPECT_NE(packet, nullptr);
packet->header = ROUTE_TYPE_DIRECT | (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT);
packet->payload[0] = 0x40;
packet->payload_len = 1;
EXPECT_TRUE(dispatcher.sendPacket(packet, 0));
};
queuePacket();
clock.now = 101;
dispatcher.loop();
EXPECT_EQ(1, radio.send_starts);
EXPECT_EQ(0, manager.getOutboundTotal());
radio.receiving = true;
clock.now = 302;
dispatcher.loop();
EXPECT_EQ(1, radio.send_starts);
clock.now = 5000;
queuePacket();
radio.start_success = true;
dispatcher.loop();
EXPECT_EQ(2, radio.send_starts);
EXPECT_TRUE(dispatcher.getErrFlags() & ERR_EVENT_CAD_TIMEOUT);
}
TEST(Dispatcher, SilentRadioEscalatesFromSoftToHardRecovery) {
RxReservePacketManager manager(8, 4);
TestClock clock;