How Does the Binary Number System Work in Digital Circuits and Code?

The binary number system is a base-2 mathematical framework that represents all numerical values using only two digits, 0 and 1, corresponding directly to the physical OFF and ON voltage states of digital logic gates. Unlike the base-10 (decimal) system humans use, which relies on ten distinct symbols, binary maps perfectly to the physical reality of a transistor acting as a switch. In a real circuit, a microcontroller does not 'understand' the number 42; it only understands a specific pattern of high and low voltages across its internal registers. For a 5V Arduino Uno (ATmega328P), a logic 0 is any voltage below 0.8V, and a logic 1 is anything above 2.0V. For a 3.3V ESP32, those TTL thresholds shift to <0.99V for LOW and >2.31V for HIGH. Understanding how these voltage states map to mathematical values is the foundation of all embedded programming and digital logic design.

The Core Mechanism: Base-2 Weighting and Conversion

In the decimal system, each position represents a power of 10 (ones, tens, hundreds). In binary, each position represents a power of 2, starting from the rightmost bit (the Least Significant Bit, or LSB) at 2⁰ and moving left. An 8-bit binary number (one byte) has positions weighted at 1, 2, 4, 8, 16, 32, 64, and 128.

To see how this works on the bench, let us run a worked numeric example converting a decimal value into an 8-bit binary register state. Suppose you need to configure a port register to the decimal value 173. We subtract the largest possible binary weight from our target until we reach zero:

• 128: 173 - 128 = 45. (Bit 7 is 1)
• 64: 45 is smaller than 64. (Bit 6 is 0)
• 32: 45 - 32 = 13. (Bit 5 is 1)
• 16: 13 is smaller than 16. (Bit 4 is 0)
• 8: 13 - 8 = 5. (Bit 3 is 1)
• 4: 5 - 4 = 1. (Bit 2 is 1)
• 2: 1 is smaller than 2. (Bit 1 is 0)
• 1: 1 - 1 = 0. (Bit 0 is 1)

Reading from Bit 7 down to Bit 0, the decimal value 173 translates to the binary sequence 10101101. If you write this to an 8-bit output port, pins 7, 5, 3, 2, and 0 will drive HIGH, while pins 6, 4, and 1 will drive LOW.

8-Bit Binary Reference Table for GPIO and Registers

When debugging shift registers like the TI SN74HC595 or configuring microcontroller ports, you will repeatedly encounter specific binary patterns. Memorizing these common byte values saves time when reading logic analyzer traces.

Where You Meet Binary in Practice

Binary is not just abstract math; it dictates physical hardware behavior. Here is what it changes in a real installation and where you will interact with it directly.

Physical DIP Switches and Stepper Drivers

If you wire a NEMA 23 stepper motor to a DM542T driver, you must set the microstepping resolution using physical DIP switches. The switches are read in binary. If switches 1, 2, and 3 represent the microstep multiplier, setting them to ON-ON-OFF (where ON = 1 and OFF = 0) yields the binary sequence 110 (decimal 6). The driver's internal logic decodes this base-2 input to physically alter the current decay timing in the H-bridge MOSFETs, changing the motor's step angle.

Execution Speed and Port Manipulation

In an Arduino sketch, calling digitalWrite(pin, HIGH) eight times to set a port takes roughly 50 microseconds because the function performs safety checks and pin mapping on every call. By contrast, writing the binary value directly to the hardware register (PORTD = B10101101;) updates all eight physical pins simultaneously in a single clock cycle—about 0.125 microseconds. This 400x speed increase is mandatory when bit-banging high-speed protocols like WS2812B addressable LED timing.

Common Confusions: Binary vs. Hexadecimal vs. Boolean

Makers frequently confuse binary with hexadecimal. Hexadecimal (base-16) is simply a human-friendly shorthand for reading binary; the silicon only ever processes base-2. Another common trap is confusing binary arithmetic (adding 1 + 1 to get 10 with a carry bit) with Boolean logic (where 1 AND 1 equals 1, with no carry). Arithmetic happens in the ALU (Arithmetic Logic Unit), while Boolean operations happen in the logic gates routing the signals.

Bitwise Operations and Port Manipulation

When manipulating the ESP32 GPIO matrix or AVR port registers, you rarely want to overwrite an entire byte, as that might reset a pin currently handling a critical interrupt. Instead, we use bitwise operators to target specific binary positions.

• Set a bit (Force HIGH): Use the bitwise OR operator (|).
  REG |= (1 << 3); // Forces bit 3 to 1, leaves others untouched.
• Clear a bit (Force LOW): Use the bitwise AND (&) with the NOT (~) operator.
  REG &= ~(1 << 3); // Forces bit 3 to 0, leaves others untouched.
• Toggle a bit (Flip state): Use the bitwise XOR operator (^).
  REG ^= (1 << 3); // Flips bit 3 from 0 to 1, or 1 to 0.
• Read a bit: Use the bitwise AND to isolate the target.
  if (REG & (1 << 3)) { ... } // Checks if bit 3 is currently HIGH.

Frequently Asked Questions