Ethernet (IEEE 802.3) — CSMA - CD, frame format: Visual walkthrough

This walkthrough belongs to the Ethernet topic note. It leans on one idea worth revisiting first: Propagation Delay vs Transmission Delay.

Step 1 — The wire, and the two words "delay"

WHAT: Draw the whole world of shared Ethernet: one straight cable, with a station at each end. Call them A (left) and B (right).

WHY: Everything that follows is a race between two clocks, so we must first name the two kinds of time. They are not the same thing and mixing them up is the classic mistake.

Propagation delay $T_{p}$ = how long one bit takes to travel from A to B down the cable. This is set by distance and the speed of the signal — nothing to do with how fast you type.
Transmission delay $T_{t r an s mi t}$ = how long it takes A to push the whole frame onto the wire, from the first bit to the last. This is set by how many bits and how fast the wire accepts them.

PICTURE:

Figure — Ethernet (IEEE 802.3) — CSMA - CD, frame format

Step 2 — Push-time is bits ÷ speed

WHAT: Write down $T_{t r an s mi t}$ from scratch.

WHY: Later we will demand "A must still be talking when the echo comes back." Still talking means $T_{t r an s mi t}$ is big enough. So we need $T_{t r an s mi t}$ as a formula in the things we control — the number of bits $L$ and the wire speed $B$ .

PICTURE:

Think of a hose that emits $B$ bits every second. To empty a bucket of $L$ bits:

$T_{t r an s mi t} = how many bits L \div bits pushed per second B = \frac{L}{B}$

$L$ on top: more bits → longer to send. Doubling the frame doubles the time. ✔ matches intuition.
$B$ on bottom: a faster wire → shorter time. Doubling the speed halves the time. ✔

Step 3 — The worst-case collision, told as a story

WHAT: Walk the single nastiest timing, moment by moment, on a time-goes-downward diagram.

WHY: A collision can happen in many ways, but only the worst one decides the rule. If our frame survives the worst case, it survives all easier cases. So we hunt for the maximum time a collision can hide from the sender.

PICTURE:

Read the figure top to bottom:

$t = 0$ — A senses the wire idle and starts sending. Its signal begins crawling rightward.
$t = T_{p}^{-}$ (a whisker before $T_{p}$ ) — the signal is almost at B. B still hears silence, so from B's point of view the wire is idle. B legally starts sending too. This is the trap: B did nothing wrong.
$t = T_{p}$ — the two signals meet at B. B detects the collision instantly (it is right there). B stops.
$t = 2 T_{p}$ — B's garbled signal has now travelled all the way back to A. Only now does A learn of the collision.

So the collision took almost the full round trip, $2 T_{p}$ , to reach the original sender A.

Step 4 — The rule: "still talking when the echo returns"

WHAT: Turn the story into one inequality.

WHY: Collision Detection only works if A is still transmitting at the moment $t = 2 T_{p}$ when the garble arrives. If A already finished and went quiet, A thinks "sent fine!" while its frame was actually shredded on the wire. A silent sender cannot detect a collision.

PICTURE:

The figure lays A's sending-window against the round-trip clock. The window must reach at least as far as the echo:

$how long A talks T_{t r an s mi t} \geq time for echo to return 2 T_{p}$

Left side: the length of A's talking window.
Right side: the deadline — the echo's arrival at $2 T_{p}$ .
$\geq$ (not $>$ ): touching exactly is allowed; A is still transmitting the final instant.

Step 5 — Substitute and solve for the frame length

WHAT: Put Step 2's formula into Step 4's rule and isolate $L$ .

WHY: The rule is about time, but a frame designer controls bits. We convert the time condition into a bits condition, because "make the frame at least this many bits" is something you can actually enforce.

PICTURE:

Start from the rule, replace $T_{t r an s mi t}$ with $L / B$ :

$\frac{L}{B} \geq 2 T_{p}$

Multiply both sides by $B$ (safe: $B > 0$ , a positive speed, so the $\geq$ does not flip):

$L \geq 2 T_{p} B$

The smallest $L$ that still obeys this is the boundary itself:

$L_{min} = 2 T_{p} B$

$2$ ::: because the collision must travel there and back (Step 3).
$T_{p}$ ::: one-way travel time — bigger cable or slower signal → longer frame needed.
$B$ ::: faster wire pushes bits out quicker, so you need more bits to keep talking the same duration.

Step 6 — Plug in real 10 Mbps Ethernet: the 512-bit number

WHAT: Feed the classic numbers in.

WHY: A formula you can't ground in a real value is just decoration. 10 Mbps Ethernet was defined with a worst-case round trip of $2 T_{p} \approx 51.2 μ s$ (the longest legal cable run, including repeaters).

PICTURE:

$L_{min} = B bits/s 10 \times 1 0^{6} \times 2 T_{p} seconds 51.2 \times 1 0^{- 6} = 512 bits$

Convert bits to bytes (8 bits each):

$512 bits \div 8 = 64 bytes$

That is the famous 64-byte minimum Ethernet frame, appearing not by decree but forced by the round-trip physics.

Step 7 — The jam signal: making sure everyone hears the crash

WHAT: After a station detects a collision, it does not just fall silent. It first transmits a short, deliberate burst of noise — the 32-bit jam sequence — and then stops.

WHY: When A detects the collision at $t = 2 T_{p}$ , the garble has only just reached A. A brief 32-bit jam guarantees the collision signal on the wire is long and loud enough that every station — even ones that only started a hair ago — is certain to register a collision and back off. Without the jam, a station could catch a collision so fleeting it doesn't reliably notice, and might charge ahead thinking its frame was fine. The jam turns "a maybe-collision" into "an unmistakable collision for all."

PICTURE:

The jam is 32 bits — small compared to the 512-bit minimum frame, so it costs almost nothing.
It works hand in hand with the minimum-frame rule: the minimum frame guarantees the sender is still transmitting when the collision arrives (so it can detect at all); the jam then guarantees the detection is broadcast clearly to everyone before backoff begins.
Only after the jam does the station run binary exponential backoff and retry.

Step 8 — Degenerate & edge cases (never leave a gap)

WHAT: Test the formula at its extremes so no reader hits an unshown scenario.

WHY: A rule you only believe in the "normal" middle is a rule you don't understand. Push it to zero, to infinity, and to "what if the frame is shorter anyway."

PICTURE:

Case	What happens to $L_{min} = 2 T_{p} B$	Meaning
Cable length → 0 ( $T_{p} \to 0$ )	$L_{min} \to 0$	Both stations at the same point hear each other instantly; no minimum needed. The echo is immediate.
Bandwidth $B$ doubles	$L_{min}$ doubles	Faster wire empties the bucket quicker, so you must add bits to stay talking through the round trip. (Gigabit Ethernet fixes this with "carrier extension" instead.)
Frame shorter than $L_{min}$ (padding fails)	A finishes at $T_{t r an s mi t} < 2 T_{p}$	A goes silent before the echo — collision undetected, frame lost silently. This is the failure the whole rule exists to prevent.
Only one station ever transmits	rule still holds	No collision occurs, but you cannot know that in advance, so every frame still obeys the minimum, just in case.

The one-picture summary

Everything above, compressed: the round-trip journey ( $2 T_{p}$ ) sets a time floor; time-times-bandwidth turns that into a bits floor ( $2 T_{p} B$ ); real 10 Mbps numbers turn that into 512 bits = 64 bytes (counted DA → FCS, not the preamble); and the 46-byte minimum data field is just what's left after the fixed headers eat their share:

$Dest 6 + Src 6 + Len 2 + Data 46 + FCS 4 = 64 bytes$

Recall Feynman: the whole walkthrough in plain words

One wire, two people at opposite ends. Alice shouts first. Sound needs time to cross the room, so just before her voice reaches Bob, Bob — hearing nothing — shouts too. Their voices smash together near Bob. Bob knows instantly. But Alice only learns when the noise crawls all the way back — that's the round trip, twice the one-way time. Here's the catch: Alice can only notice the crash if she's still shouting when the noise returns. If her sentence was too short, she's already gone quiet and walks off thinking all is well — while her message was actually destroyed. So every message must last at least one round trip. The moment Alice hears the crash, she shouts a quick "STATIC!" (the 32-bit jam) so everyone is sure to stop, then both roll dice for how long to wait. On real 10 Mbps wire the "at least one round trip" arithmetic lands on exactly 64 bytes — counted from the address fields to the checksum, not the warm-up preamble in front of it. Not a magic number — just the shortest sentence long enough to hear your own crash.

Connections

Propagation Delay vs Transmission Delay — the two clocks whose race this whole page is about.
ALOHA and Slotted ALOHA — the ancestor with no carrier sense, and no such minimum-frame rule.
CSMA-CA — wireless cousin that avoids collisions because you can't listen while sending on radio.
Switched vs Shared Ethernet — modern full-duplex links remove collisions, retiring this minimum's original reason.