How to Master the Conversion of Fractional Decimal to Binary for Microcontrollers

The conversion of a fractional decimal to binary is the mathematical process of translating the non-integer portion of a base-10 number into a base-2 sequence by repeatedly multiplying the fraction by 2 and recording the integer carry bits. In real-world circuits and embedded installations, this conversion is not just academic; it dictates the exact voltage steps in Digital-to-Analog Converters (DACs), determines the quantization error floor in Analog-to-Digital Converters (ADCs), and defines the precise duty cycle registers on microcontrollers like the ESP32 or STM32. When you command a motor driver to run at exactly 33.3% speed or configure a 12-bit ADC to read a 3.3V reference, you are relying on the hardware's ability to map fractional decimals into finite binary registers.

The Core Algorithm and Reference Tables

While the integer portion of a decimal number is converted to binary using the "divide by 2" method, the fractional portion requires the "multiply by 2" algorithm. You take the decimal fraction, multiply it by 2, and record the integer part of the result (which will always be 0 or 1) as the next binary bit. You then take the remaining fractional part and repeat the process until the fraction reaches zero or you hit your hardware's bit-depth limit.

Below is the step-by-step conversion table for the decimal fraction 0.6875, demonstrating how the algorithm terminates cleanly.

Because hardware registers rely on fixed binary weights, it is highly useful to memorize or reference the standard fractional binary equivalents. The table below maps common base-10 fractions to their base-2 representations and their corresponding voltage output on a standard 5.0V reference DAC.

Worked Numeric Example: The 0.1 Decimal Trap

In embedded C and C++, developers frequently attempt to use 0.1 as a clean incremental step for timing loops or motor ramp-ups. However, the conversion of fractional decimal 0.1 to binary reveals a critical hardware limitation: it does not terminate.

Let us run the multiply-by-2 algorithm on 0.1:

• 0.1 × 2 = 0.2 (Bit: 0)
• 0.2 × 2 = 0.4 (Bit: 0)
• 0.4 × 2 = 0.8 (Bit: 0)
• 0.8 × 2 = 1.6 (Bit: 1, remainder 0.6)
• 0.6 × 2 = 1.2 (Bit: 1, remainder 0.2)
• 0.2 × 2 = 0.4 (Bit: 0) ← The sequence 0011 now repeats infinitely.

The binary representation of 0.1 is 0.0001100110011... repeating forever. According to the IEEE 754 standard for floating-point arithmetic, a standard 32-bit float on an Arduino or ESP32 must truncate this sequence at 23 bits. This truncation means the stored value is actually 0.100000001490116119384765625. If you accumulate this value in a while loop to trigger a relay at exactly 1.0 seconds, the relay will fire late due to compounded quantization drift. In safety-critical or precision-timing loops, always use integer math (e.g., counting milliseconds) rather than fractional float accumulation.

Where You Meet This in Practice

The most common jobsite and bench scenarios where you must manually calculate fractional decimal to binary conversions involve configuring Pulse Width Modulation (PWM) and interpreting ADC datasheets.

ESP32 PWM Duty Cycle Configuration

When configuring the LEDC peripheral on an ESP32-WROOM-32, you define a timer resolution. If you select a 10-bit resolution, the hardware register accepts values from 0 to 1023. Suppose your project requires a cooling fan to run at exactly 68.75% capacity. You convert 0.6875 to binary (0.1011), but the hardware doesn't take the raw fraction; it takes the integer mapped to the resolution depth.

// ESP32 Arduino Core PWM Configuration
const int pwmChannel = 0;
const int pwmFreq = 25000; // 25kHz for PC fan
const int pwmResolution = 10; // 10-bit resolution (0-1023)

void setup() {
  ledcSetup(pwmChannel, pwmFreq, pwmResolution);
  ledcAttachPin(25, pwmChannel); // GPIO 25
  
  // 68.75% duty cycle derived from fractional conversion
  int dutyCycle = (int)(0.6875 * pow(2, pwmResolution)); 
  ledcWrite(pwmChannel, dutyCycle);
}

ADC Quantization and LSB Voltage

When reading sensors, the Espressif ESP-IDF documentation and various silicon datasheets define resolution in bits. A 12-bit ADC reading a 3.3V nominal rail has 4096 discrete steps. The Least Significant Bit (LSB) represents the smallest fractional voltage change the ADC can detect. By converting the fraction 1/4096 to decimal (0.00024414), we find the LSB voltage is 3.3V × 0.00024414 = 0.805 mV. If your sensor outputs a 2 mV change per degree Celsius, your binary readout will jump by roughly 2 to 3 integer steps per degree, defining your absolute temperature resolution.

Common Confusions and Mistakes to Avoid

When working with base conversions at the bench, hobbyists and junior engineers frequently fall into two specific traps:

1. Confusing the Integer and Fractional Algorithms: The most common mistake is attempting to use the "divide by 2 and record the remainder" method on the fractional part of a number. Division is strictly for the left side of the decimal point (the integer). The right side of the decimal point (the fraction) strictly requires multiplication by 2 and recording the carry. Mixing these up will yield completely invalid binary strings that will brick your register configurations.
2. Assuming All Decimals Terminate: As demonstrated with 0.1, many clean-looking base-10 decimals result in infinitely repeating binary fractions. Only fractions that can be expressed as a sum of inverse powers of 2 (e.g., 0.5, 0.25, 0.75, 0.125) terminate cleanly. If your target decimal is something like 0.3 or 0.6, you must explicitly decide how many bits of precision your hardware supports and truncate the math accordingly, accepting the resulting quantization error.