Understanding Binary Numbers: From Theory to Shift Register Wiring

Binary is a base-2 numbering system where every digit represents a power of two, using only 0s and 1s to represent off and on states in digital circuits. In physical hardware, understanding binary numbers changes how a microcontroller maps physical voltage levels (like 0V and 3.3V) to logical decisions, memory addresses, and pin states. When you write a command to toggle a GPIO pin or configure a sensor register, you are not just doing abstract math; you are physically charging and discharging microscopic capacitors inside a silicon die.

While most high-level programming abstracts these details away, bench electronics and embedded systems require you to read and write binary fluently. A single flipped bit can mean the difference between a 3.3V logic HIGH and a 0V logic LOW, potentially sending a 12V solenoid valve into the wrong state. This guide bridges the gap between textbook base-2 arithmetic and the actual behavior of logic ICs on your workbench.

The Anatomy of a Byte: A Worked Numeric Example

A single binary digit is a bit, representing either a 0 (LOW / 0V) or a 1 (HIGH / VCC). Eight bits grouped together form a byte, which is the fundamental unit of data in most 8-bit registers and shift registers. Each bit position holds a specific weight, doubling as you move from right to left.

Worked Example: Converting Decimal 173 to Binary

Let us convert the decimal number 173 into an 8-bit binary sequence. We subtract the largest possible power of two at each step:

1. 128: 173 ≥ 128? Yes. Bit 7 = 1. (Remainder: 173 - 128 = 45)
2. 64: 45 ≥ 64? No. Bit 6 = 0.
3. 32: 45 ≥ 32? Yes. Bit 5 = 1. (Remainder: 45 - 32 = 13)
4. 16: 13 ≥ 16? No. Bit 4 = 0.
5. 8: 13 ≥ 8? Yes. Bit 3 = 1. (Remainder: 13 - 8 = 5)
6. 4: 5 ≥ 4? Yes. Bit 2 = 1. (Remainder: 5 - 4 = 1)
7. 2: 1 ≥ 2? No. Bit 1 = 0.
8. 1: 1 ≥ 1? Yes. Bit 0 = 1. (Remainder: 0)

Reading from Bit 7 down to Bit 0, the binary representation of 173 is 10101101. In C++ or Arduino code, you would write this as 0b10101101 or in hexadecimal as 0xAD.

Where You Meet Binary in Practice

You rarely write out long strings of 1s and 0s in modern application development, but in embedded systems and hardware design, binary is the native language of the physical layer.

• GPIO Port Registers: On an ATmega328P (Arduino Uno), the PORTB register controls digital pins 8 through 13. Writing PORTB = 0b00100000; instantly sets pin 13 HIGH while forcing pins 8-12 LOW in a single clock cycle, bypassing the overhead of the digitalWrite() function.
• Sensor Configuration: I2C sensors like the BME280 use configuration registers. To set the oversampling rate, you must write a specific binary bitmask to the ctrl_meas register without accidentally overwriting the adjacent power mode bits.
• Shift Registers: ICs like the 74HC595 take a serial stream of binary bits and convert them into parallel physical outputs. According to the Texas Instruments SN74HC595 datasheet, the serial input pin shifts data into an internal 8-bit register on every rising edge of the clock pin.

Real-World Scenario: The Shift Register Relay Disaster

To understand how binary theory translates to physical failures, let us walk through a common bench mistake involving bit-ordering and shift registers.

The Setup

You are building an automated greenhouse irrigation system. An ESP32 microcontroller controls an 8-channel relay module via a 74HC595 shift register to save GPIO pins. The relays are wired to solenoid valves. Relay 1 is connected to output Q0, and Relay 2 is connected to output Q1.

The Numbers

You need to turn on Relay 1 and Relay 2 simultaneously, leaving the rest off.
Target physical output at Q7..Q0: 00000011.
In decimal, this is 3.
Your code calls: shiftOut(dataPin, clockPin, MSBFIRST, 3);

The Outcome

You upload the code. Instead of Relay 1 and Relay 2 clicking on, Relay 7 and Relay 8 activate, flooding the wrong zones and triggering a water alarm.

What Went Wrong

The failure stems from a misunderstanding of how the 74HC595 shifts binary data internally. When you specify MSBFIRST (Most Significant Bit First), the shift register takes the highest bit (Bit 7) and pushes it into the Q7 flip-flop first. On the next clock pulse, that bit shifts down to Q6, and the next bit enters Q7. After 8 clock pulses, the first bit you sent ends up at Q0, and the last bit you sent ends up at Q7.

Let us trace the binary for decimal 3 (00000011) sent MSBFIRST:

• Bit 7 (0) is sent first → cascades down to Q0.
• Bit 6 (0) is sent second → cascades down to Q1.
• ...
• Bit 1 (1) is sent seventh → ends up at Q6.
• Bit 0 (1) is sent last → stays at Q7.

The physical output at Q7..Q0 becomes 11000000. You accidentally turned on Q7 and Q6 (Relays 8 and 7).

The Fix

To fix this without rewiring the physical relay board, change the bit-order parameter in your code to LSBFIRST (Least Significant Bit First). This sends Bit 0 first (landing at Q0) and Bit 7 last (landing at Q7), perfectly matching your logical expectation of the binary number 3.

Common Confusions: Hex, BCD, and Bit-Ordering

When learning binary, makers frequently confuse it with adjacent numbering systems and concepts. Here is what you need to distinguish on the bench:

Binary vs. Hexadecimal

Hexadecimal (base-16) is not a different physical state; it is simply a human-readable shorthand for binary. Because 16 is a power of 2 (2^4), exactly four binary bits map to one hex digit. 1010 in binary is A in hex. When you see an I2C address listed as 0x3F, the hardware is still just seeing 00111111. Use hex when reading datasheets; use binary when configuring specific bitmasks.

Binary vs. BCD (Binary Coded Decimal)

Binary Coded Decimal uses 4 bits to represent a single decimal digit (0-9). Real-Time Clock (RTC) modules like the DS1307 often store time in BCD. The decimal number 45 is 00101101 in pure binary, but in BCD, it is split into two nibbles: 0100 (4) and 0101 (5), resulting in 01000101. If you read an RTC register and treat the BCD output as pure binary, your microcontroller will think the time is 69 instead of 45.

MSB vs. LSB (Endianness)

As demonstrated in the shift register scenario, the order in which bits are transmitted over a wire (Serial) or stored in memory (Endianness) matters. Always check whether a communication protocol like SPI or I2C expects the Most Significant Bit or Least Significant Bit first. The All About Circuits digital textbook provides excellent visual diagrams of how bit-shifting cascades through flip-flops.

FAQ: Binary Logic on the Workbench