How to Decode Binary Numbers for Embedded Hardware and Register Mapping

Binary is a base-2 numbering system where each digit (bit) represents a power of two, using only 0s and 1s to denote off and on states. In a physical circuit, decoding binary is what allows a microcontroller to configure a GPIO pin as a high-impedance input or a push-pull output, directly changing whether current can flow to your load or if a pull-up resistor is engaged. When you write digitalWrite(LED_BUILTIN, HIGH), the Arduino core is ultimately decoding your command into a binary bitmask to flip a specific transistor gate inside the silicon.

The Core Math: Decoding Base-2 to Base-10

To decode a binary number into the decimal (base-10) format we use for everyday math, you assign a positional weight to each bit. The rightmost bit is the Least Significant Bit (LSB) and represents $2^0$ (1). Moving left, the weights double: $2^1$ (2), $2^2$ (4), $2^3$ (8), and so on. You simply add the weights of the positions where the bit is a 1.

While you can decode any length of binary, embedded systems usually handle data in 8-bit (byte), 16-bit, or 32-bit chunks. Below is a reference table of common 8-bit binary masks you will encounter when manipulating hardware registers on AVR (Arduino) and ESP32 microcontrollers.

Where You Meet Binary in Real Circuits and Installations

Understanding how to decode binary numbers is not just an academic exercise; it is a daily requirement when wiring complex digital logic or debugging communication buses.

Shift Registers (e.g., 74HC595)

When you run out of GPIO pins on an Arduino Uno, you typically add a 74HC595 shift register. This IC takes a serial stream of 1s and 0s and latches them onto 8 parallel output pins. If you want to turn on the LED connected to output Q7 (the most significant bit) and leave the rest off, you must send the binary value 0b10000000 (decimal 128). If you accidentally send 0b00000001, you will light up Q0 instead, because the hardware physically maps the first bit shifted in to the highest register position.

I2C Addressing and I/O Expanders

I2C addresses are usually documented in hexadecimal, but the physical bus transmits them in binary. Take the popular PCF8574 I/O expander. Its base address is 0x20. Decoded to binary, that is 0b00100000. The PCF8574 has three physical address pins (A0, A1, A2). If you wire A0 to VCC (High/1), you alter the lowest bit of the address. The new binary address becomes 0b00100001, which decodes to 0x21 in hex. If you do not understand how to decode and manipulate these lower bits, your microcontroller will fail to acknowledge the chip on the bus.

Stepper Motor Driver DIP Switches

Industrial and hobbyist stepper drivers (like the TB6600 or DM542) use physical DIP switches to set the microstepping resolution and current limit. The manual will show a table of switch positions. A switch flipped UP might represent a 1, and DOWN a 0. To set a driver to 1/16th microstepping, you might need the binary sequence 0b101 on switches S1, S2, and S3. Decoding the physical switch positions into the binary logic the driver expects is the only way to achieve smooth motor motion without stalling.

Common Confusions: Binary vs. Hexadecimal vs. BCD

The most frequent mistake hobbyists make is confusing pure binary with its shorthand and specialized variants. Knowing the difference will save you hours of debugging.

The BCD Trap (Binary-Coded Decimal)

Binary-Coded Decimal (BCD) is where most embedded beginners get stuck. BCD does not convert the whole number to binary; instead, it encodes each individual decimal digit into its own 4-bit binary block.

Example: The Decimal Number 45

• Pure Binary: 32 + 8 + 4 + 1 = 0010 1101
• BCD: 4 is 0100, 5 is 0101. Combined = 0100 0101

Why does this matter? Real-Time Clock (RTC) modules like the DS3231 store time in BCD to make displaying the time on 7-segment displays or LCDs easier. If you read the seconds register from a DS3231 and it returns the binary value 0100 0101, a naive pure-binary decode gives you 69 seconds. But decoded as BCD, it correctly reads as 45 seconds. If your RTC code is outputting "85 minutes" or "94 seconds", you have failed to decode BCD properly. You must isolate the nibbles, decode them separately, and multiply the high nibble by 10.

Practical Bitwise Operations for Register Mapping

When programming microcontrollers like the ESP32, you rarely overwrite an entire 32-bit register, because doing so would instantly change the state of 32 different hardware peripherals. Instead, you decode the binary mask and use bitwise operators to flip specific bits while leaving the rest untouched.

Here is the standard decision framework for manipulating hardware registers in C/C++:

• Set a bit (Force to 1): Use Bitwise OR (|).
  REG |= (1 << PIN_BIT);
• Clear a bit (Force to 0): Use Bitwise AND (&) with NOT (~).
  REG &= ~(1 << PIN_BIT);
• Toggle a bit (Flip state): Use Bitwise XOR (^).
  REG ^= (1 << PIN_BIT);
• Read a bit (Check state): Use Bitwise AND.
  if (REG & (1 << PIN_BIT)) { // Pin is HIGH }

Let us look at a practical ESP32 example. Suppose you are working with the ESP32 GPIO Enable Register and you need to enable GPIO 5 without disabling GPIOs 0 through 4. GPIO 5 corresponds to the 6th bit from the right (bit index 5, decimal weight 32, binary 0b00100000).

// Define the pin we want to manipulate
const int TARGET_PIN = 5;

// WRONG: This overwrites the whole register, disabling all other pins!
// GPIO.enable_w1ts = (1 << TARGET_PIN); 

// RIGHT: This uses bitwise OR to set ONLY bit 5 high
GPIO.enable_w1ts = (1 << TARGET_PIN);

// To later disable ONLY GPIO 5, we write to the clear register
GPIO.enable_w1tc = (1 << TARGET_PIN);

By mastering how to decode binary numbers and apply these bitwise masks, you move from relying on bloated abstraction libraries to writing lean, cycle-accurate code that directly commands the silicon. Whether you are debugging an I2C address collision, wiring a shift register, or reading BCD time data, the ability to fluently translate between base-2, base-10, and base-16 is the foundational skill that separates hardware tinkerers from embedded engineers.