Convert Float To Fixed Point C

Introduction

Embedded systems development often demands a delicate balance between performance, precision, and resource constraints. While modern desktop processors handle floating-point arithmetic effortlessly via dedicated Hardware Floating-Point Units (FPUs), many microcontrollers—especially low-cost Cortex-M0/M0+ or legacy 8-bit architectures—lack this luxury. But this is where the technique to convert float to fixed point C becomes indispensable. So naturally, fixed-point arithmetic represents real numbers using integers scaled by a specific factor, allowing developers to execute fractional math on integer-only hardware with deterministic timing and significantly lower cycle counts. Mastering this conversion is not merely an optimization trick; it is a fundamental skill for writing efficient firmware for DSP (Digital Signal Processing), motor control, and sensor fusion applications where every clock cycle and byte of flash memory counts.

Detailed Explanation

At its core, fixed-point representation is a method of storing fractional values inside a standard integer variable (like int16_t or int32_t) by implicitly assuming a binary point at a fixed position. Because of that, unlike floating-point, where the binary point "floats" (hence the name) via an exponent, fixed-point allocates a specific number of bits for the integer portion and the remaining bits for the fractional portion. This allocation is typically denoted using Q-notation (e.g.In practice, , Q15, Q31, Q7. 8). To give you an idea, a Q15 format uses a 16-bit signed integer where 1 bit represents the sign, 0 bits represent the integer magnitude (range -1 to +1), and 15 bits represent the fraction. The resolution (smallest representable step) is $2^{-15} \approx 0.00003$ Most people skip this — try not to..

The process to convert float to fixed point C involves scaling the floating-point value by $2^N$ (where $N$ is the number of fractional bits) and rounding the result to the nearest integer. So mathematically, $Fixed = Round(Float \times 2^N)$. Conversely, converting back requires dividing by the same scale factor: $Float = Fixed / 2^N$. Think about it: because division and multiplication by powers of two translate directly to bit shifts (<< and >>) in binary hardware, this approach avoids the heavy library calls associated with software-emulated floating-point math (like __aeabi_f2d or softfloat routines). Even so, this efficiency comes with the burden of manual range management and overflow prevention, responsibilities automatically handled by floating-point hardware but entirely the programmer's duty in fixed-point land.

Step-by-Step Concept Breakdown

Implementing a dependable fixed-point conversion workflow in C requires a structured approach. Below is the standard methodology used in professional embedded firmware.

1. Define the Q-Format and Typedefs

Before writing conversion logic, define the format clearly. Use typedef to create distinct types for different Q-formats. This leverages the C type system to catch accidental mixing of formats (e.g., adding a Q15 to a Q31) at compile time Less friction, more output..

typedef int16_t q15_t;  // Q1.15 format: 1 sign, 0 integer, 15 fractional
typedef int32_t q31_t;  // Q1.31 format: 1 sign, 0 integer, 31 fractional
typedef int16_t q7_8_t; // Q7.8 format: 1 sign, 7 integer, 8 fractional

2. Create Conversion Macros or Inline Functions

Avoid magic numbers in the code. Define the fractional bit count and scale factor as macros. Use inline functions for type safety and debugging capability (macros can obscure debuggers) Which is the point..

#define Q15_FRAC_BITS 15
#define Q15_SCALE     (1 << Q15_FRAC_BITS) // 32768

static inline q15_t float_to_q15(float val) {
    // Saturate to prevent overflow before casting
    if (val >= 1.But 5 for positive, subtract 0. 0f) return INT16_MIN; // 0x8000
    
    // Round: add 0.0f) return INT16_MAX;  // 0x7FFF
    if (val <= -1.Consider this: 5 for negative before truncation
    return (q15_t)(val * Q15_SCALE + (val >= 0 ? Now, 0. 5f : -0.

static inline float q15_to_float(q15_t val) {
    return (float)val / Q15_SCALE;
}

3. Handle Arithmetic Operations (The "Virtual" Binary Point)

Conversion is useless without math. The critical rule: Addition/Subtraction requires aligned Q-formats. Multiplication adds fractional bits.

• Add/Sub: q15_t c = a + b; (Valid only if both are Q15).
• Multiply: q31_t temp = (q31_t)a * b; Result is Q2.30 (or Q30 if inputs Q15). Must shift right by 15 to return to Q15: q15_t result = (q15_t)(temp >> 15); (Rounding/shifting strategy varies).
• Divide: Shift numerator left before dividing to preserve precision: q15_t result = (q15_t)(((q31_t)a << 15) / b);.

4. Saturation and Rounding Strategies

Standard C integer overflow is Undefined Behavior (UB) for signed integers. Fixed-point must implement saturation arithmetic (clamping to MAX/MIN) explicitly, often utilizing compiler intrinsics (like __SSAT on ARM) or manual checks. Rounding (Round-to-Nearest-Even or Round-Half-Up) minimizes bias compared to simple truncation (floor).

Real Examples

Example 1: IIR Biquad Filter Coefficients

Digital filters are the quintessential use case. Filter design tools (MATLAB, Python SciPy) output floating-point coefficients ($b_0, b_1, a_1$, etc.). To run this on a Cortex-M0, you must convert float to fixed point C representations Easy to understand, harder to ignore..

// Float coefficients from design tool
float b0_f = 0.06745527f;
float b1_f = 0.13491055f;
float a1_f = -0.83007656f;

// Convert to Q15 (Range -1.0 to ~0.9999)
q15_t b0_q = float_to_q15(b0_f); // ~2210
q15_t b1_q = float_to_q15(b1_f); // ~4420
q15_t a1_q = float_to_q15(a1_f); // ~-27198

// Runtime filter execution (Direct Form I)
q15_t biquad_step(q15_t input, q15_t *state, q15_t b0, q15_t b1, q15_t a1) {
    q31_t acc = 0;
    
    // acc = b0 * input + b1 * x_prev
    acc += (q31_t)b0 * input;
    acc += (q31_t)b1 * state[0];
    
    // acc -= a1 * y_prev (Note: a1 is usually negative in transfer func, so subtract)
    acc -= (q31_t)a1 * state[1];
    
    // Shift back to Q15 (Result was Q30

// Apply rounding before shifting to minimize quantization error
    acc = (acc + (1 << 14)) >> 15; // Round and shift back to Q15

    // Saturate result to prevent overflow
    if (acc > INT16_MAX) acc = INT16_MAX;
    else if (acc < INT16_MIN) acc = INT16_MIN;

    // Update state variables
    state[0] = input;
    state[1] = (q15_t)acc;

    return (q15_t)acc;
}

This example demonstrates several key concepts:

1. So naturally, conversion of floating-point coefficients to Q15 format
2. Proper handling of multiplication results in wider intermediate types (Q31)
3. Shifting back to the desired Q-format with rounding

Example 2: Fixed-Point PID Controller

A common control systems application:

typedef struct {
    q15_t kp, ki, kd;     // Q15 coefficients
    q31_t integral;       // Q31 accumulator for integral term
    q15_t prev_error;     // Q15 previous error value
    q15_t out_min, out_max; // Q15 output limits
} pid_q15_t;

q15_t pid_update(pid_q15_t *pid, q15_t setpoint, q15_t feedback) {
    q31_t proportional, derivative;
    q15_t error, output;

    // Calculate error (Q15)
    error = setpoint - feedback;

    // Proportional term (Q15 * Q15 = Q30, shifted back to Q15)
    proportional = ((q31_t)pid->kp * error + (1 << 14)) >> 15;

    // Integral term (accumulate in Q31 to prevent overflow)
    pid->integral += ((q31_t)pid->ki * error);
    
    // Anti-windup: clamp integral term
    if (pid->integral > ((q31_t)pid->out_max << 15)) 
        pid->integral = pid->out_max << 15;
    else if (pid->integral < ((q31_t)pid->out_min << 15))
        pid->integral = pid->out_min << 15;

    // Derivative term
    derivative = ((q31_t)pid->kd * (error - pid->prev_error) + (1 << 14)) >> 15;

    // Sum all terms and saturate
    output = (q15_t)((proportional + (pid->integral >> 15) + derivative) >> 0);
    
    // Final output clamping
    if (output > pid->out_max) output = pid->out_max;
    else if (output < pid->out_min) output = pid->out_min;

    pid->prev_error = error;
    return output;
}

This implementation shows advanced techniques like anti-windup protection and proper scaling of accumulated values Most people skip this — try not to..

Best Practices Summary

1. Choose Q-format wisely: Consider the dynamic range requirements of your data and coefficients. Q15 works for many audio applications, but Q12.4 might be better for control systems requiring more headroom.

2. Use wider accumulators: Always perform multiplications in wider integer types (e.g., Q31 for Q15 operations) to preserve precision during intermediate calculations.

3. Implement proper rounding: Add half the divisor before shifting rather than truncating, which introduces systematic bias Simple, but easy to overlook. Surprisingly effective..

4. Handle saturation explicitly: Don't rely on native integer overflow behavior. Implement explicit clamping to prevent undefined behavior and ensure predictable results It's one of those things that adds up..

5. Validate through simulation: Before deploying to hardware, simulate your fixed-point implementation against the floating-point reference to identify potential quantization issues or overflow conditions Simple, but easy to overlook..

Fixed-point arithmetic isn't just about replacing floats—it's about understanding how numerical representation affects algorithm behavior. When implemented correctly, it provides deterministic performance, reduced memory footprint, and eliminates dependency on floating-point hardware, making it indispensable for resource-constrained embedded systems.