Optimizing Fixed-Point Calculations on ARM Cortex-M4 Without FPU Using CMSIS-DSP

Fixed-Point Arithmetic Challenges on Cortex-M4 Without FPU

When working with ARM Cortex-M4 microcontrollers that lack a Floating-Point Unit (FPU), such as the nrf52810, developers often face significant challenges in performing efficient fractional and trigonometric calculations. The absence of an FPU means that floating-point operations are emulated in software, leading to increased computational overhead and slower execution times. This becomes particularly problematic in real-time applications, such as robotics or sensor data processing, where timely and accurate calculations are critical.

The CMSIS-DSP library provides a powerful set of tools for fixed-point arithmetic, which can significantly improve performance on FPU-less Cortex-M4 devices. However, leveraging these tools effectively requires a deep understanding of fixed-point representation, the Q-format, and the specific functions provided by the CMSIS-DSP library. Missteps in implementation can lead to incorrect results, overflow issues, or even performance degradation.

In this guide, we will explore the core issues surrounding fixed-point arithmetic on Cortex-M4 without an FPU, identify potential pitfalls, and provide detailed steps to optimize calculations using the CMSIS-DSP library.

Misuse of Q-Format and CMSIS-DSP Functions

One of the most common issues when transitioning from floating-point to fixed-point arithmetic is the improper use of the Q-format. The Q-format is a fixed-point representation where a fixed number of bits are allocated for the integer and fractional parts of a number. For example, in Q31 format, 31 bits are used for the fractional part, and 1 bit is used for the sign. This allows for a range of -1 to 1 – 2^-31, with a precision of 2^-31.

The confusion often arises when developers attempt to map floating-point values directly to Q-format without considering the range and precision limitations. For instance, in the provided example, the developer attempts to convert floating-point values like 30.02 and 12.76 to Q31 format by dividing them by 1000. This approach is flawed because it does not account for the fact that Q31 values must lie within the range of -1 to 1. Dividing by 1000 ensures that the values fall within this range, but it also reduces the precision of the original values, leading to potential inaccuracies in the final result.

Another issue is the misuse of CMSIS-DSP functions. The CMSIS-DSP library provides functions like arm_float_to_q31, arm_mult_q31, and arm_q31_to_float to convert between floating-point and fixed-point formats and perform arithmetic operations. However, these functions must be used correctly to avoid errors. For example, the developer in the provided example incorrectly uses arm_float_to_q31 to convert both ValA and ValB to Q31 format, but mistakenly assigns the result of the second conversion to ValA_Q31 instead of ValB_Q31. This kind of error can lead to incorrect calculations and is difficult to debug.

Optimizing Fixed-Point Calculations with CMSIS-DSP

To address these issues, it is essential to follow a systematic approach to fixed-point arithmetic using the CMSIS-DSP library. The first step is to understand the range and precision requirements of the application. For example, if the sensor data being processed has a range of -1000 to 1000, it may be more appropriate to use Q15 format instead of Q31. Q15 format provides a range of -1 to 1 – 2^-15, with a precision of 2^-15, which may be sufficient for many sensor applications.

Once the appropriate Q-format is selected, the next step is to correctly convert floating-point values to fixed-point format. This involves scaling the floating-point values to fit within the range of the chosen Q-format. For example, if using Q15 format, the floating-point values should be divided by 32768 (2^15) to ensure they fall within the range of -1 to 1. The CMSIS-DSP function arm_float_to_q15 can be used for this purpose.

After converting the values to fixed-point format, arithmetic operations can be performed using the appropriate CMSIS-DSP functions. For example, multiplication of two Q15 values can be performed using the arm_mult_q15 function. It is important to note that the result of a multiplication operation in Q15 format will be in Q30 format, so it may need to be scaled back to Q15 format using the arm_sat_q30_to_q15 function.

Finally, the results of the fixed-point calculations can be converted back to floating-point format using the arm_q15_to_float function. This allows the results to be used in subsequent floating-point calculations or displayed to the user.

To illustrate this process, let’s consider the example provided in the forum discussion. The goal is to calculate the product of two floating-point values, 30.02 and 12.76, using fixed-point arithmetic. The following steps outline the correct approach:

1. Select the appropriate Q-format: Given the range of the input values, Q15 format is a suitable choice.
2. Convert floating-point values to fixed-point format: Scale the floating-point values by dividing them by 32768 and convert them to Q15 format using arm_float_to_q15.
3. Perform the multiplication: Use arm_mult_q15 to multiply the two Q15 values. The result will be in Q30 format.
4. Scale the result back to Q15 format: Use arm_sat_q30_to_q15 to convert the Q30 result back to Q15 format.
5. Convert the result back to floating-point format: Use arm_q15_to_float to convert the Q15 result back to floating-point format.

Here is the corrected code:

#include "arm_math.h"

float32_t ValA = 30.02f;
float32_t ValB = 12.76f;
float32_t Outcome;

q15_t ValA_Q15, ValB_Q15, Outcome_Q15;

// Convert floating-point values to Q15 format
arm_float_to_q15(&ValA, &ValA_Q15, 1);
arm_float_to_q15(&ValB, &ValB_Q15, 1);

// Perform multiplication in Q15 format
q31_t Outcome_Q30;
arm_mult_q15(&ValA_Q15, &ValB_Q15, &Outcome_Q30, 1);

// Scale the result back to Q15 format
arm_sat_q30_to_q15(&Outcome_Q30, &Outcome_Q15, 1);

// Convert the result back to floating-point format
arm_q15_to_float(&Outcome_Q15, &Outcome, 1);

printf("Sensordata: %f", Outcome * 32768 * 32768);

This approach ensures that the fixed-point calculations are performed correctly and efficiently, without the risk of overflow or loss of precision. By following these steps, developers can leverage the power of the CMSIS-DSP library to optimize fixed-point arithmetic on Cortex-M4 microcontrollers without an FPU.

Advanced Techniques for Trigonometric and Complex Calculations

In addition to basic arithmetic operations, many embedded applications require trigonometric functions such as sine, cosine, and square root. The CMSIS-DSP library provides optimized fixed-point implementations of these functions, which can be used to further reduce computational overhead.

For example, the arm_sin_q15 function can be used to calculate the sine of a Q15 value. The input to this function should be in the range of -32768 to 32767, representing angles in radians scaled by 32768/π. Similarly, the arm_cos_q15 function can be used to calculate the cosine of a Q15 value.

To illustrate the use of these functions, let’s consider the example provided in the forum discussion, where the goal is to calculate the sine of a sensor value and use it in a subsequent calculation. The following steps outline the correct approach:

1. Convert the sensor value to Q15 format: Scale the sensor value by dividing it by 1000 and convert it to Q15 format using arm_float_to_q15.
2. Calculate the sine of the sensor value: Use arm_sin_q15 to calculate the sine of the Q15 value.
3. Perform the subsequent calculation: Multiply the sine value by a fixed-point constant and add it to another fixed-point value.
4. Convert the result back to floating-point format: Use arm_q15_to_float to convert the Q15 result back to floating-point format.

Here is the corrected code:

#include "arm_math.h"

int32_t ValA = 300; // Integer Sensor value
float32_t ValA_float;
float32_t Outcome;

q15_t ValA_Q15, Sine_Q15, Outcome_Q15;

// Convert sensor value to Q15 format
ValA_float = (float32_t)ValA / 1000.0f;
arm_float_to_q15(&ValA_float, &ValA_Q15, 1);

// Calculate sine of the sensor value
arm_sin_q15(&ValA_Q15, &Sine_Q15, 1);

// Perform the subsequent calculation
q15_t Constant_Q15 = arm_float_to_q15(1.32f);
q15_t Offset_Q15 = arm_float_to_q15(20.0f);
arm_mult_q15(&Sine_Q15, &Constant_Q15, &Outcome_Q15, 1);
arm_add_q15(&Outcome_Q15, &Offset_Q15, &Outcome_Q15, 1);

// Convert the result back to floating-point format
arm_q15_to_float(&Outcome_Q15, &Outcome, 1);

printf("Sensordata: %f", Outcome);

This approach ensures that the trigonometric calculations are performed efficiently and accurately, without the need for floating-point emulation. By leveraging the optimized fixed-point functions provided by the CMSIS-DSP library, developers can achieve significant performance improvements in their embedded applications.

Conclusion

Optimizing fixed-point calculations on ARM Cortex-M4 microcontrollers without an FPU requires a deep understanding of fixed-point arithmetic, the Q-format, and the CMSIS-DSP library. By carefully selecting the appropriate Q-format, correctly converting between floating-point and fixed-point formats, and using the optimized functions provided by the CMSIS-DSP library, developers can achieve significant performance improvements in their embedded applications.

In this guide, we have explored the core issues surrounding fixed-point arithmetic on Cortex-M4 without an FPU, identified potential pitfalls, and provided detailed steps to optimize calculations using the CMSIS-DSP library. By following these steps, developers can ensure that their fixed-point calculations are performed efficiently and accurately, even in the absence of an FPU.