Correct Morse human spacing and harden speed qualification
Run Unit Tests / nrf52-companion-smoke (push) Canceled after 0s
Run Unit Tests / nrf52-sensor-smoke (push) Canceled after 0s
Run Unit Tests / esp32-sensor-smoke (push) Canceled after 0s
Run Unit Tests / management-reports (push) Canceled after 0s
Run Unit Tests / stm32-companion-smoke (push) Canceled after 0s
Run Unit Tests / bootloader-version (push) Canceled after 0s
Run Unit Tests / test (push) Canceled after 0s
Run Unit Tests / hosted-doc-links (push) Canceled after 0s
Build and deploy Docs site to GitHub Pages / github-pages (push) Canceled after 0s

This commit is contained in:
mikecarper committed 2026-10-13 05:25:07 -07:00
1 parent 378925638b
commit af08c02a00
23 files changed
+1194 -34

No files matched your search

+70
View File
@@ -0,0 +1,70 @@
#include <helpers/MorseRx.h>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <initializer_list>
#include <vector>
static_assert(sizeof(mesh::MorseRx) == 4168, "gap fix must not add receiver memory");
struct Segment { bool keyed; uint32_t duration; };
static uint32_t rounded(double value) { return uint32_t(std::lround(value)); }
static std::vector<Segment> envelope(const char* text, uint32_t nominal) {
// A bounded human-envelope model, not a replay of the sparse physical trace:
// 10% faster pace, 15% shortened gap phases, and an RF OFF-edge delay of
// roughly one tenth of a dot. Marks use +11.1% phase jitter at that pace,
// staying nominal before the same delay lengthens their measured envelope.
// This puts real letter/word quiet below 2.25/5.5 but above the 2/5 midpoints.
const double peer = nominal * 0.9;
const uint32_t bias = rounded(nominal * 0.1);
std::vector<Segment> result;
const size_t length = std::strlen(text);
for (size_t position = 0; position < length; ++position) {
if (text[position] == ' ') continue;
const uint8_t code = mesh::MorseTx::codeFor(text[position]);
assert(code);
const uint8_t symbols = mesh::MorseTx::symbolCount(code);
for (uint8_t bit = symbols; bit; --bit) {
const bool dash = ((code >> (bit - 1)) & 1) != 0;
result.push_back({true, nominal * (dash ? 3U : 1U) + bias});
if (bit > 1) result.push_back({false, nominal - bias});
}
const bool word = position + 1 == length || text[position + 1] == ' ';
result.push_back({false, rounded(peer * (word ? 7.0 : 3.0) * .85) - bias});
}
return result;
}
int main() {
constexpr const char* text = "VW MN DOG";
unsigned mismatches = 0;
for (uint8_t wpm : {25, 60, 120}) {
for (uint32_t cadence : {1U, 2U}) {
mesh::MorseRx receiver;
assert(receiver.start(wpm, 300000, 0) == mesh::MorseRxResult::Started);
uint32_t now = 0;
for (; now < 600; now += cadence) receiver.sample(-120, now);
const auto segments = envelope(text, mesh::MorseTx::unitMillis(wpm));
size_t position = 0;
uint32_t end = now + segments[0].duration;
while (position < segments.size()) {
while (now >= end && ++position < segments.size()) end += segments[position].duration;
if (position == segments.size()) break;
receiver.sample(segments[position].keyed ? -40 : -120, now);
now += cadence;
}
const uint32_t finish = now + mesh::MorseTx::unitMillis(wpm) * 8;
for (; now < finish; now += cadence) receiver.sample(-120, now);
receiver.stop(now);
const bool exact = std::strcmp(receiver.text(), "VW MN DOG ") == 0;
if (!exact) ++mismatches;
std::printf("%u\t%u\t%s\t%s\n", wpm, cadence, exact ? "PASS" : "FAIL", receiver.text());
}
}
#if REQUIRE_TIGHT_PASS
assert(mismatches == 0);
#else
assert(mismatches == 6); // the former boundaries fail every tight waveform
#endif
}
+6 -4
View File
@@ -16,10 +16,10 @@ int main() {
{"speeding20", {0, -20, 0, 2}},
{"slowing20", {0, 20, 0, 2}},
{"spacing50", {0, 0, 50, 3}},
{"mixed_speeding", {15, -10, 25, 6789}}
{"mixed_speeding", {15, -10, 25, 6789}},
{"tight_human", {20, -10, 0, 6789}}
};
constexpr const char* message = "CQ DE TEST 73 SOS";
unsigned failures = 0;
// Rates above production's 60 WPM ceiling are explicit lab-only stress
// vectors, including the fractional 5 ms phase quantization at 240 WPM.
for (uint8_t wpm : {5, 10, 15, 20, 25, 30, 40, 60, 120, 200, 240}) {
@@ -44,10 +44,12 @@ int main() {
const bool exact = strcmp(receiver.text(), "CQ DE TEST 73 SOS ") == 0;
printf("%u\t%u\t%s\t%s\t%s\n", wpm, cadence, profile.name,
exact ? "PASS" : "FAIL", receiver.text());
if (!exact) ++failures;
}
}
}
assert(mesh::setMorseHilTiming({}));
return failures ? 1 : 0;
// The Python contract checks every row byte-for-byte, including the one
// explicitly unsupported high-speed spacing/sampling combination. Keeping
// all rows lets it characterize limits without hiding them as feature passes.
return 0;
}
+128
View File
@@ -0,0 +1,128 @@
#include <helpers/MorseRx.h>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <initializer_list>
#include <limits>
using mesh::MorseRx;
#if defined(MESH_MORSE_HIL) && MESH_MORSE_HIL
static_assert(sizeof(MorseRx) == 4168 + sizeof(void*), "squelch must not add decoder fields");
#else
static_assert(sizeof(MorseRx) == 4168, "shipping decoder layout must be unchanged");
#endif
struct Receiver {
MorseRx rx;
uint32_t now = 100;
Receiver() {
assert(rx.start(25, 300000, now) == mesh::MorseRxResult::Started);
level(-120, 520);
}
void level(float dbm, uint32_t ms) {
for (uint32_t sample = 0; sample < ms; ++sample) rx.sample(dbm, now++);
}
void finish() { level(-120, 400); rx.stop(now); }
};
static void unchanged_auto_weak_signal() {
#if defined(MESH_MORSE_HIL) && MESH_MORSE_HIL
assert(mesh::setMorseHilSquelch(NAN));
#endif
Receiver weak;
weak.level(-113, 48); // valid seven-dB CW above this quiet floor
weak.finish();
assert(std::strcmp(weak.rx.text(), "E ") == 0);
}
#if defined(MESH_MORSE_HIL) && MESH_MORSE_HIL
static void setter_range_and_auto() {
assert(std::isnan(mesh::morseHilSquelch())); // default AUTO, no saved setting
for (float value : {-160.0f, -100.0f, 0.0f}) {
assert(mesh::setMorseHilSquelch(value));
assert(mesh::morseHilSquelch() == value);
}
assert(mesh::setMorseHilSquelch(-100));
for (float invalid : {-160.01f, 0.01f,
std::numeric_limits<float>::infinity(),
-std::numeric_limits<float>::infinity()}) {
assert(!mesh::setMorseHilSquelch(invalid));
assert(mesh::morseHilSquelch() == -100);
}
assert(mesh::setMorseHilSquelch(NAN));
assert(std::isnan(mesh::morseHilSquelch()));
}
static void quiet_prekey_cannot_absorb_the_real_dot() {
assert(mesh::setMorseHilSquelch(NAN));
Receiver automatic;
automatic.level(-111, 100); // measured-style quiet excursion keys prematurely
assert(automatic.rx.keyed());
automatic.level(-40, 48);
automatic.finish();
assert(std::strcmp(automatic.rx.text(), "T ") == 0); // one false long mark, not a real dash
assert(mesh::setMorseHilSquelch(-100));
Receiver bounded;
bounded.level(-111, 100);
assert(!bounded.rx.keyed() && bounded.rx.length() == 0);
bounded.level(-40, 48);
bounded.finish();
assert(std::strcmp(bounded.rx.text(), "E ") == 0); // reject RF noise before symbol recording
}
static void measured_style_quiet_is_empty_without_transcript_filtering() {
assert(mesh::setMorseHilSquelch(NAN));
Receiver automatic;
for (unsigned pulse = 0; pulse < 8; ++pulse) {
automatic.level(-111, 100);
automatic.level(-120, 320);
}
automatic.finish();
assert(automatic.rx.length() > 0); // negative control proves the fixture crosses AUTO
assert(mesh::setMorseHilSquelch(-100));
Receiver bounded;
for (unsigned sample = 0; sample < 5000; ++sample) {
const float dbm = sample % 109 < 40 ? -106 : (sample % 3 ? -115 : -124);
bounded.level(dbm, 1);
assert(!bounded.rx.keyed() && bounded.rx.length() == 0);
}
bounded.finish();
assert(bounded.rx.length() == 0 && !bounded.rx.truncated());
}
static void falling_floor_has_three_db_hysteresis() {
assert(mesh::setMorseHilSquelch(-100));
Receiver bounded;
bounded.level(-99, 48);
assert(bounded.rx.keyed());
bounded.level(-102, 20); // below the ON floor, but still above its -103 OFF floor
assert(bounded.rx.keyed());
bounded.level(-104, 15);
assert(!bounded.rx.keyed());
bounded.finish();
assert(std::strcmp(bounded.rx.text(), "E ") == 0);
// The bound is deliberately optional: enabling it rejects weaker real CW,
// then AUTO returns the exact existing weak-signal behavior, not a new gate.
Receiver weak;
weak.level(-113, 48);
weak.finish();
assert(weak.rx.length() == 0);
unchanged_auto_weak_signal();
}
#endif
int main() {
#if defined(MESH_MORSE_HIL) && MESH_MORSE_HIL
setter_range_and_auto();
quiet_prekey_cannot_absorb_the_real_dot();
measured_style_quiet_is_empty_without_transcript_filtering();
falling_floor_has_three_db_hysteresis();
#endif
unchanged_auto_weak_signal();
std::puts("actual squelch checks passed");
}
+9 -9
View File
@@ -109,13 +109,13 @@ static void fractional_gap_comparisons() {
rx._last_edge = 100;
rx._code = 2;
rx._symbols = 1;
rx.flushGap(108);
assert(rx.length() == 0); // eight ms is still shorter than two fractional units
rx.flushGap(109);
assert(rx.length() == 0); // nine ms is still shorter than 2.25 fractional units
rx.flushGap(110);
assert(std::strcmp(rx.text(), "E") == 0);
rx.flushGap(122);
assert(std::strcmp(rx.text(), "E") == 0); // 22 ms is shorter than 5.5 fractional units
rx.flushGap(123);
rx.flushGap(120);
assert(std::strcmp(rx.text(), "E") == 0); // 20 ms is shorter than five fractional units
rx.flushGap(121);
assert(std::strcmp(rx.text(), "E ") == 0);
begin(rx, 240);
@@ -123,13 +123,13 @@ static void fractional_gap_comparisons() {
rx._last_edge = 100;
rx._code = 2;
rx._symbols = 1;
rx.flushGap(111);
rx.flushGap(109);
assert(rx.length() == 0);
rx.flushGap(112);
rx.flushGap(110);
assert(std::strcmp(rx.text(), "E") == 0);
rx.flushGap(127);
rx.flushGap(124);
assert(std::strcmp(rx.text(), "E") == 0);
rx.flushGap(128);
rx.flushGap(125);
assert(std::strcmp(rx.text(), "E ") == 0);
}