Information Buses

When we were building simple logic circuits, a handful of single wires was enough. But as soon as 8-bit numbers come into play, everything gets complicated. To transfer a single byte from the adder to memory, you have to route 8 separate wires at once. Bit by bit, the schematic turns into an unreadable spiderweb.

Engineers solved this problem with buses. A bus is an information highway — a bundle of wires combined into one cable. In the simulator, buses are drawn as thick lines and carry a whole value at once, a number from 0 to 255. Instead of dozens of tiny contacts, you connect two complex components with one thick line. That keeps the processor architecture clean and compact.

Practical example. Imagine passing the number 42 from a register to the ALU. Without a bus, you would have to route 8 individual wires — bit 0, bit 1, ..., bit 7 — and make sure none got mixed up. With a bus, you connect one "thick" cable and all 8 bits travel together. In a real processor, the data bus is 32 or 64 parallel conductors etched onto the silicon.

What is a byte, and why does it need 8 wires

A single wire carries only one bit — a 0 or a 1. But a byte is 8 bits, and every bit must arrive at the same time. That's why a bus of 8 parallel wires carries one byte at a time.

From 8 bits you can build 2⁸ = 256 combinations — from 00000000 to 11111111. So a byte stores any whole number from 0 to 255. Eight wires are like a road with eight lanes: data travels on all of them at once.

Every bit has its own weight

Bits in a byte are not equal. The rightmost — bit 0 (LSB) — has a weight of 1; the next one, bit 1, has a weight of 2. Then 4, 8, 16, 32, 64 — and the leftmost bit 7 (MSB) with a weight of 128. The value of a byte is the sum of the weights of the set bits.

The number 42 on a bus: a step-by-step walkthrough

Take the example from the intro: the number 42. In binary it is 00101010. How does it break down into bits?

Step by step:

1. Find the bits set to 1: bits 5, 3, and 1.

2. Add up their weights: 32 + 8 + 2 = 42.

3. Check: 42 = 00101010 — one bus, eight wires, carrying exactly the number we wanted to send.

Splitter and Maker: connecting a bus to bits

In the game, a bus is a ready-made component, but it still needs to talk to individual bits. Two helper nodes do this job.

Splitter takes an 8-bit bus and splits it into 8 separate wires: Bit0 (LSB), Bit1, ..., Bit7 (MSB). It's like combing a cable apart into individual strands.

Maker works the other way: it takes 8 individual bits and assembles them into one 8-bit bus. Without them, we couldn't feed a single bit into a gate nor pass a whole byte further down the line.

Level 1.8 "8-bit Adder"

In level 1.8 you will build a real 8-bit adder and earn the ADDER8 chip. The circuit uses buses heavily:

1. Two Splitters break the input buses A and B into individual bits.

2. Eight FullAdders add the bits in pairs: least with least, most with most.

3. Carries link the adders into a chain — each adder's carry output feeds the next.

4. One Maker assembles the 8 sum bits back into the output bus.

All 8 adders compute simultaneously: hardware works in parallel; only the carry ripples from the least to the most significant bit.

Buses in real processors

A real computer has several buses. The data bus carries the values — the numbers the ALU works with. The address bus tells memory which location to read or write; it is one-way, driven only by the processor. The control bus carries commands: Read, Write, Clock, Reset.

To execute "store a value at address 100," the processor puts 100 on the address bus, the value on the data bus, and asserts Write on the control bus. Three buses, one operation — together with the adder from the previous article, this already looks like a real processor.

Common mistakes

1. Mixing up the bit order. Bit0 is the one with weight 1, the rightmost bit. Swap the Splitter outputs and the numbers go "backwards."

2. Forgetting the carry. In an adder chain, every carry must reach the next bit position, or the sum will be wrong.

Summary

1. A bus is 8 parallel wires carrying one byte (a number from 0 to 255).

2. In the simulator, buses are thick lines that connect components with one cable instead of eight.

3. Every bit has a weight: bit 0 is 1, bit 7 is 128; the byte's value is the sum of the set bits' weights.

4. Splitter breaks a bus into bits; Maker assembles bits into a bus.

5. An 8-bit adder is 8 FullAdders joined by a carry chain; all bits compute in parallel.

In level 1.8 you will build the 8-bit ADDER8: split two input buses into bits with Splitters, add them with eight FullAdders in a carry chain, and assemble the result back into a bus with a Maker. The next article covers switching data flows — the multiplexer.