How to Go From Binary to Decimal: A Practical Guide for Makers

Binary to decimal conversion is the mathematical process of translating a base-2 sequence of 1s and 0s—representing physical HIGH and LOW voltage states in a circuit—into a standard base-10 integer. While translating these states doesn't alter the physical electrons flowing through your traces, it fundamentally changes how you configure microcontroller registers, set hardware addresses, and interpret logic analyzer captures. The most common mistake makers make isn't the math itself; it is confusing binary with hexadecimal when reading datasheets, or misaligning the Most Significant Bit (MSB) and Least Significant Bit (LSB) when flipping physical DIP switches on a breakout board.

The 8-Bit Positional Weight Reference Table

Before running through the math, you need a reference for what each physical pin or bit position actually represents in decimal weight. In an 8-bit system (like a standard microcontroller port or a byte sent over SPI), the rightmost bit is the LSB (weight of 1) and the leftmost is the MSB (weight of 128). Keep this table bookmarked when you are debugging direct port manipulation or reading parallel bus data.

Bit Position	Decimal Weight	Binary State Example	Real-World Hardware Meaning
Bit 7 (MSB)	128	1	UART Stop Bit check / GPIO Pin 7 HIGH
Bit 6	64	0	PWM Channel 6 disabled / Pin 6 LOW
Bit 5	32	1	I2C Address offset A5 (e.g., PCA9685)
Bit 4	16	1	SPI Clock Polarity (CPOL) set to 1
Bit 3	8	0	Interrupt Flag cleared (no fault)
Bit 2	4	1	GPIO Pin 2 Output HIGH (LED ON)
Bit 1	2	0	UART Parity bit (configured for Even)
Bit 0 (LSB)	1	1	Start Bit indicator / Pin 0 HIGH

Note: The total maximum decimal value for an 8-bit unsigned integer is 255 (all bits set to 1). If you are working with 16-bit registers (like the ESP32's GPIO enable registers), the MSB weight scales up to 32,768.

Step-by-Step Numeric Conversion Example

Let's look at a real-world scenario. You are reading a logic analyzer trace of an 8-bit parallel bus, and the captured byte is 10110101. You need to know the decimal value to match it against a sensor's expected output threshold.

The Standard Positional Method:

Write out the binary number and multiply each bit by its corresponding decimal weight from the table above, then sum the results.

• 1 × 128 = 128
• 0 × 64 = 0
• 1 × 32 = 32
• 1 × 16 = 16
• 0 × 8 = 0
• 1 × 4 = 4
• 0 × 2 = 0
• 1 × 1 = 1

Summing the non-zero values: 128 + 32 + 16 + 4 + 1 = 181.

Where You Meet This in Practice

Understanding how to go from binary to decimal is not just an academic exercise; it dictates how you write firmware and wire hardware.

1. Direct Port Manipulation (AVR / Arduino)

If you need to toggle multiple pins on an ATmega328P (Arduino Uno) simultaneously to avoid the overhead of digitalWrite(), you write directly to the PORTD register. If you want to set pins 7, 5, 4, 2, and 0 HIGH, and pins 6, 3, and 1 LOW, your binary mask is 10110101. In your C++ code, you can write this as PORTD = B10110101;, but if you are using a library that only accepts decimal integers for register writes, you must convert it to PORTD = 181;. For a deeper look at AVR register mapping, consult the official Arduino Port Manipulation documentation.

2. ESP32 GPIO Matrices

The ESP32 uses 32-bit registers for GPIO outputs. If you are writing bare-metal ESP-IDF code to set GPIO 5 and GPIO 18 HIGH simultaneously, you are essentially setting Bit 5 (weight 32) and Bit 18 (weight 262,144). The decimal value you write to the GPIO.out_w1ts (write 1 to set) register is 32 + 262,144 = 262176. Misinterpreting the binary bit-shift (1 << 5) as a literal decimal 5 will result in toggling the wrong pins and potentially shorting a misconfigured peripheral. See the Espressif GPIO API Reference for exact register layouts.

3. I2C Address Configuration via DIP Switches

Many industrial sensors and DMX-to-I2C bridges use physical 8-position DIP switches to set the device address. If the datasheet states the base address is 0x40 (64 in decimal) and the switches add an offset based on their binary state, flipping switches 1, 3, and 5 (assuming LSB-first wiring) yields a binary offset of 00010101 (21 in decimal). Your final I2C address becomes 64 + 21 = 85 (0x55 in hex).

Endianness and Common Datasheet Pitfalls

The most frequent point of failure when converting binary to decimal for hardware configuration is endianness—the order in which bits are transmitted or physically wired.

Consider the ubiquitous 74HC595 shift register. When you use the Arduino shiftOut() function, you must specify either MSBFIRST or LSBFIRST. If you send the decimal value 128 (binary 10000000) using MSBFIRST, the first bit shifted out is the 1, which ends up on the Q7 output pin (the last physical pin in the chain). If you wired your LEDs sequentially from Q0 to Q7 expecting the '1' to light up the first LED, it will actually light up the last one. Always verify the shift direction in the datasheet (like the Texas Instruments SN74HC595 datasheet) before converting your decimal target into a binary array.