Binary Number Representation in Embedded Systems: From Bits to GPIO

Binary number representation is a base-2 numerical system that uses only two symbols, 0 and 1, to encode data, where each digit's position represents a successive power of two. In a physical circuit, this abstract math changes everything: it dictates how a microcontroller interprets 0V and 3.3V on a GPIO pin, how hardware DIP switches configure I2C bus addresses, and how analog-to-digital converters (ADCs) slice continuous voltage into discrete steps. If you are programming an ESP32 or wiring a shift register, understanding how base-2 maps to physical hardware is the difference between code that works and code that bricks your I2C bus.

The Core Math: Place Values and Bit Weights

Unlike the decimal (base-10) system you use daily, which rolls over to a new column after 9, binary rolls over after 1. Each position in a binary number—called a bit—represents a specific power of two, starting from $2^0$ on the far right (the Least Significant Bit, or LSB) and increasing as you move left toward the Most Significant Bit (MSB).

To read a binary number, you simply add the decimal weights of the positions that contain a '1'. For example, the 8-bit binary number 00010101 has '1's in the $2^0$ (1), $2^2$ (4), and $2^4$ (16) positions. Adding those weights (1 + 4 + 16) gives a decimal value of 21.

Table Note: The physical state column assumes standard 3.3V CMOS logic, where a '1' is driven to VCC (3.3V) and a '0' is pulled to GND (0V). Source: All About Circuits Digital Textbook.

Worked Example: Configuring Hardware Addresses and Bit Masks

Let's look at a real-world scenario where binary number representation directly dictates how you wire a breadboard. Suppose you are adding a Microchip MCP23017 16-bit I/O expander to your ESP32 via I2C. The MCP23017 has three hardware address pins: A0, A1, and A2. These pins allow you to connect up to eight of these chips on the same I2C bus.

The base 7-bit I2C address for the MCP23017 is 0x20 (which is 0100000 in binary). The state of the A0, A1, and A2 pins adds a 3-bit binary value to this base address.

If you wire A2 to 3.3V, A1 to GND, and A0 to 3.3V, the chip's internal logic reads the binary representation 101, adds it to 0100000, and answers to 0100101 (0x25).

In your C++ firmware, you will use bitwise operators to manipulate these binary representations. To check if Bit 3 of a status register is high, you don't convert the whole byte to decimal; you use a binary mask. According to the Arduino Bitwise Reference, the bitwise AND operator (&) isolates specific bits:

uint8_t status_reg = 0b00101100; // Decimal 44
// Isolate Bit 3 using a left-shifted mask (1 << 3 equals 0b00001000)
if (status_reg & (1 << 3)) {
    Serial.println("Bit 3 is HIGH");
}

Where You Meet This in Practice

Binary representation isn't just for I2C addressing; it is the foundational layer of almost every embedded subsystem you will build.

Shift Registers and Relay Banks

When you run out of GPIO pins on an Arduino Nano, you use a shift register like the 74HC595. You send an 8-bit binary number over SPI or bit-banged GPIO, and the chip latches those bits to its 8 physical output pins (Q0 through Q7). Sending 0b10100101 turns on relays 0, 2, 5, and 7 while keeping the others off, all using only three microcontroller pins.

Direct Port Manipulation

Calling digitalWrite(pin, HIGH) in Arduino is notoriously slow because the function has to look up the pin mapping and toggle registers safely. If you need to toggle multiple pins on an ATmega328P (Arduino Uno) in a single clock cycle, you write binary directly to the hardware port register. Writing PORTD = 0b00101100; instantly sets physical pins 2, 3, and 5 high, bypassing the Arduino abstraction layer entirely.

ADC and DAC Quantization

Analog signals are continuous, but microcontrollers are discrete. A 12-bit Digital-to-Analog Converter (DAC) like the MCP4725 maps binary numbers to analog voltages. It accepts values from 0 to 4095 ($2^{12} - 1$). If your VCC is exactly 3.3V, and you want to output 1.65V (exactly half), you must send the binary representation of 2048 (0b100000000000). The DAC reads this base-2 value and sets its internal resistor ladder to output half the reference voltage.

Common Confusions: Representation vs. Logic Levels vs. Hex

When troubleshooting a buggy circuit, makers frequently conflate three distinct concepts. Clearing up these confusions will save you hours of bench time.

1. Binary Representation vs. Binary Logic Levels
Binary representation is the abstract mathematical encoding (e.g., the number 1010). Binary logic is the physical electrical implementation. On a 3.3V ESP32, a '1' is nominally 3.3V and a '0' is 0V. However, CMOS logic has thresholds. The input low voltage ($V_{IL}$) might be anything below 0.8V, and input high ($V_{IH}$) anything above 2.0V. If a noisy sensor outputs 1.4V, the binary representation is undefined. The microcontroller might read it as a '0' or a '1', or worse, the input buffer might enter metastability, drawing excess current and overheating. Always use pull-up or pull-down resistors to ensure physical voltages snap cleanly to valid binary logic levels.

2. Base-2 (Binary) vs. Base-16 (Hexadecimal)
Hexadecimal is not a different way of storing data in memory; it is simply a human-friendly shorthand for binary representation. Because $16 = 2^4$, exactly four binary bits map to one hex character. The binary string 11111111 is cumbersome to read, so we write it as 0xFF. The prefix 0x tells the compiler (and the programmer) to interpret the following characters as base-16. The underlying silicon still only sees base-2.