Binary Numbers Explanation: How Base-2 Logic Drives Microcontrollers and Digital Circuits

Binary is a base-2 numbering system that uses only two digits, 0 and 1, to represent all data and instructions in digital electronics by mapping directly to the physical off and on states of semiconductor transistors. While software engineers treat binary as abstract data, electrical engineers and hardware makers must treat it as a physical reality: every '1' and '0' corresponds to a specific voltage potential driving a gate, charging a capacitor, or triggering a relay.

The Core Mechanics of Base-2 and Hardware Mapping

In a physical circuit, a binary state changes the actual electrical behavior of the system. A binary '1' on a microcontroller pin is not just a mathematical truth; it is a physical voltage level—typically 3.3V or 5.0V relative to ground—sourcing current. Conversely, a '0' connects the pin to ground, sinking current. This physical reality dictates how we design input circuits: an unconnected (floating) input pin can randomly fluctuate between 0 and 1 due to electromagnetic interference, which is why we use pull-up or pull-down resistors to force a known binary state when a switch is open.

To see how binary translates directly to hardware, consider the ATmega328P microcontroller (used in the Arduino Uno). Its GPIO pins are grouped into 8-bit hardware registers. Writing a single binary byte to the PORTD register instantly changes the physical voltage state of eight distinct pins (PD0 through PD7) simultaneously.

Worked Example: Translating ADC Readings to Binary

Microcontrollers read analog voltages using an Analog-to-Digital Converter (ADC), which translates a continuous voltage into a discrete binary number. Let us calculate the exact binary output of a 10-bit ADC reading a 2.5V signal on a system with a 5.0V reference.

The formula for ADC conversion is:

ADC_Value = (V_in / V_ref) × (2^n - 1)

For a 10-bit ADC, n = 10, so the maximum value is 2^10 - 1 = 1023.

ADC_Value = (2.5 / 5.0) × 1023 = 511.5

Since the ADC outputs an integer, it truncates the decimal, giving us 511. Now, we convert 511 into a 10-bit binary string by subtracting the highest possible bit weights (powers of 2):

• Bit 9 (Weight 512): 511 is less than 512. Bit = 0
• Bit 8 (Weight 256): 511 - 256 = 255. Bit = 1
• Bit 7 (Weight 128): 255 - 128 = 127. Bit = 1
• Bit 6 (Weight 64): 127 - 64 = 63. Bit = 1
• Bit 5 (Weight 32): 63 - 32 = 31. Bit = 1
• Bit 4 (Weight 16): 31 - 16 = 15. Bit = 1
• Bit 3 (Weight 8): 15 - 8 = 7. Bit = 1
• Bit 2 (Weight 4): 7 - 4 = 3. Bit = 1
• Bit 1 (Weight 2): 3 - 2 = 1. Bit = 1
• Bit 0 (Weight 1): 1 - 1 = 0. Bit = 1

The final 10-bit binary string is 01 1111 1111. In your microcontroller's memory, this is stored across two 8-bit bytes. Understanding this exact bit structure is critical when you need to bit-shift or mask the ADC result to send it over a serial protocol.

Where You Meet Binary in Practical Electronics

You will encounter binary manipulation constantly when moving beyond basic Arduino sketches into direct hardware control and communication protocols.

I2C and SPI Addressing

When communicating with an I2C sensor like the BME280, the protocol uses a 7-bit binary address (e.g., 1110111 or 0x77). However, the physical bus transmits 8 bits. The 8th bit is the Read/Write flag. If you want to read from the sensor, the master appends a '1' to the end, making the transmitted byte 11101111 (0xEF). If you write, it appends a '0', resulting in 11101110 (0xEE). This is detailed in the official NXP I2C-bus specification.

Direct Register Bitmasking

On an ESP32, toggling a GPIO pin using digitalWrite() is slow because the function includes safety checks. For high-speed bit-banging, you write directly to the hardware register using binary bit-shifting. To set GPIO 2 high without affecting other pins, you write a binary 1 shifted left by 2 positions to the 'write-1-to-set' register:

GPIO.out_w1ts = (1 << 2);

This pushes the binary value 0000 0100 into the register, instantly driving GPIO 2 to 3.3V in a single clock cycle. The ESP32 Technical Reference Manual documents these specific register addresses and bit layouts.

Shift Registers (74HC595)

When you run out of GPIO pins, you use a shift register. You feed binary data serially (one bit at a time) into the chip's data pin, pulsing the clock pin for each bit. Once all 8 bits are loaded, a latch pin pulses, and the chip outputs all 8 binary states to physical pins simultaneously, effectively converting serial binary data into parallel hardware outputs.

Common Confusions and Logic Thresholds

Binary vs. Hexadecimal

Beginners often confuse binary and hexadecimal, thinking they represent different physical states. They do not. Hexadecimal (base-16) is simply a human-readable shorthand for binary. Because one hex digit perfectly represents four binary bits (a nibble), writing 0xFF is just a faster way to write 1111 1111. The microcontroller only ever sees the binary voltages; the hex is just for the programmer's convenience.

Endianness (MSB vs. LSB)

When transmitting multi-byte binary numbers over SPI or UART, you must know the endianness. Most Significant Bit (MSB) first means the highest-value bit is sent first (standard for I2C and SPI). Least Significant Bit (LSB) first sends the lowest-value bit first (common in some UART configurations and USB). If your sender uses MSB and your receiver expects LSB, your binary data will arrive backwards, turning a command to open a valve into a command to reset the system.