Converting the standard 8-bit binary number 11010110 to decimal yields exactly 214. Whether you are debugging an I2C sensor payload on an ESP32 or reading raw GPIO states on an Arduino, base-2 to base-10 translation is a fundamental bench skill. The formula used with values substituted for this specific byte is: 214 = (1×2⁷) + (1×2⁶) + (0×2⁵) + (1×2⁴) + (0×2³) + (1×2²) + (1×2¹) + (0×2⁰), which simplifies to 128 + 64 + 0 + 16 + 0 + 4 + 2 + 0.
The Core Formula and Worked Example
The binary (base-2) system relies on positional weighting, where each bit represents a power of 2, starting from 2⁰ (which equals 1) at the Least Significant Bit (LSB) on the far right, and increasing as you move left toward the Most Significant Bit (MSB). To convert any binary string to decimal, you multiply each bit by its positional weight and sum the results.
11010110, simply add the powers of 2 where a '1' is present: 128 (bit 7) + 64 (bit 6) + 16 (bit 4) + 4 (bit 2) + 2 (bit 1) = 214.
In embedded systems, you rarely do this math in your head for 32-bit registers. Instead, you rely on bitwise operations. For instance, if you are reading the GPIO_IN_REG on an ESP32 microcontroller and bit 4 is high, that specific pin contributes exactly 16 to the total decimal register value. Understanding this positional weight is critical when masking bits using the AND operator (e.g., reg & 0x10).
Assumptions That Fix Your Answer (and When It Shifts)
Unlike AC power calculations where voltage, power factor (pf), and phase angle fix your result, binary-to-decimal conversion relies on a different set of assumptions: bit-width, endianness, and signing method (unsigned vs. two's complement). If you assume an 8-bit unsigned integer, 11010110 is exactly 214. However, if you assume an 8-bit signed integer (two's complement), that exact same binary string represents -42. Presenting a single 8-bit unsigned conversion as a universal truth is a common beginner mistake; always define your register width and signing method before finalizing your decimal output.
How the Answer Shifts Across Bit-Widths
Just as calculating wattage shifts drastically for 120V vs 230V vs 3-phase systems, your decimal ceiling shifts based on register size. An 8-bit register caps at 255. A 16-bit register caps at 65,535. If you are reading a 16-bit I2C sensor (like the MPU6050 accelerometer) but your code accidentally truncates the upper byte, your decimal answer shifts from the true physical measurement to a heavily aliased fraction. Always verify if your sensor transmits MSB-first (Big-Endian) or LSB-first (Little-Endian) before combining bytes into a final decimal value.
When the Conversion is Meaningless
A direct polynomial base-2 to base-10 conversion is meaningless if the binary string represents an IEEE 754 floating-point number or Binary-Coded Decimal (BCD). For example, the binary sequence 0100 0001 converts to 65 in standard base-2 math. But if that byte is part of a 32-bit IEEE 754 float payload from a serial sensor, those bits represent the sign and exponent, not a direct integer. Similarly, in BCD (often used in Real-Time Clock modules like the DS3231), 0100 0001 translates to the decimal number 41, not 65. Always check the datasheet encoding scheme before applying the standard formula.
Neighboring Values Reference Table (±20% Range)
When debugging digital logic analyzers or oscilloscope captures, having a quick reference for neighboring values saves time. Below is a spec-sheet-style table covering the ±20% range around our target value of 214 (spanning roughly 171 to 255), focusing on the upper quadrant of an 8-bit unsigned byte.
| Decimal | 8-Bit Binary | Hexadecimal | Common Embedded Use Case |
|---|---|---|---|
| 170 | 10101010 | 0xAA | Standard I2C/SPI test pattern (alternating bits) |
| 192 | 11000000 | 0xC0 | Top 2 bits set (often used for 2-bit status flags) |
| 204 | 11001100 | 0xCC | Alternating nibbles (useful for clock signal testing) |
| 214 | 11010110 | 0xD6 | Target example value |
| 224 | 11100000 | 0xE0 | Top 3 bits set (e.g., SPI clock divider masks) |
| 240 | 11110000 | 0xF0 | Upper nibble mask (isolating high 4 bits of a byte) |
| 255 | 11111111 | 0xFF | Max 8-bit value (all pins HIGH, pull-up enabled) |
Note: For a deeper dive into binary arithmetic and logic gates, refer to the All About Circuits Digital Textbook.
Frequently Asked Questions
How to convert binary numbers to decimal with a fractional point?
When dealing with fixed-point math in DSP (Digital Signal Processing) or audio DACs, bits to the right of the binary point represent negative powers of 2. For example, 101.11 converts to: (1×2²) + (0×2¹) + (1×2⁰) + (1×2⁻¹) + (1×2⁻²). This equals 4 + 0 + 1 + 0.5 + 0.25 = 5.75. The formula remains the same; only the exponent signs change across the radix point.
How to convert binary numbers to decimal in Arduino C++ without manual math?
You do not need to write a custom loop to parse binary strings in C++. If you have a binary string (e.g., from a Serial input), use the standard library function strtol(). For example: long val = strtol("11010110", NULL, 2); will instantly return the decimal 214. If you are working with native binary literals in your code, simply prefix the number with 0b (e.g., int x = 0b11010110;), and the compiler handles the decimal conversion at build time. See the Arduino Byte Reference for data type limits.
Why does my 8-bit binary conversion output a negative decimal?
If your MSB (bit 7) is a 1 and your system interprets the variable as a signed 8-bit integer (like the int8_t data type in C++), the system uses two's complement. In two's complement, the MSB carries a negative weight of -128 instead of +128. Therefore, 11010110 becomes -128 + 64 + 16 + 4 + 2 = -42. To force a positive decimal output, cast the variable to an unsigned type: uint8_t or byte.
How to convert binary numbers to decimal for 32-bit IP subnet masks?
Network engineers frequently convert 32-bit binary strings into dotted-decimal notation for subnetting. You cannot convert the entire 32-bit string into one massive decimal number for an IP address. Instead, split the binary string into four 8-bit octets, convert each octet to decimal individually, and separate them with periods. For example, the binary subnet mask 11111111 11111111 11111111 00000000 converts octet-by-octet to 255.255.255.0.
