How to List Binary Numbers for Microcontroller Registers and GPIO Masks

Binary numbers are a base-2 numeral system using only 0s and 1s to represent discrete electrical states, such as 0V (LOW) and 3.3V (HIGH), in digital logic circuits. Knowing how to list binary numbers changes your approach from guessing pin states to precisely manipulating hardware registers, configuring I2C multiplexers, and setting GPIO port masks. Beginners commonly confuse raw binary values with binary coding schemes like Gray code or Binary-Coded Decimal (BCD), which are specific mapping rules for encoders and displays rather than the underlying base-2 mathematics used for direct hardware control.

The Core Mechanism: Base-2 vs Base-10 at the Bench

When you write code for a microcontroller, the compiler handles base-10 (decimal) to base-2 (binary) conversion automatically. However, when you are debugging a logic analyzer trace or writing directly to a hardware register, you must think in binary. Each digit (bit) represents a power of 2, starting from 2^0 on the far right (the Least Significant Bit, or LSB) and increasing as you move left.

Where You Meet This in Practice: ESP32 and Arduino

Listing binary numbers is not just an academic exercise; it is a daily requirement when working with modern embedded systems. You will encounter base-2 logic in three primary areas on the workbench:

1. Direct GPIO Register Manipulation
On the ESP32, toggling individual pins using digitalWrite() is slow because the Arduino core performs safety checks and pin mapping. For high-speed bit-banging (like driving WS2812B addressable LEDs), you write directly to the GPIO_OUT_W1TS_REG (Write 1 to Set) and GPIO_OUT_W1TC_REG (Write 1 to Clear). These 32-bit registers require you to list binary masks to target specific pins without disturbing the others. According to the Espressif ESP32 Technical Reference Manual, writing a 1 to bit 2 of the W1TS register sets GPIO2 HIGH, while leaving all other bits as 0 ensures pins 4, 5, and 18 remain untouched.

2. Shift Registers (e.g., 74HC595)
When you run out of GPIO pins, you use an 8-bit shift register like the NXP 74HC595. You clock in 8 bits serially. If you want to turn on relays connected to outputs Q0, Q3, and Q7, you must list the binary number 10001001 (decimal 137) and shift it out MSB-first or LSB-first, depending on your wiring.

3. I2C Addressing and Multiplexing
I2C addresses are 7-bit or 10-bit values. A common OLED display (SSD1306) has an I2C address of 0x3C. In binary, 0x3C is 0111100. Understanding this binary list is critical when you are pulling A0/A1/A2 address pins HIGH or LOW on sensors like the MCP23017 I/O expander to create a custom address mask.

Real-World Scenario Walkthrough: Bricking an I2C Bus with a Bad Bitmask

The most common point of failure when makers transition from basic Arduino sketches to intermediate hardware design is confusing decimal channel indices with binary bitmasks. Here is a real-world bench scenario.

The Setup:
You are building an environmental monitor using an ESP32 and three BME280 temperature/humidity sensors. Because all three BME280s share the same default I2C address (0x76), you wire them through a Texas Instruments TCA9548A I2C multiplexer. The TCA9548A allows you to route the main I2C bus to one of 8 downstream channels (0 through 7) by writing a single byte to its control register.

The Numbers:
The TCA9548A control register uses the lower 3 bits to select the active channels.

• Channel 0 requires binary 00000001 (Decimal 1)
• Channel 1 requires binary 00000010 (Decimal 2)
• Channel 2 requires binary 00000100 (Decimal 4)

The Outcome:
In your C++ code, you write a function selectChannel(2) to read the third sensor. Inside the function, you send the number 2 directly to the Wire.write() command, assuming "2" means "Channel 2". The ESP32 compiles and runs, but the serial monitor prints NaN (Not a Number) for the temperature. The logic analyzer shows the I2C bus scanning the wrong physical wires.

What Went Wrong:
You sent decimal 2, which is binary 00000010. Looking at the TCA9548A datasheet, 00000010 enables Channel 1, not Channel 2. Because no sensor was wired to Channel 1, the ESP32 received no ACK (acknowledge) bit and read floating garbage data.

uint8_t channel = 2;
uint8_t bitmask = 1 << channel; // Shifts binary 00000001 left by 2 positions = 00000100 (Decimal 4)
Wire.beginTransmission(0x70);
Wire.write(bitmask);
Wire.endTransmission();

Quick Reference: How to List Binary Numbers for 4-Bit Registers

When working with 4-bit nibbles (common in BCD thumbwheel switches, 4-bit LCD interfaces, or the lower nibble of a port expander), you need to quickly map physical switch states to code. Below is the definitive reference for listing 4-bit binary numbers alongside their hex and decimal equivalents.

Troubleshooting and FAQ