To convert the standard 8-bit binary sequence 11001010 to a decimal number, the direct answer is 202 (if interpreted as an unsigned integer) or -54 (if interpreted as a signed two's complement integer). The universal base-2 formula used to reach this is Decimal = Σ(bit × 2^position). Substituting our specific values for 11001010 (reading right-to-left from position 0 to 7), the math looks like this: (1×128) + (1×64) + (0×32) + (0×16) + (1×8) + (0×4) + (1×2) + (0×1) = 202.

While the base math is straightforward, raw binary is just a sequence of high and low logic states. Just as calculating amperage from wattage requires knowing whether you are on a 120V single-phase or 208V 3-phase system, converting binary to a usable number requires knowing the data format. Below is the complete breakdown of how to execute the conversion, what assumptions lock in your answer, and how to avoid bricking your microcontroller logic with misinterpreted sensor data.

The Core Formula and Step-by-Step Substitution

The foundation of binary-to-decimal conversion is positional weighting. Each bit represents a power of 2, starting at 2^0 on the far right (the Least Significant Bit, or LSB) and increasing as you move left to the Most Significant Bit (MSB).

Bench Tip: When reading binary off a logic analyzer like a Saleae Logic Pro, always confirm the bit-ordering. Most standard textbooks read MSB-to-LSB (left-to-right), but some shift registers clock out LSB-first. Reversing the string 11001010 to 01010011 changes your answer from 202 to 83.

Let us break down the substitution for an 8-bit unsigned integer using 10110101 as a second worked example:

  • Bit 7 (MSB): 1 × 2^7 = 128
  • Bit 6: 0 × 2^6 = 0
  • Bit 5: 1 × 2^5 = 32
  • Bit 4: 1 × 2^4 = 16
  • Bit 3: 0 × 2^3 = 0
  • Bit 2: 1 × 2^2 = 4
  • Bit 1: 0 × 2^1 = 0
  • Bit 0 (LSB): 1 × 2^0 = 1

Total Sum: 128 + 32 + 16 + 4 + 1 = 181.

What Assumption Fixes the Answer? (Bit-Width and Signedness)

A raw binary string is meaningless without a defined format assumption. The answer shifts drastically depending on the bit-width and whether the system expects signed or unsigned data. Here is how the interpretation changes across common embedded formats:

8-Bit vs. 16-Bit vs. 32-Bit Shifts

If you receive the binary payload 11111111 over an I2C bus, the decimal answer depends entirely on the register width defined in the sensor's datasheet:

  • 8-bit Unsigned: The answer is 255.
  • 16-bit Unsigned (padded): If it is the lower byte of a 16-bit register (00000000 11111111), the answer is still 255.
  • 8-bit Signed (Two's Complement): The MSB acts as a negative weight (-128). The calculation becomes -128 + 127 = -1.

When the Conversion is Meaningless

Converting binary to a standard integer becomes mathematically meaningless in two specific scenarios:

  1. Missing Endianness Context: If you read a 16-bit value as 00110100 00010010 but do not know if the device uses Big-Endian or Little-Endian byte order, your answer could be 13,330 or 4,660. Without the datasheet, the conversion is a guess.
  2. IEEE 754 Floating Point Data: If a 32-bit binary sequence represents an IEEE 754 float (like GPS coordinates or temperature from a BME280 sensor), applying the standard integer sum formula yields a garbage number like 1,104,609,280 instead of the actual value 24.5. You must use a float-union cast in C/C++ to interpret the sign bit, 8-bit exponent, and 23-bit mantissa correctly. See the IEEE 754-2019 standard documentation for the exact bit-mapping.

Neighboring Values Reference Table

When debugging ADC (Analog-to-Digital Converter) outputs or encoder positions, it helps to see how the binary shifts around your target number. Below is a reference table for values neighboring our anchor unsigned integer 202 (11001010), covering a ±10 decimal range.

Decimal 8-Bit Binary Hexadecimal Two's Complement (Signed)
192110000000xC0-64
197110001010xC5-59
201110010010xC9-55
202110010100xCA-54
203110010110xCB-53
208110100000xD0-48
212110101000xD4-44

Decision Tree: Which Format Should You Pick?

Use this decision path to determine exactly how to parse incoming binary data in your Arduino, ESP32, or Raspberry Pi code. Follow the conditions down to lock in your concrete data type.

Condition / Data Source If True... Concrete Pick (C/C++ Data Type)
Is the data a simple GPIO state, PWM duty cycle, or 8-bit DAC value? Values will never drop below zero. Max value is 255. uint8_t (Unsigned 8-bit)
Is the data from an audio DSP, accelerometer axis, or motor encoder? Values must represent negative direction or phase. Max magnitude is ~32,768. int16_t (Signed 16-bit)
Is the data a raw 24-bit ADC reading (like from an INA219 or HX711)? The 24th bit dictates sign, but standard C types are 16 or 32-bit. Requires sign-extension. int32_t (with manual 24-bit sign extension)
Is the data a precise physical measurement (temperature, pressure, GPS)? The sensor datasheet specifies 'Float' or 'IEEE 754' payload. float (Parsed via memcpy or union)
Warning: Never cast a signed integer directly to an unsigned integer of the same width without checking the sign bit. If your ESP32 reads a signed -1 from a temperature sensor and casts it to a uint16_t, your code will interpret it as 65535, potentially triggering an over-temperature shutdown fault.

Common Embedded System Pitfalls and FAQ

Why does my 16-bit binary conversion yield the wrong decimal on my Arduino?

This is almost always an endianness mismatch. Microcontrollers like the ATmega328P (Arduino Uno) and ESP32 are Little-Endian, meaning the least significant byte is stored at the lowest memory address. If you read a 16-bit register from an I2C sensor that transmits Big-Endian (like many Bosch or Sensirion sensors), you must swap the bytes in software before converting. Use the formula: value = (wire_read_MSB() << 8) | wire_read_LSB();. For a deeper dive into byte ordering, refer to this All About Circuits guide on endianness.

How do I handle Two's Complement manually without built-in functions?

If you are writing low-level bit-banging code and need to convert a signed binary string manually: leave all bits up to the MSB alone, calculate their positive decimal sum, and then subtract the weight of the MSB instead of adding it. For a 4-bit example of 1011: the MSB (8) is subtracted, and the remaining bits (2 + 1) are added. -8 + 2 + 1 = -5. This matches the hardware logic of ALUs inside your microcontroller.

What happens if I read a 32-bit float as a 32-bit integer?

The binary sequence for the float 12.5 is 01000001 01001000 00000000 00000000. If you force a standard decimal conversion on this exact sequence treating it as an unsigned 32-bit integer, the math yields 1,095,237,632. This is a catastrophic failure in control loops. Always verify the sensor datasheet's payload format before writing your parsing function.