Merge branch 'keymindCascade' of github.com:mikecarper/MeshCore into keymindCascade
# Conflicts: # test/test_nrf52_ble_startup.py
This commit is contained in:
commit
bbb5c14fba
50 files changed
+3450
-261
No files matched your search
@@ -34,6 +34,7 @@ struct Manager {
|
||||
uint8_t max_hops() const { return hops; }
|
||||
uint16_t checkpoint_blocks() const { return checkpoint; }
|
||||
uint16_t advert_mins() const { return advert; }
|
||||
float adaptivePacketSpeed() const { return 0.5f; }
|
||||
void set_autofetch(uint8_t v) { af=v; }
|
||||
void set_max_hops(uint8_t v) { hops=v; }
|
||||
void set_checkpoint_blocks(uint16_t v) { checkpoint=v; }
|
||||
@@ -53,6 +54,8 @@ static bool ota_acquire_context(char* reply, size_t cap) {
|
||||
static OtaContext& ota_ctx() { return context; }
|
||||
static OtaContext* ota_context_if_active() { return &context; }
|
||||
static void formatSpeed(char* text, size_t) { strcpy(text, "1"); }
|
||||
static float effectivePacketPace(float adaptive) { return adaptive; }
|
||||
static void formatSpeedFactor(float factor, char* text, size_t cap) { snprintf(text, cap, "%g", factor); }
|
||||
@IS_CMD@
|
||||
static bool config(const char* rest, char* reply, OtaContext& c) {
|
||||
@CONFIG@
|
||||
@@ -111,6 +114,7 @@ int main() {
|
||||
assert(!context.config_dirty);
|
||||
};
|
||||
reboot(fs);
|
||||
command("ota config", "ota config: speed=1x packet=0.5x");
|
||||
for (const auto* setting : {"hops", "checkpoint", "advert"}) {
|
||||
const auto before=OtaConfigState::capture(context);
|
||||
for (const auto* bad : {"", " ", "x", "-1", "1x", "1 2", "1.0", "4294967296", "9999999999999999999999"}) {
|
||||
|
||||
+82
-5
@@ -4,12 +4,16 @@
|
||||
|
||||
namespace policy = mesh::esp32_partition_migration;
|
||||
|
||||
TEST(Esp32PartitionMigrationPolicy, AcceptsOnlyTheKnownLegacyV4Layout) {
|
||||
TEST(Esp32PartitionMigrationPolicy, AcceptsOnlyKnownFlashSizesWithLegacyLayout) {
|
||||
EXPECT_TRUE(policy::isLegacyLayout(policy::kLegacyLayout));
|
||||
EXPECT_TRUE(policy::canMigrate(policy::kSmallRequiredFlashBytes,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_TRUE(policy::canMigrate(policy::kXiaoRequiredFlashBytes,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_TRUE(policy::canMigrate(policy::kRequiredFlashBytes,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_TRUE(policy::canMigrate(policy::kRequiredFlashBytes + 1,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_FALSE(policy::canMigrate(policy::kRequiredFlashBytes + 1,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_FALSE(policy::canMigrate(policy::kRequiredFlashBytes - 1,
|
||||
policy::kLegacyLayout));
|
||||
|
||||
@@ -33,14 +37,19 @@ TEST(Esp32PartitionMigrationPolicy, ExpandedLayoutRetainsAndGrowsSpiffs) {
|
||||
policy::kExpandedLayout.spiffs_address);
|
||||
}
|
||||
|
||||
TEST(Esp32PartitionMigrationPolicy, GenericPlansAcceptStableEightAndSixteenMiBLayouts) {
|
||||
TEST(Esp32PartitionMigrationPolicy, GenericPlansAcceptStableFourEightAndSixteenMiBLayouts) {
|
||||
EXPECT_EQ(&policy::kTarget4MB, policy::targetForFlash(4U * 1024U * 1024U));
|
||||
EXPECT_EQ(&policy::kTarget8MB, policy::targetForFlash(8U * 1024U * 1024U));
|
||||
EXPECT_EQ(&policy::kTarget16MB, policy::targetForFlash(16U * 1024U * 1024U));
|
||||
EXPECT_EQ(nullptr, policy::targetForFlash(4U * 1024U * 1024U));
|
||||
EXPECT_EQ(nullptr, policy::targetForFlash(2U * 1024U * 1024U));
|
||||
EXPECT_TRUE(policy::isTargetLayout(4U * 1024U * 1024U,
|
||||
policy::kExpanded4MBLayout));
|
||||
EXPECT_TRUE(policy::isTargetLayout(8U * 1024U * 1024U,
|
||||
policy::kExpanded8MBLayout));
|
||||
EXPECT_TRUE(policy::canMigrateGeneric(8U * 1024U * 1024U,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_TRUE(policy::canMigrateGeneric(4U * 1024U * 1024U,
|
||||
policy::kLegacyLayout));
|
||||
EXPECT_TRUE(policy::canMigrateGeneric(16U * 1024U * 1024U,
|
||||
policy::kLegacyLayout));
|
||||
|
||||
@@ -55,6 +64,71 @@ TEST(Esp32PartitionMigrationPolicy, GenericPlansAcceptStableEightAndSixteenMiBLa
|
||||
out_of_bounds));
|
||||
}
|
||||
|
||||
TEST(Esp32PartitionMigrationPolicy, LoRaResumePreservesTheOldApplicationInEitherSlot) {
|
||||
for (const auto& target : {policy::kExpanded8MBLayout,
|
||||
policy::kExpandedLayout}) {
|
||||
const auto from_a = policy::planLoRaResume(policy::kLegacyLayout, target,
|
||||
policy::kLegacyLayout.app0_address);
|
||||
EXPECT_TRUE(from_a.valid);
|
||||
EXPECT_EQ(0, from_a.bridge_slot);
|
||||
EXPECT_EQ(1, from_a.resume_slot);
|
||||
EXPECT_TRUE(from_a.copy_app1);
|
||||
EXPECT_FALSE(from_a.restore_identity_in_full);
|
||||
|
||||
const auto from_b = policy::planLoRaResume(policy::kLegacyLayout, target,
|
||||
policy::kLegacyLayout.app1_address);
|
||||
EXPECT_TRUE(from_b.valid);
|
||||
EXPECT_EQ(1, from_b.bridge_slot);
|
||||
EXPECT_EQ(0, from_b.resume_slot);
|
||||
EXPECT_TRUE(from_b.copy_app1);
|
||||
EXPECT_FALSE(from_b.restore_identity_in_full);
|
||||
}
|
||||
|
||||
auto overlapping = policy::kExpanded8MBLayout;
|
||||
overlapping.app1_address = policy::kLegacyLayout.app1_address;
|
||||
EXPECT_FALSE(policy::planLoRaResume(policy::kLegacyLayout, overlapping,
|
||||
policy::kLegacyLayout.app0_address).valid);
|
||||
EXPECT_FALSE(policy::planLoRaResume(policy::kLegacyLayout,
|
||||
policy::kExpandedLayout, 0x300000).valid);
|
||||
EXPECT_FALSE(policy::planLoRaResume(policy::kLegacyLayout,
|
||||
policy::kExpanded4MBLayout,
|
||||
policy::kLegacyLayout.app0_address).valid);
|
||||
const auto small_from_b = policy::planLoRaResume(
|
||||
policy::kLegacyLayout, policy::kExpanded4MBLayout,
|
||||
policy::kLegacyLayout.app1_address);
|
||||
EXPECT_TRUE(small_from_b.valid);
|
||||
EXPECT_EQ(1, small_from_b.bridge_slot);
|
||||
EXPECT_EQ(0, small_from_b.resume_slot);
|
||||
EXPECT_FALSE(small_from_b.copy_app1);
|
||||
EXPECT_TRUE(small_from_b.restore_identity_in_full);
|
||||
}
|
||||
|
||||
TEST(Esp32PartitionMigrationPolicy, ExpandedLoRaHandoffUsesOnlyTheOppositeSlot) {
|
||||
for (const auto& layout : {policy::kExpanded4MBLayout,
|
||||
policy::kExpanded8MBLayout,
|
||||
policy::kExpandedLayout}) {
|
||||
const auto no_record_from_a = policy::planLoRaHandoff(
|
||||
layout, layout.app0_address, 0xFF);
|
||||
EXPECT_TRUE(no_record_from_a.valid);
|
||||
EXPECT_EQ(1, no_record_from_a.other_slot);
|
||||
EXPECT_FALSE(no_record_from_a.has_record);
|
||||
|
||||
const auto no_record_from_b = policy::planLoRaHandoff(
|
||||
layout, layout.app1_address, 0xFF);
|
||||
EXPECT_TRUE(no_record_from_b.valid);
|
||||
EXPECT_EQ(0, no_record_from_b.other_slot);
|
||||
EXPECT_FALSE(no_record_from_b.has_record);
|
||||
|
||||
const auto recorded = policy::planLoRaHandoff(
|
||||
layout, layout.app1_address, 0);
|
||||
EXPECT_TRUE(recorded.valid);
|
||||
EXPECT_TRUE(recorded.has_record);
|
||||
EXPECT_FALSE(policy::planLoRaHandoff(layout, layout.app1_address, 1).valid);
|
||||
EXPECT_FALSE(policy::planLoRaHandoff(layout, layout.app0_address, 2).valid);
|
||||
EXPECT_FALSE(policy::planLoRaHandoff(layout, 0x300000, 0xFF).valid);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Esp32PartitionMigrationPolicy, GeneratedTablePrefixContainsAllSixEntriesAndMd5) {
|
||||
EXPECT_EQ(0xE0U, policy::kExpandedPartitionTablePrefixBytes);
|
||||
EXPECT_EQ(0xAA, policy::kExpandedPartitionTablePrefix[0]);
|
||||
@@ -68,6 +142,9 @@ TEST(Esp32PartitionMigrationPolicy, GeneratedTablePrefixContainsAllSixEntriesAnd
|
||||
EXPECT_EQ(0x33, policy::kExpanded8MBPartitionTablePrefix[0x4A]);
|
||||
EXPECT_EQ(0x34, policy::kExpanded8MBPartitionTablePrefix[0x66]);
|
||||
EXPECT_EQ(0x67, policy::kExpanded8MBPartitionTablePrefix[0x86]);
|
||||
EXPECT_EQ(0xC0U, policy::kExpanded4MBPartitionTablePrefixBytes);
|
||||
EXPECT_EQ(0xEB, policy::kExpanded4MBPartitionTablePrefix[0xA0]);
|
||||
EXPECT_EQ(0xEB, policy::kExpanded4MBPartitionTablePrefix[0xA1]);
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
|
||||
@@ -0,0 +1,257 @@
|
||||
"""No-hardware contract tests for the serial ESP32 migration build recipe."""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
import zipfile
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "scripts"))
|
||||
from build_esp32_partition_migration import ( # noqa: E402
|
||||
build_steps, bundle_release, verify_archive,
|
||||
)
|
||||
from package_esp32_partition_migration import ( # noqa: E402
|
||||
BOARDS, bridge_with_successor_endf, mota_full, readme,
|
||||
)
|
||||
from motalib import FwIdent, build_endf, parse_endf_ident # noqa: E402
|
||||
|
||||
|
||||
class Esp32MigrationRecipeTest(unittest.TestCase):
|
||||
def test_catalog_covers_all_three_roles_and_exact_flash_plans(self):
|
||||
self.assertEqual({"repeater", "room-server", "sensor"},
|
||||
{spec["role"] for spec in BOARDS.values()})
|
||||
self.assertIn("heltec-v4-sensor", BOARDS)
|
||||
self.assertIn("xiao-s3-wio-sensor", BOARDS)
|
||||
self.assertIn("heltec-ct62-sensor", BOARDS)
|
||||
self.assertIn("nibble-zero-room-server", BOARDS)
|
||||
self.assertEqual("esp32_c3_4mb_partition_migrator",
|
||||
BOARDS["heltec-ct62-sensor"]["wifi_bridge"])
|
||||
self.assertEqual("esp32_4mb_partition_migrator",
|
||||
BOARDS["generic-e22-sx1262-repeater"]["wifi_bridge"])
|
||||
self.assertEqual("esp32_s3_8mb_partition_migrator",
|
||||
BOARDS["heltec-v3-sensor"]["wifi_bridge"])
|
||||
self.assertEqual("heltec_v4_partition_expander",
|
||||
BOARDS["heltec-v4"]["expander_bridge"])
|
||||
self.assertEqual("Xiao_S3_WIO_partition_expander",
|
||||
BOARDS["xiao-s3-wio"]["expander_bridge"])
|
||||
self.assertEqual("esp32_8mb_partition_migrator",
|
||||
BOARDS["heltec-v2-room-server"]["wifi_bridge"])
|
||||
expected_slots = {4 * 1024 * 1024: 0x1F0000,
|
||||
8 * 1024 * 1024: 0x330000,
|
||||
16 * 1024 * 1024: 0x640000}
|
||||
env_names = set()
|
||||
for config in (ROOT / "variants").glob("*/platformio.ini"):
|
||||
env_names.update(re.findall(r"^\[env:([^]]+)\]",
|
||||
config.read_text(), re.MULTILINE))
|
||||
for board, spec in BOARDS.items():
|
||||
with self.subTest(board=board):
|
||||
self.assertIn(spec["target"], env_names)
|
||||
self.assertIn(spec["wifi_bridge"], env_names)
|
||||
self.assertIn(spec["lora_bridge"], env_names)
|
||||
if spec.get("expander_bridge"):
|
||||
self.assertIn(spec["expander_bridge"], env_names)
|
||||
self.assertEqual(expected_slots[spec["flash_bytes"]],
|
||||
spec["slot_bytes"])
|
||||
|
||||
@unittest.skipIf(os.name == "nt", "POSIX shell menu runs in WSL/Linux")
|
||||
def test_shell_menu_and_noninteractive_selection(self):
|
||||
script = str(ROOT / "scripts/build_esp32_partition_migration.sh")
|
||||
common = ["--version", "v1.17.1.7-test",
|
||||
"--radio-preset", "usa-cascadia", "--dry-run"]
|
||||
one = subprocess.run(["sh", script, "--board", "heltec-v4", *common],
|
||||
cwd=ROOT, text=True, capture_output=True, check=True)
|
||||
self.assertIn("build-firmware heltec_v4_repeater", one.stdout)
|
||||
self.assertNotIn("build-firmware Xiao_S3_WIO_repeater", one.stdout)
|
||||
self.assertNotIn("Bundle all configured board/role recipes", one.stdout)
|
||||
all_boards = subprocess.run(["sh", script, "--all", *common],
|
||||
cwd=ROOT, text=True, capture_output=True, check=True)
|
||||
self.assertIn("build-firmware Xiao_S3_WIO_repeater", all_boards.stdout)
|
||||
self.assertIn("build-firmware ThinkNode_M2_Repeater", all_boards.stdout)
|
||||
self.assertIn("Bundle all configured board/role recipes", all_boards.stdout)
|
||||
sensors = subprocess.run(["sh", script, "--role", "sensor", *common],
|
||||
cwd=ROOT, text=True, capture_output=True,
|
||||
check=True)
|
||||
self.assertIn("build-firmware Xiao_S3_WIO_sensor", sensors.stdout)
|
||||
self.assertNotIn("build-firmware Xiao_S3_WIO_repeater", sensors.stdout)
|
||||
self.assertNotIn("Bundle all configured board/role recipes", sensors.stdout)
|
||||
interactive = subprocess.run(["sh", script], input="q\n",
|
||||
cwd=ROOT, text=True, capture_output=True,
|
||||
check=True)
|
||||
self.assertIn("ESP32 in-place partition migration", interactive.stdout)
|
||||
invalid = subprocess.run(["sh", script, "--board", "unknown", *common],
|
||||
cwd=ROOT, text=True, capture_output=True)
|
||||
self.assertNotEqual(0, invalid.returncode)
|
||||
self.assertIn("not configured", invalid.stderr)
|
||||
|
||||
def test_full_images_precede_every_bridge_and_builds_are_serial(self):
|
||||
steps = build_steps(["heltec-v4", "xiao-s3-wio"], "v1.17.1.7-test",
|
||||
"usa-cascadia", "cascade", 4)
|
||||
self.assertEqual(8, len(steps))
|
||||
self.assertEqual([True, True] + [False] * 6,
|
||||
[full for _, full in steps])
|
||||
self.assertEqual("heltec_v4_repeater", steps[0][0][3])
|
||||
self.assertEqual("Xiao_S3_WIO_repeater", steps[1][0][3])
|
||||
self.assertTrue(all("--full-exact" in command for command, _ in steps[:2]))
|
||||
self.assertEqual([
|
||||
"heltec_v4_partition_migrator",
|
||||
"heltec_v4_partition_migrator_lora_repeater",
|
||||
"heltec_v4_partition_expander",
|
||||
"xiao_s3_partition_migrator",
|
||||
"xiao_s3_partition_migrator_lora_repeater",
|
||||
"Xiao_S3_WIO_partition_expander",
|
||||
], [command[3] for command, _ in steps[2:]])
|
||||
guide = readme("heltec-v4", BOARDS["heltec-v4"],
|
||||
"v1.17.1.7-test", "01234567", full_mota_blocks=960)
|
||||
self.assertIn("partition-expander.mota", guide)
|
||||
self.assertIn("automatically", guide)
|
||||
self.assertIn("already-expanded board", guide)
|
||||
|
||||
def test_4mb_roles_share_two_chip_family_bridges(self):
|
||||
steps = build_steps(["thinknode-m2-repeater", "thinknode-m2-room-server"],
|
||||
"v1.17.1.7-test", "usa-cascadia", "cascade", 4)
|
||||
self.assertEqual([True, True, False, False], [full for _, full in steps])
|
||||
self.assertEqual("ThinkNode_M2_Repeater", steps[0][0][3])
|
||||
self.assertEqual("ThinkNode_M2_room_server", steps[1][0][3])
|
||||
self.assertEqual("esp32_s3_4mb_partition_migrator", steps[2][0][3])
|
||||
self.assertEqual("esp32_s3_4mb_partition_migrator_lora", steps[3][0][3])
|
||||
guide = readme("thinknode-m2-repeater", BOARDS["thinknode-m2-repeater"],
|
||||
"v1.17.1.7-test", "01234567", full_mota_blocks=900)
|
||||
self.assertIn("old slot B", guide)
|
||||
self.assertIn("original private key from NVS", guide)
|
||||
self.assertIn("accidentally installed on a node that already has", guide)
|
||||
self.assertIn("power loss during", guide)
|
||||
self.assertIn("exact\n `Started:` URL", guide)
|
||||
self.assertIn("ota pull <id>", guide)
|
||||
large_guide = readme("heltec-v3-sensor", BOARDS["heltec-v3-sensor"],
|
||||
"v1.17.1.7-test", "01234567", full_mota_blocks=1400)
|
||||
self.assertIn("5600 bytes of proof scratch", large_guide)
|
||||
|
||||
def test_sensor_and_room_roles_share_the_8mb_bridge(self):
|
||||
steps = build_steps(["xiao-s3-wio-sensor", "xiao-s3-wio-room-server"],
|
||||
"v1.17.1.7-test", "usa-cascadia", "cascade", 4)
|
||||
self.assertEqual([True, True, False, False], [full for _, full in steps])
|
||||
self.assertEqual("Xiao_S3_WIO_sensor", steps[0][0][3])
|
||||
self.assertEqual("Xiao_S3_WIO_room_server", steps[1][0][3])
|
||||
self.assertEqual("esp32_s3_8mb_partition_migrator", steps[2][0][3])
|
||||
self.assertEqual("esp32_s3_8mb_partition_migrator_lora", steps[3][0][3])
|
||||
|
||||
def test_full_mota_can_exceed_old_seeder_scratch_limit(self):
|
||||
image = b"\xE9" + b"\0" * (1024 * 2048)
|
||||
package = mota_full(image, FwIdent(0x01020304, 0xAABBCCDD, "TEST"), 2048)
|
||||
self.assertGreater(len(package), len(image))
|
||||
|
||||
def test_bridge_mota_rebinds_preexisting_temporary_role_endf(self):
|
||||
body = b"\xe9" + b"bridge image"
|
||||
temporary = body + build_endf(body, FwIdent(1, 0x12345678, "BOARD"))
|
||||
successor = FwIdent(2, 0x87654321, "BOARD")
|
||||
rebound = bridge_with_successor_endf(temporary, successor)
|
||||
self.assertEqual(len(temporary), len(rebound))
|
||||
self.assertEqual(successor, parse_endf_ident(rebound))
|
||||
self.assertEqual(body, rebound[:-56])
|
||||
|
||||
def test_dry_run_has_no_build_side_effects(self):
|
||||
with tempfile.TemporaryDirectory(prefix="esp32-migration-plan-") as temporary:
|
||||
output_root = Path(temporary) / "release"
|
||||
result = subprocess.run([
|
||||
sys.executable, "-B",
|
||||
str(ROOT / "scripts/build_esp32_partition_migration.py"),
|
||||
"--version", "v1.17.1.7-test", "--radio-preset", "usa-cascadia",
|
||||
"--board", "heltec-v4", "--output-root", str(output_root),
|
||||
"--dry-run",
|
||||
], cwd=ROOT, text=True, capture_output=True, check=True)
|
||||
self.assertIn("build-firmware heltec_v4_repeater", result.stdout)
|
||||
self.assertIn("pio run -e heltec_v4_partition_migrator", result.stdout)
|
||||
self.assertFalse(output_root.exists())
|
||||
|
||||
def test_partition_expanders_use_adaptive_four_block_transfer_window(self):
|
||||
for variant in ("heltec_v4", "xiao_s3_wio"):
|
||||
config = (ROOT / "variants" / variant / "platformio.ini").read_text()
|
||||
expander = config.split("partition_expander]", 1)[1].split("\n[env:", 1)[0]
|
||||
self.assertIn("-D OTA_FETCH_PIPELINE=4", expander)
|
||||
|
||||
def test_archive_verification_rejects_changed_payload(self):
|
||||
with tempfile.TemporaryDirectory(prefix="esp32-migration-zip-") as temporary:
|
||||
archive_path = Path(temporary) / "test.zip"
|
||||
payload = b"correct image"
|
||||
manifest = {
|
||||
"board": "heltec-v4", "firmware_version": "v1.17.1.7-test",
|
||||
"source_commit": "01234567", "files": {
|
||||
"full-application.bin": {
|
||||
"bytes": len(payload),
|
||||
"sha256": hashlib.sha256(payload).hexdigest(),
|
||||
}
|
||||
},
|
||||
}
|
||||
with zipfile.ZipFile(archive_path, "w") as archive:
|
||||
archive.writestr("manifest.json", json.dumps(manifest))
|
||||
archive.writestr("full-application.bin", payload)
|
||||
verify_archive(archive_path, "heltec-v4", "v1.17.1.7-test", "01234567")
|
||||
with zipfile.ZipFile(archive_path, "w") as archive:
|
||||
archive.writestr("manifest.json", json.dumps(manifest))
|
||||
archive.writestr("full-application.bin", b"damaged image")
|
||||
with self.assertRaisesRegex(ValueError, "invalid full-application.bin"):
|
||||
verify_archive(archive_path, "heltec-v4", "v1.17.1.7-test", "01234567")
|
||||
|
||||
def test_all_bundle_contains_only_verified_board_packages(self):
|
||||
with tempfile.TemporaryDirectory(prefix="esp32-migration-release-") as temporary:
|
||||
output_root = Path(temporary)
|
||||
package_dir = output_root / "packages"
|
||||
package_dir.mkdir()
|
||||
version = "v1.17.1.7-test"
|
||||
source = "01234567"
|
||||
sample_boards = ["heltec-v4", "xiao-s3-wio-room-server",
|
||||
"heltec-ct62-sensor"]
|
||||
for board in sample_boards:
|
||||
payload = (board + " image").encode()
|
||||
manifest = {
|
||||
"board": board, "firmware_version": version,
|
||||
"source_commit": source, "files": {
|
||||
"full-application.bin": {
|
||||
"bytes": len(payload),
|
||||
"sha256": hashlib.sha256(payload).hexdigest(),
|
||||
}
|
||||
},
|
||||
}
|
||||
archive_path = package_dir / f"{board}-{version}-{source}-migration.zip"
|
||||
with zipfile.ZipFile(archive_path, "w") as archive:
|
||||
archive.writestr("manifest.json", json.dumps(manifest))
|
||||
archive.writestr("full-application.bin", payload)
|
||||
release = bundle_release(output_root, package_dir,
|
||||
sample_boards,
|
||||
version, source, "usa-cascadia", "cascade")
|
||||
with zipfile.ZipFile(release) as archive:
|
||||
self.assertIsNone(archive.testzip())
|
||||
release_manifest = json.loads(archive.read("release-manifest.json"))
|
||||
self.assertEqual(sample_boards,
|
||||
release_manifest["boards"])
|
||||
self.assertEqual(["repeater", "room-server", "sensor"],
|
||||
release_manifest["roles"])
|
||||
self.assertEqual("repeater",
|
||||
release_manifest["board_roles"]["heltec-v4"])
|
||||
self.assertEqual("room-server", release_manifest["board_roles"][
|
||||
"xiao-s3-wio-room-server"])
|
||||
self.assertEqual("sensor", release_manifest["board_roles"][
|
||||
"heltec-ct62-sensor"])
|
||||
for name, checks in release_manifest["packages"].items():
|
||||
data = archive.read(name)
|
||||
self.assertEqual(checks["bytes"], len(data))
|
||||
self.assertEqual(checks["sha256"], hashlib.sha256(data).hexdigest())
|
||||
self.assertEqual(release, bundle_release(
|
||||
output_root, package_dir, sample_boards,
|
||||
version, source, "usa-cascadia", "cascade"))
|
||||
(package_dir / f"heltec-ct62-sensor-{version}-{source}-migration.zip").unlink()
|
||||
with self.assertRaisesRegex(ValueError, "missing heltec-ct62-sensor"):
|
||||
bundle_release(output_root, package_dir,
|
||||
sample_boards,
|
||||
version, source, "usa-cascadia", "cascade")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -296,6 +296,21 @@ const fullUsbLogging = picker.parseTargetProfile(
|
||||
assert.strictEqual(fullUsbLogging.mode, "usb");
|
||||
assert.strictEqual(fullUsbLogging.variant, "default");
|
||||
|
||||
const partitionExpander = picker.parseTargetProfile(
|
||||
"Xiao_S3_WIO_partition_expander"
|
||||
);
|
||||
assert.strictEqual(partitionExpander.role, "partition-expander");
|
||||
assert.strictEqual(partitionExpander.hardware, "Xiao_S3_WIO");
|
||||
assert.strictEqual(partitionExpander.explicitOta, "lora-receiver");
|
||||
assert.strictEqual(picker.ROLE_LABELS[partitionExpander.role],
|
||||
"Partition Expander");
|
||||
assert(picker.installSteps(partitionExpander, "zip").some(function (step) {
|
||||
return step.includes("not an nRF52 Serial DFU package");
|
||||
}));
|
||||
assert(picker.installSteps(partitionExpander, "bin").some(function (step) {
|
||||
return step.includes("temporary bridge");
|
||||
}));
|
||||
|
||||
const heltecV4Full = picker.parseTargetProfile(
|
||||
"heltec_v4_2_v4_3_companion_radio_full_femon"
|
||||
);
|
||||
|
||||
@@ -42,6 +42,24 @@ assert_auto_unified Heltec_T190_repeater_ Heltec_T190_repeater_observer_mqtt
|
||||
assert_auto_unified LilyGo_TLora_V2_1_1_6_room_server LilyGo_TLora_V2_1_1_6_room_server_observer_mqtt_
|
||||
assert_auto_unified heltec_v4_r8_repeater_observer_mqtt heltec_v4_r8_repeater_observer_mqtt
|
||||
|
||||
# A one-board migration package must retain the old repeater's mOTA identity,
|
||||
# even when its Full sources come from the matching observer environment.
|
||||
(
|
||||
BUILD_PROFILE_OVERRIDE=full
|
||||
BUILD_PROFILE_EXPLICIT=1
|
||||
SINGLE_TARGET_FULL_BUILD=1
|
||||
EXACT_IDENTITY_FULL_BUILD=1
|
||||
RESOLVED_BUILD_TARGETS=(heltec_v4_repeater)
|
||||
configure_effective_build_profile build-firmware >/dev/null
|
||||
[ "${RESOLVED_BUILD_TARGETS[*]}" = heltec_v4_repeater ] \
|
||||
|| fail "exact Full target changed identity"
|
||||
run_logged_build_targets() {
|
||||
[ "${*}" = heltec_v4_repeater ] || fail "exact Full built a different target"
|
||||
[ "$ESP32_FULL_BUILD" = 1 ] || fail "exact Full lost expanded partitions"
|
||||
}
|
||||
run_command build-firmware >/dev/null
|
||||
)
|
||||
|
||||
# Only targets whose standard and FULL board recipes retain the exact same
|
||||
# partition table may omit their redundant portable bulk artifact.
|
||||
full_only_count=0
|
||||
@@ -157,7 +175,7 @@ done
|
||||
observed_filename=""
|
||||
observed_output=""
|
||||
build_artifacts_exist() {
|
||||
observed_filename=$2
|
||||
observed_filename=$3
|
||||
observed_output="$PACKET_LOGGING_OVERRIDE/$MQTT_BRIDGE_OVERRIDE/$MESHDEBUG_OVERRIDE/$MQTT_DEBUG_OVERRIDE"
|
||||
return 0
|
||||
}
|
||||
@@ -183,7 +201,7 @@ done
|
||||
observed_filename=""
|
||||
observed_full=0
|
||||
build_artifacts_exist() {
|
||||
observed_filename=$2
|
||||
observed_filename=$3
|
||||
observed_full=$ESP32_FULL_BUILD
|
||||
return 0
|
||||
}
|
||||
@@ -203,7 +221,7 @@ done
|
||||
FIRMWARE_FILENAME_INFIX=""
|
||||
observed_filename=""
|
||||
build_artifacts_exist() {
|
||||
observed_filename=$2
|
||||
observed_filename=$3
|
||||
return 0
|
||||
}
|
||||
build_firmware heltec_v4_r8_repeater >/dev/null
|
||||
|
||||
@@ -15,8 +15,10 @@ PROFILE = ROOT / "variants/heltec_v4/platformio.ini"
|
||||
MIGRATOR_BOARD = ROOT / "boards/heltec_v4_migrator.json"
|
||||
XIAO_PROFILE = ROOT / "variants/xiao_s3_wio/platformio.ini"
|
||||
XIAO_MIGRATOR_BOARD = ROOT / "boards/seeed_xiao_esp32s3_migrator.json"
|
||||
EXPANDER = ROOT / "examples/partition_expander/main.cpp"
|
||||
PARTITIONS = Path.home() / ".platformio/packages/framework-arduinoespressif32/tools/partitions/default_16MB.csv"
|
||||
PARTITIONS_8MB = Path.home() / ".platformio/packages/framework-arduinoespressif32/tools/partitions/default_8MB.csv"
|
||||
PARTITIONS_4MB = ROOT / "variants/dual_ota_full_4MB.csv"
|
||||
GENERATOR = Path.home() / ".platformio/packages/framework-arduinoespressif32/tools/gen_esp32part.py"
|
||||
|
||||
|
||||
@@ -54,10 +56,26 @@ class HeltecV4PartitionMigratorTest(unittest.TestCase):
|
||||
migration_body = source[source.index("void runMigration()") :]
|
||||
self.assertLess(migration_body.index("stageLegacyIdentity()"),
|
||||
migration_body.index("copyAndVerify(*running"))
|
||||
self.assertLess(migration_body.index("esp_ota_set_boot_partition(&target_app0)"),
|
||||
self.assertLess(migration_body.index("esp_ota_set_boot_partition(\n boot_in_app0 ? refs.app0 : refs.app1)"),
|
||||
migration_body.index("publishExpandedPartitionTable(*plan)"))
|
||||
self.assertLess(migration_body.index("stageLegacyConfig()"),
|
||||
migration_body.index("copyAndVerify(*running"))
|
||||
self.assertLess(migration_body.index("stageExpanderHandoff()"),
|
||||
migration_body.index("publishExpandedPartitionTable(*plan)"))
|
||||
setup_body = source[source.index("void setup()") :]
|
||||
self.assertIn("restoreStagedIdentity()", setup_body)
|
||||
self.assertIn("restoreStagedConfig()", setup_body)
|
||||
self.assertIn("verifyExpandedIdentityFile()", setup_body)
|
||||
self.assertIn('kMigrationConfigRestoredKey[] = "cfg-restored"', source)
|
||||
self.assertIn("nvs.putBool(kMigrationConfigRestoredKey, true)", source)
|
||||
self.assertIn("resumeLegacyOtaReceiver(geometry)", setup_body)
|
||||
self.assertLess(setup_body.index("restoreStagedIdentity()"),
|
||||
setup_body.index("restoreStagedConfig()"))
|
||||
self.assertLess(setup_body.index("restoreStagedConfig()"),
|
||||
setup_body.index("resumeLegacyOtaReceiver(geometry)"))
|
||||
self.assertIn("validOtherLoRaFirmware(*running, *old_receiver)", migration_body)
|
||||
self.assertIn("copyAndVerify(*refs.app1", migration_body)
|
||||
self.assertIn("stageResumeSlot(resume.resume_slot)", migration_body)
|
||||
self.assertIn("AsyncElegantOTA.begin(&server)", source)
|
||||
self.assertIn("MeshCore-Migrate", source)
|
||||
self.assertIn("DRAM_ATTR esp_partition_t copy_destination", source)
|
||||
@@ -66,6 +84,11 @@ class HeltecV4PartitionMigratorTest(unittest.TestCase):
|
||||
self.assertIn("esp_flash_erase_region(chip", source)
|
||||
self.assertIn("esp_flash_write(chip", source)
|
||||
self.assertNotIn("#include <esp_flash_internal.h>", source)
|
||||
for path in ("/com_prefs", "/node_prefs", "/s_contacts",
|
||||
"/s_login_replay", "/radio_profiles", "/regions2",
|
||||
"/com_prefs.bak", "/radio_profiles.bak", "/prefs.json",
|
||||
"/management", "/ota_speed", "/bsec_state.bin"):
|
||||
self.assertIn(path, source)
|
||||
|
||||
board = MIGRATOR_BOARD.read_text(encoding="utf-8")
|
||||
self.assertIn('"-DARDUINO_USB_CDC_ON_BOOT=0"', board)
|
||||
@@ -92,6 +115,28 @@ class HeltecV4PartitionMigratorTest(unittest.TestCase):
|
||||
embedded_8mb = bytes(int(value, 16)
|
||||
for value in re.findall(r"0x([0-9A-F]{2})", block_8mb))
|
||||
self.assertEqual(embedded_8mb, generated_8mb.read_bytes()[:len(embedded_8mb)])
|
||||
generated_4mb = Path(directory) / "default4.bin"
|
||||
subprocess.run([sys.executable, str(GENERATOR), str(PARTITIONS_4MB),
|
||||
str(generated_4mb)], check=True, capture_output=True, text=True)
|
||||
start_4mb = text.index("kExpanded4MBPartitionTablePrefix[]")
|
||||
block_4mb = text[start_4mb:text.index("};", start_4mb)]
|
||||
embedded_4mb = bytes(int(value, 16)
|
||||
for value in re.findall(r"0x([0-9A-F]{2})", block_4mb))
|
||||
self.assertEqual(0xC0, len(embedded_4mb))
|
||||
self.assertEqual(embedded_4mb, generated_4mb.read_bytes()[:len(embedded_4mb)])
|
||||
|
||||
def test_expander_pins_full_target_and_reboots_after_apply(self):
|
||||
expander = EXPANDER.read_text(encoding="utf-8")
|
||||
self.assertIn("MOTA_MIGRATION_TARGET_ID", expander)
|
||||
self.assertIn("manifest.is_full()", expander)
|
||||
self.assertIn("loadPrimaryRadio(profile)", expander)
|
||||
self.assertIn("returnToVerifiedFull()", expander)
|
||||
self.assertIn("hasExpanderHandoff()", expander)
|
||||
self.assertIn("hasVerifiedConfigHandoff()", expander)
|
||||
self.assertIn("ota.apply_fetched(message)", expander)
|
||||
self.assertIn("ota_reboot_to_apply()", expander)
|
||||
self.assertLess(expander.index("ota.apply_fetched(message)"),
|
||||
expander.index("ota_reboot_to_apply()"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -212,9 +212,9 @@ int main() {
|
||||
|
||||
class Nrf52BleStartupTest(unittest.TestCase):
|
||||
def test_reported_startup_failures_are_not_reinitialized(self):
|
||||
implementation = (ROOT / "src/helpers/nrf52/SerialBLEInterface.cpp").read_text()
|
||||
begin = method(implementation, "bool SerialBLEInterface::begin(")
|
||||
format_device_name = method(implementation, "static bool formatDeviceName(")
|
||||
serial_source = (ROOT / "src/helpers/nrf52/SerialBLEInterface.cpp").read_text()
|
||||
formatter = method(serial_source, "static bool formatDeviceName(")
|
||||
begin = method(serial_source, "bool SerialBLEInterface::begin(")
|
||||
header = (ROOT / "src/helpers/nrf52/SerialBLEInterface.h").read_text()
|
||||
# Use the real in-class startup initializers, too.
|
||||
fields = "\n".join(line for line in header.splitlines()
|
||||
@@ -224,8 +224,8 @@ class Nrf52BleStartupTest(unittest.TestCase):
|
||||
or "char _active_name" in line)
|
||||
self.assertTrue(fields)
|
||||
source = (HARNESS.replace("@BEGIN@", begin)
|
||||
.replace("@FORMAT_DEVICE_NAME@", format_device_name)
|
||||
.replace("@STARTUP_FIELDS@", fields))
|
||||
.replace("@STARTUP_FIELDS@", fields)
|
||||
.replace("@FORMAT_DEVICE_NAME@", formatter))
|
||||
with tempfile.TemporaryDirectory(prefix="meshcore-ble-start-") as temp:
|
||||
temp = Path(temp)
|
||||
(temp / "Arduino.h").write_text(RTOS)
|
||||
|
||||
@@ -2781,6 +2781,47 @@ TEST(OtaTransfer, ServerPacesOneKilobyteBlockAndProactiveProofWithBackpressure)
|
||||
EXPECT_EQ(server.pendingServeJobs(), 0u);
|
||||
}
|
||||
|
||||
TEST(OtaTransfer, SenderPacketPaceBacksOffOnDistinctLostBlocks) {
|
||||
MotaManifest manifest;
|
||||
ASSERT_TRUE(mota_parse(SIM_MOTA_1K, SIM_MOTA_1K_LEN, manifest));
|
||||
ASSERT_EQ(manifest.block_count, 3u);
|
||||
|
||||
OtaManager server;
|
||||
CapturedMessages sent;
|
||||
server.begin(0, capture_send, &sent);
|
||||
ASSERT_TRUE(server.serve(SIM_MOTA_1K, SIM_MOTA_1K_LEN));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 1.0f);
|
||||
|
||||
auto request = [&](uint16_t block, uint16_t mask) {
|
||||
ReqMsg req{};
|
||||
memcpy(req.manifest_id, manifest.merkle_root, 4);
|
||||
req.block_idx = block;
|
||||
req.want_mask = mask;
|
||||
uint8_t wire[MAX_PACKET_PAYLOAD];
|
||||
const uint16_t len = encode_req(wire, sizeof(wire), req);
|
||||
return len != 0 && server.on_message(wire, len);
|
||||
};
|
||||
|
||||
ASSERT_TRUE(request(0, 0xFFFF));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 1.0f);
|
||||
ASSERT_TRUE(request(0, 0x0001));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 0.5f);
|
||||
ASSERT_TRUE(request(0, 0x0001));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 0.5f); // same hole cannot ratchet down
|
||||
ASSERT_TRUE(request(1, 0x0001));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 0.4f);
|
||||
ASSERT_TRUE(request(0, 0x0001));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 0.3f);
|
||||
ASSERT_TRUE(request(1, 0x0001));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 0.25f); // automatic floor
|
||||
ASSERT_TRUE(request(1, 0x0001));
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 0.25f);
|
||||
|
||||
// Reinitializing a source starts with the configured maximum again.
|
||||
server.begin(0, capture_send, &sent);
|
||||
EXPECT_FLOAT_EQ(server.adaptivePacketSpeed(), 1.0f);
|
||||
}
|
||||
|
||||
TEST(OtaTransfer, LiteralLegacyFullMaskServesTwoKilobyteBlockInThirteenFragments) {
|
||||
MotaManifest manifest;
|
||||
ASSERT_TRUE(mota_parse(SIM_MOTA_2K, SIM_MOTA_2K_LEN, manifest));
|
||||
@@ -3744,6 +3785,7 @@ TEST(OtaTransfer, FlightRetriesOnlyMissingFragmentsAfterItsDeadline) {
|
||||
client.begin(SIM_TARGET_ID, capture_send, &sent);
|
||||
client.set_fetch_store(&store);
|
||||
client.set_clock(100);
|
||||
client.set_link_timing(20, 2000); // direct SF5-class link
|
||||
client.pull(manifest.merkle_root, manifest.target_id);
|
||||
sent.items.clear();
|
||||
deliver_manifest_fragment(client, manifest.merkle_root, 0,
|
||||
@@ -3752,6 +3794,10 @@ TEST(OtaTransfer, FlightRetriesOnlyMissingFragmentsAfterItsDeadline) {
|
||||
manifest.manifest_start + OTA_MF_FRAG,
|
||||
(uint16_t)(MOTA_MFL - OTA_MF_FRAG));
|
||||
ASSERT_EQ(sent.items.size(), 1u); // conservative one-block probe flight
|
||||
const uint32_t unanswered_timeout = client.fetchRetryTimeoutMs();
|
||||
EXPECT_GE(unanswered_timeout, (uint32_t)OTA_FETCH_RETRY_MIN_MS);
|
||||
client.note_rx_path_hops(0);
|
||||
EXPECT_EQ(client.fetchRetryTimeoutMs(), unanswered_timeout); // path alone is not proof of a live response
|
||||
|
||||
DataMsg first_fragment;
|
||||
memcpy(first_fragment.manifest_id, manifest.merkle_root, 4);
|
||||
@@ -3765,6 +3811,8 @@ TEST(OtaTransfer, FlightRetriesOnlyMissingFragmentsAfterItsDeadline) {
|
||||
client.on_message(wire, wire_len);
|
||||
|
||||
const uint32_t timeout = client.fetchRetryTimeoutMs();
|
||||
EXPECT_EQ(timeout, (uint32_t)OTA_FETCH_RETRY_PARTIAL_MIN_MS);
|
||||
EXPECT_LT(timeout, unanswered_timeout);
|
||||
client.set_clock(100 + timeout - 1);
|
||||
client.loop(); // no premature fixed-tick retry
|
||||
EXPECT_EQ(sent.items.size(), 1u);
|
||||
|
||||
+13
-7
@@ -20,20 +20,26 @@ int main() {
|
||||
assert(!strncmp(reply, prefix, strlen(prefix)));
|
||||
};
|
||||
beginSpeedConfig(&fs);
|
||||
command("get ota.speed", "> ota.speed=1x");
|
||||
command("get ota.speed", "> ota.speed=1x packet=1x");
|
||||
assert(handleSpeedCommand("get ota.speed", reply, sizeof reply, 0.25f));
|
||||
assert(!strcmp(reply, "> ota.speed=1x packet=0.25x"));
|
||||
assert(effectivePacketPace(0.25f) == 0.25f);
|
||||
assert(effectivePacketPace(1.0f) == 1.0f);
|
||||
for (const auto* bad : {"", "0", "-1", "0.049", "3.01", "nan", "inf", "1e0", "1abc", "1 2"}) {
|
||||
const std::string text = std::string("set ota.speed ") + bad;
|
||||
command(text.c_str(), "ERR");
|
||||
assert(speedFactor() == 1.0f && fs.files.empty());
|
||||
}
|
||||
command("set ota.speed .05", "OK ota.speed=0.05x (saved)");
|
||||
command("set ota.speed .05", "OK ota.speed=0.05x (saved) packet=0.05x");
|
||||
assert(handleSpeedCommand("get ota.speed", reply, sizeof reply, 0.25f));
|
||||
assert(!strcmp(reply, "> ota.speed=0.05x packet=0.05x"));
|
||||
assert(validSpeed(speedFactor()));
|
||||
beginSpeedConfig(&fs);
|
||||
command("get ota.speed", "> ota.speed=0.05x");
|
||||
command("ota config speed 3", "OK ota.speed=3x (saved)");
|
||||
command("ota config speed", "> ota.speed=3x");
|
||||
command("ota cfg speed 0.5", "OK ota.speed=0.5x");
|
||||
command("ota speed", "> ota.speed=0.5x");
|
||||
command("get ota.speed", "> ota.speed=0.05x packet=0.05x");
|
||||
command("ota config speed 3", "OK ota.speed=3x (saved) packet=1x");
|
||||
command("ota config speed", "> ota.speed=3x packet=1x");
|
||||
command("ota cfg speed 0.5", "OK ota.speed=0.5x (saved) packet=0.5x");
|
||||
command("ota speed", "> ota.speed=0.5x packet=0.5x");
|
||||
command("get ota.speed 1", "ERR");
|
||||
assert(!handleSpeedCommand("get ota.speed.extra", reply, sizeof reply));
|
||||
assert(!handleSpeedCommand("ota config advert 10", reply, sizeof reply));
|
||||
|
||||
@@ -51,6 +51,13 @@ assert.match(pageSource, /data-action="apply-node-clock"/);
|
||||
assert.match(pageSource, /data-role="node-clock-status"/);
|
||||
assert.match(pageSource, /data-command="primary-scheduled"/);
|
||||
assert.match(pageSource, /data-command="primary-cancel"/);
|
||||
assert.match(pageSource, /name="schedule-command-mode" value="relative" checked/);
|
||||
assert.match(pageSource, /KeyMind Cascade · <code>\+minutes<\/code>/);
|
||||
assert.match(pageSource, /name="schedule-command-mode" value="absolute"/);
|
||||
assert.match(pageSource, /data-role="absolute-clock-controls" hidden/);
|
||||
assert.match(pageSource, /class="preset-test-time-fields"/);
|
||||
assert.match(pageSource, /class="preset-test-radio-layout"/);
|
||||
assert.match(pageSource, /class="preset-test-radio-fields"/);
|
||||
assert.match(pageSource, /Simple Repeater primary radio/);
|
||||
assert.doesNotMatch(pageSource, /Stock firmware has no <code>tempradioat<\/code> command/);
|
||||
assert.doesNotMatch(pageSource, /Normal return profile/);
|
||||
@@ -61,7 +68,8 @@ const query =
|
||||
"&tz=America%2FLos_Angeles" +
|
||||
"&freq=910.1&bw=500&sf=8&cr=7";
|
||||
const config = tool.configFromSearch(query);
|
||||
const defaults = tool.configFromSearch("", "America/Los_Angeles");
|
||||
const defaultNow = Date.parse("2026-09-22T08:00:00.000Z");
|
||||
const defaults = tool.configFromSearch("", "America/Los_Angeles", defaultNow);
|
||||
|
||||
assert.strictEqual(tool.hasPresetParameters(""), false);
|
||||
assert.strictEqual(tool.hasPresetParameters("?"), false);
|
||||
@@ -107,8 +115,15 @@ assert.strictEqual(config.sf, 8);
|
||||
assert.strictEqual(config.cr, 7);
|
||||
assert.strictEqual(config.tz, "America/Los_Angeles");
|
||||
assert.strictEqual(config.tx, 22);
|
||||
assert.strictEqual(defaults.startEpoch, config.startEpoch);
|
||||
assert.strictEqual(defaults.endEpoch, config.endEpoch);
|
||||
assert.strictEqual(
|
||||
defaults.startMs,
|
||||
Date.parse("2026-09-23T17:00:00-07:00")
|
||||
);
|
||||
assert.strictEqual(
|
||||
defaults.endMs,
|
||||
Date.parse("2026-09-25T17:00:00-07:00")
|
||||
);
|
||||
assert.strictEqual(defaults.endEpoch - defaults.startEpoch, 48 * 60 * 60);
|
||||
assert.strictEqual(defaults.freq, config.freq);
|
||||
assert.strictEqual(defaults.bw, 500);
|
||||
assert.strictEqual(defaults.sf, 8);
|
||||
@@ -116,10 +131,27 @@ assert.strictEqual(defaults.cr, 7);
|
||||
assert.strictEqual(defaults.tx, 22);
|
||||
assert.strictEqual(defaults.tz, config.tz);
|
||||
assert.strictEqual(tool.isDefaultPreset(defaults), true);
|
||||
assert.strictEqual(tool.isDefaultPreset(config), true);
|
||||
assert.strictEqual(tool.presetPageTitle(defaults), "Default temporary radio test · 910.1 MHz");
|
||||
assert.match(tool.presetPageSummary(defaults), /910\.1 MHz, 500 kHz, SF8, CR7, 22 dBm/);
|
||||
assert.strictEqual(tool.presetEyebrow(defaults), "MeshCore · default 48-hour temporary preset test");
|
||||
|
||||
const dstDefault = tool.configFromSearch(
|
||||
"?tz=America%2FLos_Angeles",
|
||||
"UTC",
|
||||
Date.parse("2026-03-06T08:00:00.000Z")
|
||||
);
|
||||
assert.strictEqual(
|
||||
tool.zonedInputValue(dstDefault.startMs, dstDefault.tz),
|
||||
"2026-03-07T17:00"
|
||||
);
|
||||
assert.strictEqual(
|
||||
tool.zonedInputValue(dstDefault.endMs, dstDefault.tz),
|
||||
"2026-03-09T17:00"
|
||||
);
|
||||
assert.strictEqual(dstDefault.endMs - dstDefault.startMs, 47 * 60 * 60 * 1000);
|
||||
assert.strictEqual(tool.isDefaultPreset(dstDefault), true);
|
||||
|
||||
const requestedLink = tool.configFromSearch(
|
||||
"?start=2026-09-22T00:00:00.000Z&end=2026-09-24T00:00:00.000Z" +
|
||||
"&tz=America%2FLos_Angeles&freq=911.3&bw=500&sf=8&cr=7&tx=22"
|
||||
@@ -135,6 +167,15 @@ assert.strictEqual(
|
||||
);
|
||||
assert.strictEqual(
|
||||
tool.commandsFor(requestedLink, requestedLink.startMs).primaryScheduled,
|
||||
"set tempradioat 911.3,500,8,7,+1,+2880\nget tempradioat"
|
||||
);
|
||||
assert.strictEqual(
|
||||
tool.commandsFor(
|
||||
requestedLink,
|
||||
requestedLink.startMs,
|
||||
0,
|
||||
tool.SCHEDULE_MODE_ABSOLUTE
|
||||
).primaryScheduled,
|
||||
"set tempradioat 911.3,500,8,7,1790035200,1790208000\nget tempradioat"
|
||||
);
|
||||
|
||||
@@ -151,7 +192,8 @@ assert.deepStrictEqual(adjustedEpochs, {
|
||||
const adjustedCommands = tool.commandsFor(
|
||||
clockAdjustedLink,
|
||||
clockAdjustedLink.startMs,
|
||||
clockOffset
|
||||
clockOffset,
|
||||
tool.SCHEDULE_MODE_ABSOLUTE
|
||||
);
|
||||
assert.strictEqual(
|
||||
adjustedCommands.primaryScheduled,
|
||||
@@ -178,10 +220,12 @@ assert.throws(
|
||||
/outside the firmware range/
|
||||
);
|
||||
|
||||
const browserZoneFallback = tool.configFromSearch("", "America/New_York");
|
||||
const browserZoneFallback = tool.configFromSearch(
|
||||
"", "America/New_York", defaultNow
|
||||
);
|
||||
assert.strictEqual(browserZoneFallback.tz, "America/New_York");
|
||||
assert.strictEqual(
|
||||
tool.configFromSearch("?tz=UTC", "America/New_York").tz,
|
||||
tool.configFromSearch("?tz=UTC", "America/New_York", defaultNow).tz,
|
||||
"UTC"
|
||||
);
|
||||
assert.doesNotThrow(() => tool.validateTimeZone(tool.browserTimeZone()));
|
||||
@@ -218,7 +262,7 @@ const commands = tool.commandsFor(config, active);
|
||||
assert.strictEqual(commands.stockNow, "tempradio 910.1,500,8,7,2880");
|
||||
assert.strictEqual(
|
||||
commands.primaryScheduled,
|
||||
"set tempradioat 910.1,500,8,7,1790035200,1790208000\nget tempradioat"
|
||||
"set tempradioat 910.1,500,8,7,+1,+2880\nget tempradioat"
|
||||
);
|
||||
assert.strictEqual(commands.primaryCancel, "get tempradioat\ndel tempradioat all");
|
||||
assert.strictEqual(
|
||||
@@ -228,7 +272,7 @@ assert.strictEqual(
|
||||
assert.strictEqual(
|
||||
commands.companionScheduled,
|
||||
"set radio2.cross on\n" +
|
||||
"set tempradioat2 910.1,500,8,7,rxtx,1790035200,1790208000\n" +
|
||||
"set tempradioat2 910.1,500,8,7,rxtx,+1,+2880\n" +
|
||||
"get tempradioat2"
|
||||
);
|
||||
assert.strictEqual(commands.stockLeaveIn30, "tempradio 910.1,500,8,7,30");
|
||||
@@ -243,6 +287,33 @@ assert.strictEqual(
|
||||
"set tempradio2 910.1,500,8,7,rxtx,30"
|
||||
);
|
||||
|
||||
const absoluteCommands = tool.commandsFor(
|
||||
config,
|
||||
active,
|
||||
0,
|
||||
tool.SCHEDULE_MODE_ABSOLUTE
|
||||
);
|
||||
assert.strictEqual(
|
||||
absoluteCommands.primaryScheduled,
|
||||
"set tempradioat 910.1,500,8,7,1790035200,1790208000\nget tempradioat"
|
||||
);
|
||||
assert.strictEqual(
|
||||
absoluteCommands.companionScheduled,
|
||||
"set radio2.cross on\n" +
|
||||
"set tempradioat2 910.1,500,8,7,rxtx,1790035200,1790208000\n" +
|
||||
"get tempradioat2"
|
||||
);
|
||||
assert.doesNotThrow(() => tool.commandsFor(
|
||||
config,
|
||||
active,
|
||||
tool.SCHEDULER_EPOCH_MAX,
|
||||
tool.SCHEDULE_MODE_RELATIVE
|
||||
));
|
||||
assert.throws(
|
||||
() => tool.commandsFor(config, active, 0, "unsupported"),
|
||||
/schedule mode must be relative or absolute/
|
||||
);
|
||||
|
||||
assert.strictEqual(tool.scheduleAvailability(config, before).available, true);
|
||||
assert.strictEqual(tool.scheduleAvailability(config, active).available, false);
|
||||
assert.strictEqual(tool.primaryScheduleAvailability(config, before).available, true);
|
||||
|
||||
@@ -42,6 +42,10 @@ static volatile uint8_t state = STATE_RX;
|
||||
static uint32_t now_ms = 0;
|
||||
uint32_t millis() { return now_ms; }
|
||||
uint32_t micros() { return now_ms * 1000UL; }
|
||||
// The dedicated profile-clock contract exercises the production clock helpers.
|
||||
// This receive-state harness only needs their portable single-process behavior.
|
||||
void syncProfileClock(bool) {}
|
||||
uint32_t profileTimestamp(bool) { return micros(); }
|
||||
void noInterrupts() {}
|
||||
void interrupts() {}
|
||||
void yield() { ++now_ms; }
|
||||
@@ -62,7 +66,7 @@ struct RadioLibWrapper {
|
||||
bool _cw_active = false;
|
||||
bool serviceCarrierWave() { return false; } // dedicated CW harness owns this path
|
||||
mesh::RadioProfiles _profiles;
|
||||
uint32_t _profile_visit_us = 0;
|
||||
uint32_t _profile_visit_stamp = 0;
|
||||
uint32_t _profile_scan_generation[2] = {};
|
||||
uint8_t _active_profile = 0;
|
||||
bool _profile_rxps_suspended = false;
|
||||
|
||||
Reference in new issue
Block a user