A binary fractional number is a base-2 value containing a radix point, where digits to the right of the point represent negative powers of two, and converting binary fractional to decimal means summing these positional weights to get a standard base-10 number.
The Core Mechanism: Positional Weights and the Radix Point
Just as a decimal number uses a period to separate whole numbers from tenths, hundredths, and thousandths, a binary number uses a radix point (often just called a binary point) to separate whole powers of two from fractional powers of two. When you move left of the radix point, the value of each bit doubles ($2^0, 2^1, 2^2$). When you move right of the radix point, the value of each bit halves ($2^{-1}, 2^{-2}, 2^{-3}$).
Worked Numeric Example
Let us convert the binary fractional value 110.1011 into a base-10 decimal. We split this at the radix point into the integer part (110) and the fractional part (1011).
| Bit Position | Binary Digit | Weight ($2^x$) | Decimal Contribution |
|---|---|---|---|
| 2 | 1 | 4 | 4.0 |
| 1 | 1 | 2 | 2.0 |
| 0 | 0 | 1 | 0.0 |
| -1 | 1 | 0.5 | 0.5 |
| -2 | 0 | 0.25 | 0.0 |
| -3 | 1 | 0.125 | 0.125 |
| -4 | 1 | 0.0625 | 0.0625 |
Summing the integer contributions (4 + 2 + 0) gives us 6. Summing the fractional contributions (0.5 + 0 + 0.125 + 0.0625) gives us 0.6875. Therefore, the binary fractional 110.1011 is exactly 6.6875 in decimal. For a deeper dive into the underlying boolean mechanics, the Electronics Tutorials guide on binary fractions provides excellent foundational logic tables.
What This Changes in Real Circuits and Installations
Understanding binary fractional math fundamentally changes how you scale sensor data and output analog signals in microcontroller firmware, specifically by allowing you to bypass the Floating Point Unit (FPU). When you read a 12-bit Analog-to-Digital Converter (ADC) on an ESP32-S3, you receive an integer between 0 and 4095. If you need to map that raw integer to a real-world voltage range of 0.0V to 3.3V, the naive approach is floating-point division: voltage = raw_adc * (3.3 / 4095.0).
On basic 8-bit AVR microcontrollers (like the ATmega328P on the Arduino Uno), floating-point math is emulated in software. That single division operation can consume over 100 clock cycles, which is catastrophic if you are running a high-speed Interrupt Service Routine (ISR) for motor commutation or digital filtering. By utilizing fixed-point binary fractional logic, you replace the slow division with rapid bitwise shifts. Shifting a 32-bit integer right by 12 bits (val >> 12) is mathematically identical to dividing by 4096, executing in a single clock cycle. You are effectively treating the lower 12 bits of your integer as a binary fraction, granting you instantaneous, deterministic execution times in time-critical control loops.
Where You Meet This in Practice
You will encounter binary fractional scaling and fixed-point math in several common embedded scenarios:
- PWM Duty Cycle Resolution: When configuring the LEDC peripheral on an ESP32 for high-resolution PWM, the hardware accepts a duty cycle value based on the timer bit-depth. If you set a 10-bit resolution, a duty cycle of
512(binary1000000000) represents exactly 50%. If you need 33.3%, you are calculating a binary fraction of the maximum period, mapping decimal percentages to raw binary weights to avoid jitter on the output pin. - I2C Sensor Compensation: High-precision environmental sensors like the Bosch BME280 output raw ADC data that must be compensated using calibration parameters stored in the chip's PROM. These compensation formulas rely heavily on fixed-point binary fractions (often designated as
t_fineor similar variables in the datasheet) to calculate temperature and pressure without floating-point drift. - Digital Signal Processing (DSP): When implementing Finite Impulse Response (FIR) or Infinite Impulse Response (IIR) filters on an Arduino to clean up noisy load cell data, the filter coefficients are rarely clean decimals. They are binary fractions. Multiplying your signal buffer by these coefficients using bit-shifting is the only way to maintain real-time audio or vibration sampling rates.
0.1 (or $2^{-1}$), which scales to 128 in an 8-bit integer register.
The Most Common Confusion: Binary Fractions vs. IEEE 754 Floats
The most frequent mistake hobbyists make is confusing a raw binary fraction with a 32-bit IEEE 754 floating-point number. They are entirely different architectural concepts.
A binary fraction (like 0.1101) is a direct positional representation. The radix point is fixed, and the value is derived purely by summing the weights of the bits present. It is the mathematical foundation of fixed-point arithmetic.
An IEEE 754 float (the standard float data type in C++) is a scientific notation encoding. It uses 1 bit for the sign, 8 bits for a biased exponent, and 23 bits for a normalized mantissa. There is no 'radix point' sitting in the middle of the 32 bits. When you cast a binary fraction directly into a 32-bit memory space expecting it to be read as a float, you will get garbage data because the microcontroller will interpret your positional bits as an exponent and mantissa. To convert a binary fractional integer to a standard C++ float, you must explicitly cast the integer and multiply it by the scaling factor (e.g., float val = (float)raw_fixed_point / 256.0;). For more on manipulating these bits directly, the Arduino Bit Math documentation is a required reference.
Frequently Asked Questions
How do you convert a repeating binary fractional to decimal?
Just as 1/3 in decimal results in a repeating 0.333..., certain decimal fractions cannot be represented perfectly in binary and result in repeating binary fractions. The most notorious example is decimal 0.1. In binary, 0.1 translates to 0.0001100110011... repeating infinitely. To convert a repeating binary fractional back to decimal, you use the geometric series sum formula: $S = a / (1 - r)$, where $a$ is the value of the first repeating block and $r$ is the positional shift ratio. In practical firmware, you simply truncate or round the repeating fraction to the bit-width of your microcontroller's register (e.g., 16-bit or 32-bit), accepting a microscopic quantization error.
Why does my Arduino output the wrong decimal when converting binary fractions?
This almost always happens due to integer truncation rather than rounding. If you are scaling a 10-bit binary fraction down to an 8-bit register using a right-shift (val >> 2), the microcontroller simply drops the two least significant bits. If those dropped bits represented a value greater than half of the new least significant bit, your decimal output will be slightly lower than the mathematically correct rounded value. To fix this, add a rounding constant before shifting: val = (raw_val + 2) >> 2;. This forces the carry bit to round up the result when the truncated fraction is 0.5 or greater.
What is the fastest way to convert binary fractional to decimal in C++ for microcontrollers?
The fastest method avoids division and floating-point libraries entirely. Use bitwise shift operators combined with integer multiplication. If your binary fraction has 8 fractional bits (meaning your scaling factor is $2^8 = 256$), and you need to display the decimal value on an OLED screen, multiply the integer part by 1000, add the fractional part multiplied by 1000 and shifted right by 8 bits ((frac * 1000) >> 8), and then use integer division to place the decimal point in your string formatting. This keeps the entire pipeline inside the ALU's ultra-fast integer execution units, completely bypassing the FPU or software-emulated float math.
