How to Turn Binary into Decimal: A Hardware Maker's Guide

Binary to decimal conversion is the mathematical process of translating a base-2 number system (using only 0s and 1s to represent off/on states) into the base-10 number system humans use for counting. When you are staring at a logic analyzer trace or flipping tiny switches on a stepper driver, this translation bridges the gap between physical hardware states and the integer variables in your microcontroller code. In a real circuit, this conversion dictates how a microcontroller's GPIO bank or serial peripheral interprets a physical array of HIGH (3.3V/5V) and LOW (0V) voltage states into a single, actionable integer for memory addressing, motor control, or logic branching.

The Core Math: How to Turn Binary into Decimal

Unlike the decimal system, which uses ten digits (0-9) and positional powers of 10, binary uses only two digits (0 and 1) and positional powers of 2. Each position in a binary string represents a specific power of 2, starting from $2^0$ (which equals 1) on the far right and doubling as you move left. This rightmost bit is the Least Significant Bit (LSB), and the leftmost is the Most Significant Bit (MSB).

To convert a binary number to decimal, you multiply each bit by its positional weight and sum the results. Let us look at a worked numeric example using an 8-bit byte commonly seen in microcontroller registers.

Worked Example: Converting 10110101

1. Write down the positional weights: For an 8-bit number, the weights from left to right are 128, 64, 32, 16, 8, 4, 2, 1.
2. Align the binary string: Place 10110101 under the weights.
3. Multiply and filter: If the bit is 1, keep the weight. If the bit is 0, the value is 0.
   • 1 × 128 = 128
   • 0 × 64 = 0
   • 1 × 32 = 32
   • 1 × 16 = 16
   • 0 × 8 = 0
   • 1 × 4 = 4
   • 0 × 2 = 0
   • 1 × 1 = 1
4. Sum the active weights: 128 + 32 + 16 + 4 + 1 = 181.

The binary byte 10110101 equals the decimal integer 181. If you were writing this in C++ for an ESP32, you would represent it as 0b10110101 or 181, and the compiler treats them identically.

Where You Meet This in Practice

Abstract math becomes physical reality the moment you wire up components that rely on hardware-level configuration. Here is where binary-to-decimal translation physically manifests on your workbench:

• Stepper Motor Drivers (e.g., DM542T): These drivers use banks of physical DIP switches to set the peak current and microstepping resolution. Switch 1 through 3 might represent a 3-bit binary number. If switches 1 and 3 are ON (1) and switch 2 is OFF (0), the binary is 101, which translates to a decimal 5. You then cross-reference decimal 5 on the manufacturer's current table to confirm you are feeding the motor 2.8A.
• I2C Address Configuration: Breakout boards like the MCP23017 16-channel GPIO expander feature physical jumpers or solder pads (A0, A1, A2) to set the I2C bus address. The base address is 0x20 (decimal 32). If you bridge A0 and A2 to VCC (binary 101 = decimal 5), the final I2C address becomes 32 + 5 = 37 (or 0x25 in hex).
• PWM and DAC Registers: When writing directly to hardware registers (like the LEDC peripheral on an ESP32), you are writing decimal values that map to binary bitmasks to set duty cycles. An 8-bit resolution means a decimal value of 255 (binary 11111111) yields a 100% duty cycle.

Real-World Scenario Walkthrough: The Shift Register Endianness Trap

The most common point of failure when dealing with binary hardware is not the math itself, but the order in which the bits are transmitted. Let us walk through a classic bench headache.

The Setup

You are wiring a 74HC595 shift register to an ESP32 WROOM-32 to control a bank of 8 relays. The ESP32 sends data serially via the shiftOut() function, and the 74HC595 converts that serial stream into 8 parallel HIGH/LOW outputs (Q0 through Q7).

The Numbers

You want to turn on Relays 1, 4, and 7. Looking at your schematic, you map this to the binary string 10010010. You do the math: 128 + 16 + 2 = 146. You write the code: shiftOut(dataPin, clockPin, MSBFIRST, 146);.

The Outcome

You upload the code, but the wrong relays click on. Instead of Relays 1, 4, and 7 activating, Relays 2, 5, and 8 engage. The hardware is wired correctly, and the math is correct, but the physical behavior is inverted.

What Went Wrong

This is an endianness collision. The 74HC595 datasheet dictates that the first bit shifted into the serial input (SER pin) ends up at the Q7 output pin, and the last bit shifted in ends up at Q0. If your code uses MSBFIRST (Most Significant Bit First), the leftmost 1 (weight 128) is pushed into the register first and lands on Q7. However, if your physical wiring assumes Q0 is Relay 1 and Q7 is Relay 8, your bit order is backward relative to your mental model. The fix is either to change the code to LSBFIRST or to recalculate the decimal value by reversing the binary string to 01001001 (decimal 73). Always verify shift register bit-order against the specific silicon datasheet, not just the Arduino reference page.

Common Confusions: Hex, BCD, and Bit Significance

When reading schematics or debugging serial output, makers frequently confuse pure binary with other base systems that look similar but behave entirely differently in a circuit.

Binary vs. Hexadecimal

Hexadecimal (base-16) is simply a human-readable shorthand for binary. Because 16 is $2^4$, exactly four binary bits map to one hex character. The binary 10110101 is split into 1011 (11, or B) and 0101 (5), resulting in 0xB5. Hex does not change the circuit's behavior; it just saves screen space in your IDE.

Binary Coded Decimal (BCD)

This is where hardware actually changes. Older Real-Time Clock (RTC) modules like the DS1307 store time data in BCD format, not pure binary. In BCD, each decimal digit (0-9) is isolated into its own 4-bit nibble.

If the RTC reads 45 seconds, it does not store the pure binary for 45 (00101101). Instead, it stores the tens digit (4) and the ones digit (5) separately as 0100 0101. If you read this register as a standard binary byte, your microcontroller will interpret 01000101 as decimal 69, leading you to believe there are 69 seconds in a minute. You must use a BCD-to-decimal conversion algorithm (like val = (reg >> 4) * 10 + (reg & 0x0F);) to get the correct time.

Quick Reference: 8-Bit Powers and Bitmasks

Memorizing the powers of 2 up to 128 will save you immense time when reading logic analyzer traces or setting hardware jumpers. Keep this table handy at your bench.