More tests

This commit is contained in:
Aiden
2026-05-13 14:45:34 +10:00
parent 769e47ed67
commit 9bcc75c2e9
9 changed files with 1253 additions and 0 deletions

View File

@@ -1726,3 +1726,312 @@ python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0xB0-0xB
If any candidate changes the screen away from `CONNECT NOT ACT`, or produces a
new RCP response after the candidate stage, retest that candidate alone with
three fresh power cycles.
### 2026-05-13 Post-Discovery Sweep `00-1F` Result
Capture:
- `captures/rcp-post-discovery-b5-candidates-00-1f.txt`
Sweep setup:
```text
primer: 00 00 00 00 80 DA
query: 00 00 B5 00 80 6F
expected: 07 80 6D 20 D8 48
candidate: 00-1F
```
Screen result:
- Every candidate remained at `CONNECT NOT ACT` / `CONNECTION NOT ACT`.
- No candidate in `0x00-0x1F` moved the panel into an active state.
Serial result:
- Most candidates produced only heartbeat-compatible traffic after the candidate
frame.
- Candidate windows for `0x00`, `0x0E`, `0x0F`, `0x1A`, `0x1E`, and `0x1F`
included additional bytes matching the known discovery response
`07 80 6D 20 D8 48`.
- Those candidate-window anomalies are likely trailing/repeated discovery
response frames from the `B5` query, not new candidate-specific responses.
Notable outlier:
- During candidate `0x03`, the primer read window contained
`07 80 40 40 30 ED`, followed by heartbeat.
- This is checksum-valid, but it occurred before the `B5` query in that test
window. Treat it as an outlier until reproduced. Possible explanations include
incomplete power-cycle reset, a previous state/latch edge, or an accidental
timing artifact.
Interpretation:
- Low command range `0x00-0x1F` does not appear to contain the simple
post-discovery activation command when tested after the `B5` discovery query.
- The script's candidate read window can still catch residual discovery
response frames; candidate anomalies must be checked against the known query
response before treating them as new behavior.
Recommended next sweep:
Use a slightly longer query read window so the known discovery response has more
time to finish before the candidate frame:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0x20-0x3F" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-discovery-b5-candidates-20-3f.txt
```
If `20-3F` also keeps the screen at `CONNECT NOT ACT`, continue:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0x80-0x9F" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-discovery-b5-candidates-80-9f.txt
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0xB0-0xBF" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-discovery-b5-candidates-b0-bf.txt
```
## Post-Discovery Test Ladder
Before manually sweeping every command byte, sample representative patterns from
several command regions. The goal is to identify which command families are
worth expanding.
Use the same known discovery setup for each sample:
```text
primer: 00 00 00 00 80 DA
query: 00 00 B5 00 80 6F
RCP: 07 80 6D 20 D8 48
then: sampled candidate command
```
Power-cycle before each candidate prompt. Type any screen change, otherwise
press Enter.
### Ladder 1: Low-Range Sanity Sample
The full `00-1F` sweep did not activate the panel, but one outlier appeared
during the `0x03` test. Retest only representative low bytes plus the outlier:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0x00 0x01 0x03 0x07 0x0F 0x10 0x1B 0x1F" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-ladder-low-sample.txt
```
What this checks:
- `0x00`, `0x01`: no-op / ACK-like small commands.
- `0x03`: the outlier run produced `07 80 40 40 30 ED`.
- `0x07`, `0x0F`, `0x1F`: bit-mask/boundary values.
- `0x10`, `0x1B`: response command-family values observed in RCP frames.
### Ladder 2: Response-Command Echo Sample
Test host commands that match command bytes seen in RCP responses. If the CCU
acknowledges or advances using related command IDs, these are good candidates.
Observed RCP response command bytes so far:
```text
1B 36 40 6C 6D
```
Run:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0x1B 0x36 0x40 0x6C 0x6D" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-ladder-response-cmds.txt
```
Expand only if one of these changes screen state or produces a new
candidate-stage response.
### Ladder 3: Boundary and Bit-Pattern Sample
This tests command bytes that often mark command classes, flags, or boundaries:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0x20 0x2F 0x30 0x3F 0x40 0x4F 0x50 0x5F 0x7F 0x80 0x8F 0x90 0x9F 0xA0 0xAF 0xB0 0xBF 0xC0 0xCF 0xE0 0xEF 0xF0 0xFF" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-ladder-boundaries.txt
```
What this checks:
- Nibble/region boundaries.
- The high-bit transition at `0x80`.
- Known discovery query region around `0xB0`.
- High command space around `0xE0-0xFF`.
### Ladder 4: Known Query Region Sample
The `B0` range is known to produce discovery/status responses when used as the
selected query. It may also contain a next-stage command.
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --candidates "0xB0 0xB1 0xB2 0xB3 0xB4 0xB5 0xB6 0xB7 0xB8 0xBF" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-ladder-b-region.txt
```
If any `B` candidate changes behavior, expand locally around it rather than
sweeping the full byte space.
### Ladder 5: Alternate Discovery Response Bases
If all candidate ladders after `00 -> B5` leave the screen at `CONNECT NOT ACT`,
try the same sampled candidates after a different discovery query. Different RCP
responses may expect different follow-up ACKs.
Use `B2` discovery:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --query-command 0xB2 --candidates "0x00 0x01 0x1B 0x36 0x40 0x6C 0x6D 0x80 0xB0 0xB5 0xFF" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-ladder-after-b2.txt
```
Use `B0` discovery:
```powershell
python scripts/serial_post_discovery_sweep.py --port COM5 --query-command 0xB0 --candidates "0x00 0x01 0x1B 0x36 0x40 0x6C 0x6D 0x80 0xB0 0xB5 0xFF" --after-query 2.0 --prompt-power-cycle --prompt-screen --log captures/rcp-post-ladder-after-b0.txt
```
Interpretation:
- If a candidate only works after one discovery response, the next-stage command
may depend on the returned block.
- If the same candidate works after multiple discovery responses, it is a
stronger activation/ACK candidate.
### When to Expand
Expand a region only when one of these occurs:
- Screen changes away from `CONNECT NOT ACT`.
- RCP sends a new candidate-stage frame that is not the known discovery response
trailing into the candidate window.
- The panel begins sending different heartbeat/status frames after the
candidate.
If none of the ladder samples produce a new behavior, stop command-byte guessing
and test other frame fields for the candidate stage: state byte, value byte, or
prefix bytes.
### 2026-05-13 Ladder 1 Result and Keepalive Hypothesis
Capture:
- `captures/rcp-post-ladder-low-sample.txt`
Ladder 1 candidates:
```text
00 01 03 07 0F 10 1B 1F
```
Result:
- Every sampled candidate left the screen at `CONNECT NOT ACT`.
- Candidate-stage RX was heartbeat-compatible for all candidates.
- The earlier `0x03` outlier did not reproduce.
- Query-stage response `07 80 6D 20 D8 48` reproduced reliably before each
candidate.
Interpretation:
- The low/outlier sample did not find a post-discovery activation/ACK command.
- `CONNECT NOT ACT` may be unrelated to a one-shot ACK. It may mean the RCP sees
host traffic but is not receiving the correct ongoing CCU heartbeat/session
cadence.
Alternative working model:
```text
Host sends discovery/status query
RCP answers once
Host must then send a sustained keepalive/session heartbeat
RCP remains CONNECT NOT ACT until that heartbeat/cadence is correct
```
### Keepalive After Discovery Tests
Use `scripts/serial_keepalive_after_query.py` to test whether a sustained host
heartbeat changes the RCP state after a known discovery response.
Default setup:
```text
primer: 00 00 00 00 80 DA
query: 00 00 B5 00 80 6F
RCP reply: 07 80 6D 20 D8 48
keepalive: repeated candidate frame
```
Test K1: repeat the known primer/heartbeat shape:
```powershell
python scripts/serial_keepalive_after_query.py --port COM5 --keepalive-command 0x00 --duration 15 --interval 0.6 --prompt-screen --log captures/rcp-keepalive-after-b5-cmd00-600ms.txt
```
Test K2: repeat the zero-state frame:
```powershell
python scripts/serial_keepalive_after_query.py --port COM5 --keepalive-frame "00 00 00 00 00 5A" --duration 15 --interval 0.6 --prompt-screen --log captures/rcp-keepalive-after-b5-zero-state-600ms.txt
```
Test K3: repeat the alternate state frame:
```powershell
python scripts/serial_keepalive_after_query.py --port COM5 --keepalive-frame "00 00 00 80 00 DA" --duration 15 --interval 0.6 --prompt-screen --log captures/rcp-keepalive-after-b5-state80-600ms.txt
```
Test K4: faster primer/heartbeat cadence:
```powershell
python scripts/serial_keepalive_after_query.py --port COM5 --keepalive-command 0x00 --duration 15 --interval 0.2 --prompt-screen --log captures/rcp-keepalive-after-b5-cmd00-200ms.txt
```
Power-cycle before each keepalive test. Watch for:
- Screen changing away from `CONNECT NOT ACT`.
- Pin 4 changing from heartbeat to another recurring status frame.
- RCP controls beginning to transmit additional button/status data.
### 2026-05-13 Keepalive After Discovery Result
Captures:
- `captures/rcp-keepalive-after-b5-cmd00-600ms.txt`
- `captures/rcp-keepalive-after-b5-zero-state-600ms.txt`
- `captures/rcp-keepalive-after-b5-state80-600ms.txt`
- `captures/rcp-keepalive-after-b5-cmd00-200ms.txt`
Result:
| Test | Keepalive frame | Cadence | Screen result | Pin 4 RX |
| --- | --- | --- | --- | --- |
| K1 | `00 00 00 00 80 DA` | 0.6 s | `CONNECT NOT ACT` | heartbeat-compatible |
| K2 | `00 00 00 00 00 5A` | 0.6 s | `CONNECT NOT ACT` | heartbeat-compatible |
| K3 | `00 00 00 80 00 DA` | 0.6 s | `CONNECT NOT ACT` | heartbeat-compatible |
| K4 | `00 00 00 00 80 DA` | 0.2 s | `CONNECT NOT ACT` | heartbeat-compatible |
Interpretation:
- A simple sustained host heartbeat after `00 -> B5` does not activate the RCP.
- The RCP continues emitting only the known heartbeat-compatible stream on pin
4 during these keepalive attempts.
- The correct next stage is probably not just "repeat the primer" or "hold a
no-op frame at CCU cadence".
- The better next branch is to map additional `primer -> request` commands that
cause one-shot RCP responses. Those response blocks may reveal the command
families, status bits, or identity data needed for the later activation step.
Recommended next request sweep:
```powershell
python scripts/serial_primer_candidate_sweep.py --port COM5 --candidates "0xB1 0xB6 0xB7 0xB8 0xB9 0xBA 0xBB 0xBC 0xBD 0xBE 0xBF" --prompt-power-cycle --log captures/rcp-primer-sweep-b1-bf.txt
```
Power-cycle before each candidate prompt. This fills the gaps around the known
`B0-B5` discovery/status region and checks whether `B8-BF` contain additional
one-shot readable blocks.
If this range is quiet, continue with neighboring command regions:
```powershell
python scripts/serial_primer_candidate_sweep.py --port COM5 --candidates "0xA0-0xAF" --prompt-power-cycle --log captures/rcp-primer-sweep-a0-af.txt
python scripts/serial_primer_candidate_sweep.py --port COM5 --candidates "0xC0-0xCF" --prompt-power-cycle --log captures/rcp-primer-sweep-c0-cf.txt
```