RioSerialMonitor: --e0test mode — on-hardware E0-threshold verification
Two-phase test against a DTR-reset board: phase A forces sub-threshold retransmits (NAK the completed reply frame -> exactly one counted retransmit, then ACK the retry), where the display must hold F0000000; phase B withholds ACKs for a full give-up cycle to cross the threshold, with the expected E0 readout predicted from observed traffic. Bench findings while building it (9600, e0t5 chip): the reply-retry machine sends 5 retransmits per cycle (not 4); responses are honored only after the complete reply frame (mid-frame ACK/NAK/RESTART is ignored); once the first retry fires the cycle runs blind to give-up; a host NAK triggers an immediate counted retransmit. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Claude Fable 5
@@ -0,0 +1,273 @@
|
||||
using System.Diagnostics;
|
||||
using RioJoy.Core.Serial;
|
||||
|
||||
namespace RioSerialMonitor;
|
||||
|
||||
/// <summary>
|
||||
/// E0-threshold firmware verification (rio-firmware `--e0thresh` images).
|
||||
///
|
||||
/// Two phases against a DTR-reset board (counters zeroed, display F0000000):
|
||||
/// - Phase A (gate hold): analog requests whose reply we ACK only after the
|
||||
/// first retransmit — each event increments the board's retransmit
|
||||
/// counter ($3184) by a small sub-threshold amount, calling the display
|
||||
/// renderer every time. The _e0t5 gate must keep the display F0000000;
|
||||
/// stock firmware paints E0... at the first retry.
|
||||
/// - Phase B (flip): analog requests we never ACK — the board runs the full
|
||||
/// retry cycle (observed: 5 retransmits) and gives up ($3185++, RESTART
|
||||
/// $FE). The counters cross the threshold and the display must flip to
|
||||
/// the E0 readout, which the tool predicts from observed traffic.
|
||||
///
|
||||
/// dotnet run --project tools/RioSerialMonitor -- --e0test [port]
|
||||
/// [--baud rate] [--hold n] [--flip n]
|
||||
///
|
||||
/// No --baud probes 9600, 31250, 62500 (DTR-resetting each try). HANDS OFF
|
||||
/// buttons/keypads during the run — an unACKed button packet shifts the
|
||||
/// counters (the tool folds observed traffic into its predictions either
|
||||
/// way). Exit: 0 = ran, 2 = no board reply on any baud.
|
||||
/// </summary>
|
||||
internal static class E0Test
|
||||
{
|
||||
private const int Threshold = 5;
|
||||
|
||||
private enum AckMode { Never, Immediate, NakThenAck }
|
||||
|
||||
public static async Task<int> RunAsync(string[] args)
|
||||
{
|
||||
string port = "COM1";
|
||||
int baud = 0, holdEvents = 4, flipEvents = 1;
|
||||
for (int i = 0; i < args.Length; i++)
|
||||
{
|
||||
switch (args[i])
|
||||
{
|
||||
case "--e0test": break;
|
||||
case "--baud" when i + 1 < args.Length && int.TryParse(args[i + 1], out int b): baud = b; i++; break;
|
||||
case "--hold" when i + 1 < args.Length && int.TryParse(args[i + 1], out int h) && h >= 0: holdEvents = h; i++; break;
|
||||
case "--flip" when i + 1 < args.Length && int.TryParse(args[i + 1], out int f) && f > 0: flipEvents = f; i++; break;
|
||||
default:
|
||||
if (!args[i].StartsWith("--")) port = args[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
var sw = Stopwatch.StartNew();
|
||||
object gate = new();
|
||||
var buffer = new List<byte>();
|
||||
int cursor = 0;
|
||||
|
||||
// Reader-thread ACK automation (latency matters: the board's ACK wait
|
||||
// at 9600 is ~4ms/retry, so ACKs must not wait for a polling loop).
|
||||
AckMode ackMode = AckMode.Never;
|
||||
int replyByte = 0x87; // frame command byte the current phase expects
|
||||
int frameLen = 12; // full frame: cmd + payload + checksum
|
||||
int repliesSeen = 0; // completed frames of replyByte since phase reset
|
||||
int frameCountdown = 0; // >0: inside a reply frame, bytes remaining
|
||||
bool ackSent = false;
|
||||
|
||||
SerialPortTransport? transport = null;
|
||||
Task? reader = null;
|
||||
|
||||
void PhaseReset(AckMode mode, int expectReply, int expectLen)
|
||||
{
|
||||
lock (gate)
|
||||
{
|
||||
ackMode = mode;
|
||||
replyByte = expectReply;
|
||||
frameLen = expectLen;
|
||||
repliesSeen = 0;
|
||||
frameCountdown = 0;
|
||||
ackSent = false;
|
||||
cursor = buffer.Count;
|
||||
}
|
||||
}
|
||||
|
||||
int[] bauds = baud != 0 ? new[] { baud } : new[] { 9600, 31250, 62500 };
|
||||
(int Major, int Minor)? version = null;
|
||||
|
||||
foreach (int tryBaud in bauds)
|
||||
{
|
||||
Console.WriteLine($"[{sw.Elapsed.TotalSeconds,6:F2}s] probing {port} @ {tryBaud} (DTR reset, ~2s boot wait)...");
|
||||
try { transport = new SerialPortTransport(port, tryBaud); }
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.WriteLine($" FAILED to open {port}: {ex.GetType().Name}: {ex.Message}");
|
||||
return 2;
|
||||
}
|
||||
|
||||
lock (gate) { buffer.Clear(); cursor = 0; }
|
||||
SerialPortTransport t = transport;
|
||||
reader = Task.Run(async () =>
|
||||
{
|
||||
var tmp = new byte[256];
|
||||
try
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
int n = await t.ReadAsync(tmp, CancellationToken.None);
|
||||
if (n <= 0) break;
|
||||
byte? respond = null;
|
||||
lock (gate)
|
||||
{
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
buffer.Add(tmp[i]);
|
||||
// Frame tracking: respond only once the FULL reply
|
||||
// frame is on the wire — the board arms its
|
||||
// reply-await when the frame finishes sending; a
|
||||
// response mid-frame is ignored.
|
||||
if (frameCountdown > 0)
|
||||
{
|
||||
if (--frameCountdown > 0) continue;
|
||||
repliesSeen++;
|
||||
if (ackMode == AckMode.Immediate && !ackSent)
|
||||
{
|
||||
ackSent = true;
|
||||
respond = 0xFC;
|
||||
}
|
||||
else if (ackMode == AckMode.NakThenAck && repliesSeen <= 2)
|
||||
{
|
||||
// frame 1 -> NAK (board resends, $3184++),
|
||||
// frame 2 -> ACK (cycle ends cleanly).
|
||||
respond = repliesSeen == 1 ? (byte)0xFD : (byte)0xFC;
|
||||
ackSent = repliesSeen == 2;
|
||||
}
|
||||
}
|
||||
else if (tmp[i] == replyByte)
|
||||
{
|
||||
frameCountdown = frameLen - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (respond is byte r)
|
||||
await t.WriteAsync(new byte[] { r }, CancellationToken.None);
|
||||
}
|
||||
}
|
||||
catch { /* port closed */ }
|
||||
});
|
||||
|
||||
await Task.Delay(2000); // boot: counters cleared, display F0000000
|
||||
|
||||
PhaseReset(AckMode.Immediate, 0x86, 4); // version reply: cmd+2+ck
|
||||
await t.WriteAsync(new byte[] { 0x81, 0x01 }, CancellationToken.None);
|
||||
byte[] got = await Collect(1200, b => IndexOf(b, 0x86) >= 0);
|
||||
int vi = IndexOf(got, 0x86);
|
||||
if (vi >= 0)
|
||||
{
|
||||
if (vi + 2 < got.Length) version = (got[vi + 1], got[vi + 2]);
|
||||
baud = tryBaud;
|
||||
break;
|
||||
}
|
||||
|
||||
Console.WriteLine($" no version reply at {tryBaud}");
|
||||
transport.Dispose();
|
||||
transport = null;
|
||||
if (reader is not null) await reader;
|
||||
}
|
||||
|
||||
if (transport is null)
|
||||
{
|
||||
Console.WriteLine(" no board reply on any baud — is the board powered / the right chip in?");
|
||||
return 2;
|
||||
}
|
||||
|
||||
// Handshake bookkeeping: fold any retries/give-up into the prediction.
|
||||
await Task.Delay(300);
|
||||
byte[] hs = Drain();
|
||||
int retx = Math.Max(0, CountAll(0x86) - 1); // $3184 prediction
|
||||
int giveup = SeenAll(0xFE) ? 1 : 0; // $3185 prediction
|
||||
|
||||
Console.WriteLine();
|
||||
Console.WriteLine($"== E0-threshold test :: {transport.Description}, firmware {version?.Major}.{version?.Minor} ==");
|
||||
Console.WriteLine($" threshold {Threshold}; phase A: {holdEvents} sub-threshold event(s), phase B: {flipEvents} give-up event(s)");
|
||||
if (retx > 0 || giveup > 0)
|
||||
Console.WriteLine($" note: handshake cost {retx} retransmit(s){(giveup > 0 ? " + a give-up" : "")}; predictions include them.");
|
||||
Console.WriteLine(" HANDS OFF buttons/keypads for the whole run.");
|
||||
Console.WriteLine();
|
||||
string expected = Expected(retx, giveup);
|
||||
Console.WriteLine($">>> WATCH THE 8-DIGIT DISPLAY. It should read {expected} right now. <<<");
|
||||
await Task.Delay(4000);
|
||||
|
||||
int eventNo = 0;
|
||||
bool ok = true;
|
||||
|
||||
for (int k = 0; k < holdEvents && ok; k++)
|
||||
ok = await RunEvent(AckMode.NakThenAck, "hold");
|
||||
for (int k = 0; k < flipEvents && ok; k++)
|
||||
ok = await RunEvent(AckMode.Never, "flip");
|
||||
|
||||
Console.WriteLine();
|
||||
Console.WriteLine("== done ==");
|
||||
Console.WriteLine($" final predicted counters: retx=${retx:X2} giveup=${giveup:X2} -> display {Expected(retx, giveup)}");
|
||||
Console.WriteLine(" PASS = display held F0000000 through every sub-threshold line above and");
|
||||
Console.WriteLine(" matched the E0 predictions after the threshold crossing.");
|
||||
Console.WriteLine(" (Stock firmware flips at the very first retry.) DTR reset restores F0.");
|
||||
|
||||
transport.Dispose();
|
||||
if (reader is not null) await reader;
|
||||
return 0;
|
||||
|
||||
async Task<bool> RunEvent(AckMode mode, string phase)
|
||||
{
|
||||
eventNo++;
|
||||
PhaseReset(mode, 0x87, 12); // analog reply: cmd+10+ck
|
||||
await transport!.WriteAsync(new byte[] { 0x82, 0x02 }, CancellationToken.None);
|
||||
|
||||
byte[] bytes = mode == AckMode.Never
|
||||
? await Collect(2500, b => IndexOf(b, 0xFE) >= 0)
|
||||
: await Collect(800, _ => false);
|
||||
await Task.Delay(250); // let the cycle finish either way
|
||||
bytes = Concat(bytes, Drain());
|
||||
|
||||
int transmissions = Count(bytes, 0x87);
|
||||
bool sawRestart = IndexOf(bytes, 0xFE) >= 0;
|
||||
if (transmissions == 0)
|
||||
{
|
||||
Console.WriteLine($"[event {eventNo}] NO analog reply ({bytes.Length} bytes) — aborting.");
|
||||
return false;
|
||||
}
|
||||
|
||||
retx += Math.Max(0, transmissions - 1);
|
||||
if (sawRestart) giveup++;
|
||||
|
||||
Console.WriteLine($"[event {eventNo}] {phase}: reply x{transmissions} " +
|
||||
$"({transmissions - 1} retries), give-up={sawRestart} " +
|
||||
$"-> retx=${retx:X2} giveup=${giveup:X2}");
|
||||
Console.WriteLine($" >>> DISPLAY SHOULD NOW READ: {Expected(retx, giveup)} <<<");
|
||||
await Task.Delay(4000);
|
||||
return true;
|
||||
}
|
||||
|
||||
string Expected(int r, int g) =>
|
||||
r >= Threshold || g >= Threshold ? $"E000{r:X2}{g:X2}" : "F0000000";
|
||||
|
||||
byte[] Drain()
|
||||
{
|
||||
lock (gate)
|
||||
{
|
||||
byte[] r = buffer.Skip(cursor).ToArray();
|
||||
cursor = buffer.Count;
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
int CountAll(byte v) { lock (gate) return buffer.Count(x => x == v); }
|
||||
bool SeenAll(byte v) { lock (gate) return buffer.Contains(v); }
|
||||
|
||||
async Task<byte[]> Collect(int ms, Func<byte[], bool> done)
|
||||
{
|
||||
var end = sw.Elapsed + TimeSpan.FromMilliseconds(ms);
|
||||
var all = new List<byte>();
|
||||
while (sw.Elapsed < end)
|
||||
{
|
||||
all.AddRange(Drain());
|
||||
if (done(all.ToArray())) break;
|
||||
await Task.Delay(15);
|
||||
}
|
||||
all.AddRange(Drain());
|
||||
return all.ToArray();
|
||||
}
|
||||
|
||||
static int IndexOf(byte[] a, byte v) => Array.IndexOf(a, v);
|
||||
static int Count(byte[] a, byte v) => a.Count(x => x == v);
|
||||
static byte[] Concat(byte[] a, byte[] b) => a.Concat(b).ToArray();
|
||||
}
|
||||
}
|
||||
@@ -15,6 +15,11 @@ using RioJoy.Core.Serial;
|
||||
// --baud: 31250 for the retuned firmware variant (rio-firmware --baud31250).
|
||||
// Exit: 0 = ran, 2 = could not open the port (mash: 1 = wedge detected).
|
||||
|
||||
// E0-threshold firmware verification (rio-firmware --e0thresh images, see E0Test.cs):
|
||||
// dotnet run --project tools/RioSerialMonitor -- --e0test [port] [--baud rate] [--events n]
|
||||
if (args.Contains("--e0test"))
|
||||
return await RioSerialMonitor.E0Test.RunAsync(args);
|
||||
|
||||
if (args.Contains("--mash"))
|
||||
return await RioSerialMonitor.MashTest.RunAsync(args);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user