What Are Binary Numbers Used For in Microcontrollers and Digital Logic?

Binary numbers are a base-2 numerical system using only 0s and 1s to represent data, logic states, and memory addresses in digital electronics and computing. While software engineers treat binary as abstract math, electrical engineers and hardware makers deal with it as physical voltage. In a real circuit, binary dictates the physical voltage thresholds required for noise immunity, governs how microcontrollers sample analog sensors, and determines the routing of data across memory buses.

The Core Mechanics: How Binary Maps to Physical Voltage

What binary changes in a real installation or circuit is the physical design of the input protection and the noise margins of the logic families. A binary 1 or 0 is not an abstract concept; it is a specific voltage range measured against a ground reference. If a voltage falls within the 'HIGH' threshold, the silicon interprets it as a 1. If it falls within the 'LOW' threshold, it reads a 0. The gap between these thresholds is the noise margin.

According to SparkFun's guide on logic levels, the exact voltage thresholds depend on the logic family and the supply voltage (VCC):

• 5V TTL Logic (e.g., Arduino Uno ATmega328P): A binary 0 is 0V to 0.8V. A binary 1 is 2.0V to 5.0V. Voltages between 0.8V and 2.0V are undefined and can cause erratic behavior.
• 3.3V CMOS Logic (e.g., ESP32-WROOM-32): A binary 0 is typically 0V to 0.8V. A binary 1 is roughly 2.3V to 3.3V.

Worked Example: Calculating 12-Bit ADC Resolution on an ESP32

To see how binary translates to real-world measurements, let's look at an Analog-to-Digital Converter (ADC). The ESP32 features a 12-bit ADC. Because it is 12-bit, it uses 12 binary digits (bits) to represent an analog voltage, giving it $2^{12}$ or 4,096 discrete steps (ranging from 0 to 4095 in decimal).

Assuming a reference voltage (VREF) of exactly 3.3V, each binary step represents:

3.3V / 4095 = 0.0008058V (or roughly 0.806 mV per bit).

Suppose you are reading a temperature sensor via the ADC, and the microcontroller's register captures the following 12-bit binary string:

0101 1001 0000

To find the physical voltage, we first convert this binary number to decimal:

• Bit 11 (0): $0 \times 2048 = 0$
• Bit 10 (1): $1 \times 1024 = 1024$
• Bit 9 (0): $0 \times 512 = 0$
• Bit 8 (1): $1 \times 256 = 256$
• Bit 7 (1): $1 \times 128 = 128$
• Bit 6 (0): $0 \times 64 = 0$
• Bit 5 (0): $0 \times 32 = 0$
• Bit 4 (1): $1 \times 16 = 16$
• Bits 3-0 (0000): $0$

Total Decimal Value: $1024 + 256 + 128 + 16 = 1424$.

Now, multiply the decimal value by the voltage per step:

1424 × 0.0008058V = 1.147V

The binary string 010110010000 tells your firmware that the sensor is currently outputting 1.147 volts.

Where You Meet Binary in Practice: Firmware and Hardware

When writing firmware in C or C++ for microcontrollers, you rarely type out long strings of 1s and 0s. However, you constantly interact with binary through bitwise operations. Microcontrollers use hardware registers—specific memory addresses where each individual bit controls a physical peripheral, like enabling a UART transmitter or triggering an interrupt.

According to the Arduino Bit Math documentation, manipulating these registers requires masking. Here is a comparison of the core binary operations you will use on the bench:

Real-World Code Snippet:
If you need to check if bit 4 (the 5th bit from the right) of an I2C status register is HIGH (indicating a bus error), you use a binary AND mask:

uint8_t status = readI2CRegister();
if (status & (1 << 4)) {
    // Bit 4 is 1: Handle I2C Bus Error
}

Common Confusions: Binary vs. Hexadecimal vs. BCD

The most common mistake beginners make is confusing binary with its shorthand cousins. Understanding the difference prevents critical bugs when reading datasheets.

• Hexadecimal (Base-16): Hex is not a different physical logic system; it is simply a human-readable compression of binary. Because 16 is $2^4$, every single hex digit perfectly represents four binary bits (a nibble). The binary string 1111 1010 is written as 0xFA in hex. Microcontrollers still process it as binary; hex is just for your convenience.
• Binary Coded Decimal (BCD): BCD uses 4 binary bits to represent a single base-10 decimal digit (0-9). This means the binary states 1010 through 1111 (10-15) are 'wasted' and invalid in BCD. You will frequently encounter BCD when working with Real-Time Clock (RTC) modules like the DS3231. If you read the seconds register and get 0101 1001, it does not mean 89 in decimal; in BCD, it means 59 seconds.