Understanding Binary Numbers in Digital Electronics and Microcontrollers

Binary numbers are a base-2 numeral system using only two digits, 0 and 1, to represent all values and logic states in digital electronics. In a physical circuit, this mathematical concept changes everything: it dictates the physical voltage thresholds a microcontroller uses to read a sensor, the exact resolution of an analog-to-digital converter (ADC), and how memory registers map directly to physical GPIO pins. The most common point of confusion for makers is conflating binary mathematical values with binary logic levels—assuming a "1" always means exactly 5.0V, when in reality, a "1" on a 3.3V CMOS system is anything above a specific threshold, and feeding it 5V will destroy the silicon.

The Core Math: Bit Weights and Conversions

Unlike the decimal (base-10) system humans use, digital logic relies on base-2 because transistors fundamentally operate as two-state switches: cut-off (open) or saturated (closed). Each position in a binary number represents a power of 2, starting from the right. Understanding these bit weights is mandatory when you need to manually set microcontroller registers or decode raw sensor data over SPI or I2C.

Where You Meet Binary Numbers in Practice

Binary numbers are not just abstract math; they are the direct interface between your code and the physical hardware. Here is where you will interact with them on the workbench.

ADC Resolution and Sensor Data

When an analog-to-digital converter (ADC) samples a voltage, it outputs a binary number. The resolution of the ADC determines how many binary bits are available. The Espressif ESP32 features a 12-bit Successive Approximation Register (SAR) ADC. This means it outputs binary numbers ranging from 000000000000 (decimal 0) to 111111111111 (decimal 4095).

If your ESP32 is referenced to 3.3V, each binary step represents 3.3V / 4095 = 0.000805V. If your multimeter reads 1.97V on GPIO 34, the ADC will return a binary value of roughly 100110011001 (decimal 2457). Bench note: The ESP32 internal ADC is notoriously non-linear at the extreme high and low ends. In practice, readings above 3.1V often saturate at 4095, which is why precision designs use an external I2C ADC like the ADS1115.

Direct Register Manipulation

Using functions like digitalWrite() in Arduino is slow because it abstracts the binary math. For high-speed applications, you write binary numbers directly to hardware registers. On an ATmega328P (Arduino Uno), writing PORTD = B10101010; instantly sets pins D2-D7 high and low in a single clock cycle. However, because Bits 0 and 1 of PORTD map to the hardware UART (RX/TX), blindly overwriting this binary register will instantly break your Serial.print() debugging output—a classic beginner trap.

Binary Logic Levels: Math vs. Physical Voltage

This is where the most expensive mistakes happen. A binary "1" in code does not mean a specific voltage; it means a voltage above a defined threshold. Mixing up 5V TTL logic (standard on older Arduino boards) with 3.3V CMOS logic (standard on ESP32, Raspberry Pi, and modern sensors) will result in dead silicon.

Debugging Binary Data Streams

When pulling binary data from sensors via I2C or SPI, the raw bytes rarely arrive in a format you can read directly. You must manipulate the bits using bitwise operators.

• Bit-Shifting (<< and >>): Used to move bits into position. If a sensor returns a 16-bit temperature value split across two 8-bit registers, you must shift the Most Significant Byte (MSB) left by 8 bits (msb << 8) and OR it with the Least Significant Byte (LSB). A common C/C++ error is attempting 1 << 8 on an 8-bit integer variable, which overflows to 0. Always cast to a 16-bit integer first: (uint16_t)msb << 8.
• Masking (&): Used to isolate specific bits. If you only care about the lower 4 bits of a status register, apply a mask: status & 0x0F. This forces the upper 4 bits to zero, preventing them from corrupting your logic.
• Endianness: This defines the byte order of multi-byte binary numbers. Most microcontrollers (ARM Cortex, AVR) are Little-Endian, meaning the LSB is stored at the lowest memory address. Many network protocols and specific sensors (like some Bosch MEMS sensors) transmit in Big-Endian. If your temperature reading looks impossibly large or negative, you likely have an endianness mismatch and need to swap the byte order.