Waiting for
a byte.

First, ask a different question.

The same input device now has two connections. Input port 0 answers “Is a byte ready?” with 0 for empty or 1 for ready. Input port 1 hands over the byte itself.

IN 00H reads readiness into A. It leaves any waiting byte in the device. You can check again and again without consuming it. Only IN 01H takes the byte.

Ready now shows the device’s current answer. A shows what the CPU last read. Looking at either display does not execute an instruction or read a port.

Waiting can be work.

After reading readiness, CPI 0 compares A with zero. If the values match, the zero flag Z becomes 1. A keeps its value.

JZ 0100H means “jump to 0100 if Z is 1.” When the device was empty, the program goes back to ask again. These three instructions form a polling loop: read readiness, compare, and decide whether to repeat.

Try RUN while the device is empty. Recent instructions keeps growing its total and shows the latest twelve steps, even though no byte reaches the lamps. The processor is executing instructions while the program waits for input.

The earlier lesson’s pause before an empty input read is gone here. The program decides when to receive data. STOP pauses execution at an instruction boundary; it preserves A, the flags, and both devices.

A byte takes the other path.

Send a byte while the program is running. On its next readiness read, A becomes 1. Comparing that with zero clears Z, so JZ continues past the jump.

Now IN 01H receives the waiting byte into A, and OUT 01H sends it to the lamps. Finally, JMP 0100H returns to the readiness check. You no longer need to EXAMINE 0100 between arrivals.

The next check replaces A with a readiness answer. The output device keeps its last byte until another OUT. It can keep displaying 42 while A holds 0 and the CPU checks for more input.

As before, the device holds only one pending byte. Send becomes available as soon as the data read empties it. Another byte can wait there while the first one is still in A, about to be echoed.

Zero can be ready.

Lower every input switch and send zero. The device holds a byte, so readiness is 1. The program follows the ready path and then receives the data value 0. All the output lamps go dark when OUT sends it, and the write count increases.

Readiness and data answer different questions. An empty device and a device holding zero both return 0 from the data port, so checking the data value alone cannot tell them apart.

IN does not change flags. When the data read receives zero, Z still holds 0 from comparing the earlier readiness answer 1 with zero. Z reports the last comparison; it does not automatically describe A.

Answers belong to a moment.

Start again and step once with the device empty. A holds 0. Now send a byte before the comparison. Ready now becomes 1, but A stays 0: the previous answer does not rewrite itself.

The comparison and jump still take the empty path. On the next trip, the CPU reads readiness again and discovers the waiting byte. Nothing was lost; the program needed one more check.

Sending while stopped never starts the CPU. Choose RUN or step when you want to continue. Open Look inside the last instruction to see the actual port transfer; its recorded answer stays the same even when later input arrives.