Foundations — Registers and shift registers

Before you can trust a single line of the parent note, you need to know exactly what each little symbol means and what it looks like. Below is every symbol and idea the topic silently assumes, built up one at a time. Nothing is used before it is drawn.

0. A bit — the smallest thing we store

Why do we start here? Because a register's whole job is to hold bits still and a shift register's job is to move bits sideways. If a "bit" is fuzzy in your head, every arrow later is fuzzy too.

Look at the two chalk switches: the left one is down (this is $0$), the right one is up (this is $1$). A wire in a real circuit carries a low voltage for $0$ and a high voltage for $1$ — the switch is a picture of that wire.

1. A word — several bits standing in a row

What each position is worth. Let us name the four bits of a word by a single letter with a small position number attached: $b_3{b}_2{b}_1{b}_0$. The small number is just a position index — it says which slot the bit sits in (leftmost is slot 3, rightmost is slot 0). We use a neutral letter $b$ here on purpose: it means "a bit sitting in a word", nothing more. (In §3 we will meet the letter $Q$, which will specifically mean "the bit a memory box is showing"; keeping them apart now avoids confusion later.) Reading right-to-left, each step left is worth twice as much:

$\text{value}=b_3\cdot 8+b_2\cdot 4+b_1\cdot 2+b_0\cdot 1$

The $8,4,2,1$ are the powers of two $2^3,2^2,2^1,2^0$. This is why shifting sideways multiplies or divides by two — you will meet that idea below.

2. MSB and LSB — the two ends of a word

Why give the ends names? Because "shift" needs a direction, and directions are described by which end a bit enters and which end it falls off. "Serial In goes into the MSB" only makes sense once you know which end that is.

The pale-yellow labels mark each position's weight. Notice the weights double as you move from the LSB (right) toward the MSB (left) — that doubling is the whole reason a left shift means "$\times 2$".

3. The flip-flop, and its letters $D$ and $Q$

Picture the box with a wire coming in on the left labelled $D$ and a wire leaving on the right labelled $Q$. $D$ = "what I want to store", $Q$ = "what I have stored". They are usually different for a moment, then the flip-flop copies $D$ into $Q$.

The parent note's atom equation

$Q_{\text{next}}=D$

now reads in plain words: "the value I will show next is whatever is being offered at $D$ right now." The subscript "next" means after the clock ticks — which brings us to the clock. Note that $Q$ (a flip-flop's stored bit) is a more specific thing than the plain $b$ we used in §1: every $Q$ is a bit, but it is a bit that lives inside a memory box.

4. The subscript $i$ — labelling boxes in a row

Why an index instead of drawing every box? Because writing one line with $i$ in it once describes what happens in every flip-flop at the same time — it is a compact promise about the whole row. Without $i$ you would have to write a separate line for a 32-bit register 32 times.

The boundary problem — what feeds the first box? When each flip-flop copies its neighbour, $Q_i^{\text{next}}=Q_{i-1}$, the very first flip-flop ($i=0$) has no neighbour before it: there is no $Q_{-1}$. So we must define where its input comes from by hand. That extra wire is the Serial In, and the bit that drops off the far end is the Serial Out:

5. The clock — the shared heartbeat

The blue trace is the clock. The pink dots mark the rising edges — the only moments anything is allowed to change. Between edges, every $Q$ is rock-steady. (The fine print of how long before an edge $D$ must be steady is Clocking and setup/hold time.)

6. The overbar and $\cdot$ / $+$ — the algebra of switches

Why do we need these three? Because the load-enable equation on the parent page,

$D_{\text{ff}}=LOAD\cdot D+\overline{LOAD}\cdot Q,$

is built entirely from them. Here $D_{\text{ff}}$ has a subscript "$\text{ff}$" that literally means ==the $D$ wire of the flip-flop== — the value that will actually be clocked in. We distinguish it from the plain $D$ (the external data line you are offering from outside) because the load-enable circuit chooses between that external $D$ and the fed-back $Q$; the winner of that choice is what reaches the flip-flop's input, and that winner is $D_{\text{ff}}$.

Read the equation aloud with the definitions: "the flip-flop's input becomes the external $D$ when $LOAD$ is on, or its own fed-back $Q$ when $LOAD$ is off." One of the two AND-terms is always zero, so exactly one wins. This choose-one-of-two behaviour is literally a multiplexer.

7. Serial vs Parallel — one wire or many

On the left, four bits ride four chalk wires simultaneously (parallel). On the right, the same four bits queue up and cross one wire, one per tick (serial). A shift register is the machine that converts between these two pictures — that is what UART and SPI rely on.

8. Why shifting is $\times 2$ and $÷2$ — both directions

Now that place-values (§1), MSB/LSB (§2) and Serial In/Out (§4) are all defined, we can see both arithmetic effects in words.

The figure follows $1011$ shifting right: the pink LSB drops off the cliff (that is the lost half), and the value walks $11\to 5\to 2\to 1$ — each step is floor-division by two, matching the parent note's Example 1. (For signed numbers you must copy the MSB back in instead of a $0$; that is arithmetic right shift, covered in Binary multiplication and division.)

9. Putting the symbols together

You can now re-read every headline formula of the parent note and hear words, not symbols:

The only difference between the last two lines is where flip-flop $i$'s input comes from: its own external wire (register) versus its neighbour, with Serial In plugging the boundary hole at $i=0$ (shift). That single wiring choice is the entire chapter.

Prerequisite map

Read it bottom-up: bits build words, words have ends, the flip-flop is the memory box with $D$/$Q$, the clock ticks it, the index and Boolean algebra assemble many flip-flops into a register, and rewiring the inputs — plus a Serial In at the boundary — turns a register into a shift register that also multiplies and divides by two.

Equipment checklist

Connections

• D flip-flop — the single box these symbols describe
• Multiplexers — the choose-one-of-two behind the load-enable equation
• Clocking and setup/hold time — the fine print of the clock edge
• Serial communication (UART, SPI) — where serial↔parallel matters
• Binary multiplication and division — signed vs floor right shift
• Parent: Registers and shift registers