Merge branch 'keymindCascade' of github.com:mikecarper/MeshCore into keymindCascade

# Conflicts:
#	test/test_nrf52_ble_startup.py
This commit is contained in:
mikecarper committed 2026-09-24 17:36:09 -07:00
commit bbb5c14fba
50 files changed
+3450 -261

No files matched your search

+4
View File
@@ -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"}) {
@@ -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()
+15
View File
@@ -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"
);
+21 -3
View File
@@ -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
+46 -1
View File
@@ -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__":
+5 -5
View File
@@ -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)
+48
View File
@@ -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
View File
@@ -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));
+79 -8
View File
@@ -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);
+5 -1
View File
@@ -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;