Worked examples — SpaceWire — high-speed serial link standard for spacecraft

This page is a drill floor. The parent note built the machinery; here we run it through every kind of input it can meet — the boring middle, the weird edges, and the exam traps.

Before a single formula, one promise: we will only use symbols you already own from the parent note. If we need something new, we build it in plain words first.

---

The scenario matrix

Every problem SpaceWire throws at you falls into one of these case classes. Each column is a lever that can be pushed to an extreme, and each extreme breaks a naive formula in its own way.

Case class	The lever being pushed	Example that covers it
DS encoding — normal run	mixed bits, both lines toggle	Example 1
DS encoding — degenerate	a run of identical bits (Data flat)	Example 2
Parity — odd vs even count	number of 1-bits is odd, then even	Example 3
Parity — all-zero / all-one	the two extreme bytes	Example 4
Wormhole vs store-forward — long packet	many cargo bytes	Example 5
Wormhole — tiny packet limit	cargo → 0 (header only)	Example 6
Flow control — short cable	RTT small, buffer easy	Example 7
Flow control — long cable (real world)	RTT large, credits scarce	Example 8
Exam twist — mixed units / trap	Mbps vs MB, ns vs μs	Example 9

Read the table as: "what could go wrong?" A run of identical bits kills the Data line's timing. An all-zero byte makes parity feel trivial (it isn't). A zero-length packet makes the latency formula collapse to just the header. Each example below is tagged with its cell.

---

Warm-up: the two tools we reuse

Recall The two invariants (from the parent note)

Data-Strobe rule — exactly one of the two lines changes each bit period: $\text{RecoveredClock}(n)=\text{Data}(n)\oplus \text{Strobe}(n)$ where $\oplus$ means XOR (1 if the two inputs differ, 0 if they match).

Latency of a wormhole route: $L_{\text{total}}=n\times L_{\text{hop}}+L_{\text{body}}$ $n$ = number of hops (switches), $L_{\text{hop}}$ = per-switch delay, $L_{\text{body}}$ = time to stream the payload at line rate.

Keep these two in view. Half the examples are just these formulas pushed to an edge.

---

Example 1 — DS encoding, normal run

Forecast first: guess how many times Strobe toggles over these 5 bits. (Hint: it toggles only when Data does not.)

Steps.

1. Data line = the bit value itself. So Data walks through $0\to 1\to 0\to 0\to 1\to 1$ (the leading 0 is our starting state, then the 5 bits). Why this step? The parent note's whole point: Data is not encoded, it is $b_n$. The cleverness lives in Strobe.

2. Strobe rule: Strobe changes exactly when Data did not change. Compare each bit to the one before:

   • $0\to 1$ (bit 1): Data changed → Strobe holds.
   • $1\to 0$ (bit 2): Data changed → Strobe holds.
   • $0\to 0$ (bit 3): Data same → Strobe toggles.
   • $0\to 1$ (bit 4): Data changed → Strobe holds.
   • $1\to 1$ (bit 5): Data same → Strobe toggles. Why this step? This guarantees "exactly one line moves per bit," which is the timing anchor.

3. Tabulate (Data, Strobe) after each bit, starting from (0,0):

bit#	$b_n$	Data	Strobe	who toggled
1	1	1	0	Data
2	0	0	0	Data
3	0	0	1	Strobe
4	1	1	1	Data
5	1	1	0	Strobe

Look at the figure: the top trace is Data, the middle is Strobe, and the bottom red trace is the recovered clock $\text{Data}\oplus \text{Strobe}$ — one clean edge per bit.

Verify: Strobe toggled exactly on bits 3 and 5 (the two "same as previous" cases) → 2 toggles, matching the forecast. In every column, exactly one of {Data, Strobe} changed. ✓

---

Example 2 — DS encoding, degenerate run of identical bits

Forecast: if we sent only the Data line, what would the receiver see across four identical 1s? (Answer: a flat line — no edges, no timing.)

Steps.

1. Data line is flat. For $1,1,1,1$ starting from Data$=0$: it rises once ($0\to 1$) then stays at 1. After the first bit there are zero Data transitions. Why this step? This is exactly the disaster DS was invented to fix — a long run of identical bits erases timing on a single wire.

2. Strobe carries all the timing now. Every bit here is "same as previous," so Strobe toggles on bits 2, 3, 4. Why this step? The invariant forces Strobe to move whenever Data can't, so no bit period is silent.

3. Recovered clock $=\text{Data}\oplus \text{Strobe}$ still ticks once per bit, because in every period one line moved.

Look at the figure: Data (top) is flat while Strobe (middle) does the work; the recovered clock (red) still shows four edges.

Verify: number of edges on the recovered clock over 4 bits = 4 (one per bit) despite Data being flat. Timing preserved. ✓

---

Example 3 — Parity, odd bit-count byte

Forecast: count the 1s by eye. Odd or even? That single fact decides both parity bits.

Steps.

1. List all eight bits $D_7\dots D_0=1,0,1,0,0,1,1,1$. Count the ones: $5$. Why this step? The classic trap (flagged in the parent note) is counting only six bits. You must XOR all eight.

2. XOR all eight — XOR-of-bits equals the parity of the count: $5$ ones is odd → XOR $=1$. Why this step? XOR is just "is the number of 1s odd?" packaged as one bit.

3. Choose parity bits:

   • Even parity wants an even total → $P_{\text{even}}=1$ (making six ones).
   • Odd parity wants an odd total → $P_{\text{odd}}=0$ (leaving five ones). Why this step? Parity picks the bit that forces the group into the target parity.

Verify: with $P_{\text{even}}=1$, total ones $=6$ (even ✓). With $P_{\text{odd}}=0$, total ones $=5$ (odd ✓). ✓

---

Example 4 — Parity, the two extreme bytes

Forecast: all-zeros feels like "no information" — does parity even do anything? And eight ones — even or odd?

Steps.

1. 0x00: zero ones → XOR $=0$. Even parity $P=0$; odd parity $P=1$. Why this step? Even the all-zero byte gets protected — a flipped bit becomes a lone 1 and breaks the expected parity.

2. 0xFF: eight ones, which is even → XOR $=0$. Even parity $P=0$; odd parity $P=1$. Why this step? Eight is even, so 0xFF behaves like 0x00 for parity — a common exam surprise (people expect "all ones = odd").

Verify: XOR(0x00) $=0$ and XOR(0xFF) $=0$. Both need odd-parity bit $P=1$ and even-parity bit $P=0$. ✓

---

Example 5 — Wormhole vs store-and-forward, long packet

Forecast: guess the ratio. Long packet + many hops should hugely favour wormhole.

Steps.

1. Body streaming time at line rate: $L_{\text{body}}=\frac{512\times 8}{200\times 10^6}\text{s}=20.48\mu s$. Why this step? Bits-per-byte is 8; dividing bits by bits-per-second gives seconds.

2. Store-and-forward: each of the 4 switches must receive the whole packet before forwarding → $4\times 20.48=81.92\mu s$. Why this step? No parallelism — each hop pays the full body time.

3. Wormhole: the header carves the path in $4\times L_{\text{hop}}=4\mu s$, then the body streams through the already-open pipe once: $4+20.48=24.48\mu s$. Why this step? Body bytes are in the wire while the header is still advancing — the parallelism the parent note stressed.

Verify: ratio $=81.92/24.48\approx 3.35\times$ faster. Store-forward $=81.92\mu s$, wormhole $=24.48\mu s$. ✓

---

Example 6 — Wormhole limit: header-only packet

Forecast: as cargo $\to 0$, the latency formula should collapse to only the hop term.

Steps.

1. Body time $\to 0$: with essentially no cargo, $L_{\text{body}}\approx 0$. Why this step? This is the degenerate limit — it isolates the per-hop cost.

2. Latency $=n\times L_{\text{hop}}+0=6\times 1\mu s=6\mu s$. Why this step? Confirms the formula degrades gracefully; there's no hidden minimum-packet penalty in the wormhole model itself.

Verify: $L_{\text{total}}=6\mu s$, dominated entirely by hop latency — exactly the limiting behaviour we predicted. ✓

---

Example 7 — Flow control, short cable

Forecast: short cable ⇒ credits return fast ⇒ tiny buffer. Guess whether one FCT (8 characters) is already enough.

Steps.

1. One-way delay $=\frac{1\text{m}}{2\times 10^8\text{m/s}}=5\text{ns}$. Why this step? Distance ÷ speed = time; this is how long a bit takes to physically travel the cable.

2. RTT $=2\times 5=10\text{ns}$ (credit must come back). Why this step? Credit is only useful after it travels there and back.

3. Bytes in flight $=\frac{100\times 10^6\times 10\times 10^{-9}}{8}=0.125$ bytes. Why this step? Bits-in-flight = rate × RTT; divide by 8 for bytes.

4. Compare to one FCT (grants 8 characters). $0.125\ll 8$, so a single FCT keeps this link permanently full. Why this step? Answers the practical question: short cables never stall.

Verify: in-flight $=0.125$ bytes, far below the 8-character credit of one FCT. No stall. ✓

---

Example 8 — Flow control, long cable (real world)

Forecast: longer cable ⇒ bigger RTT ⇒ more credit needed. Will one FCT still cut it?

Steps.

1. One-way $=\frac{30}{2\times 10^8}=150\text{ns}$; RTT $=300\text{ns}$. Why this step? Same physics as Example 7, scaled up 30×.

2. Bytes in flight $=\frac{200\times 10^6\times 300\times 10^{-9}}{8}=7.5$ bytes. Why this step? Rate × RTT ÷ 8. This is the buffer you must have outstanding to avoid stalling.

3. Credits needed: each FCT $=8$ characters, so we need $\lceil 7.5/8\rceil =1$ FCT... but at the boundary. Doubling the harness or the rate would tip us over 8 → 2 FCTs. Why this step? Shows why longer/faster links demand more outstanding credit — the RTT-bandwidth product is the design driver named in the parent note.

Verify: in-flight $=7.5$ bytes; $\lceil 7.5/8\rceil =1$ FCT (just barely). ✓

---

Example 9 — Exam twist: the unit trap

Forecast: the trap is b (bits) vs B (bytes) and M meaning $10^6$. Guess the answer's order of magnitude.

Steps.

1. Convert the image to bits. $1\text{MB}=10^6$ bytes $=8\times 10^6$ bits. Why this step? Mbps counts bits per second; the payload is quoted in bytes. Mixing them is the classic exam kill.

2. Divide by rate. $\frac{8\times 10^6\text{bits}}{400\times 10^6\text{bits/s}}=0.02\text{s}=20\text{ms}$. Why this step? Bits ÷ bits-per-second = seconds. Units cancel cleanly, which is your correctness signal.

3. Sanity check the magnitude. 400 Mbps = 50 MB/s; $1\text{MB}/50\text{MB/s}=0.02\text{s}$. Same answer via bytes. Why this step? Two independent routes agreeing means no factor-of-8 slip.

Verify: $8\times 10^6/(400\times 10^6)=0.02$ s $=20$ ms, and $1/50=0.02$ s. ✓

---

Recall check

Related reading: Wormhole Routing vs Store-and-Forward, LVDS Signaling, RMAP Protocol, Real-Time Determinism, Cosmic Ray Effects on Electronics.