ARM Cortex-M CMSIS Queue Implementation Issue with FreeRTOS and STM32F103RB

Incorrect Data Transfer in CMSIS Queue Implementation with FreeRTOS on STM32F103RB

The core issue revolves around the incorrect transfer of data when using the CMSIS (Cortex Microcontroller Software Interface Standard) library in conjunction with FreeRTOS on an STM32F103RB microcontroller. Specifically, when creating a queue with a custom item size of 20 bytes (intended to transfer a structure of this size), only the first 4 bytes of the structure are being transferred correctly. This behavior suggests a misalignment between the expected and actual implementation of the queue mechanism in the CMSIS library.

The problem was identified in the cmsis_os.c file, where the osMessageQDef_t structure is defined. The original implementation incorrectly uses the sizeof() operator when defining the queue, leading to a mismatch in the expected item size. The fix involves removing the sizeof() operator, which resolves the issue and allows the full 20-byte structure to be transferred correctly. This raises questions about whether this is a bug in the CMSIS library or an unintended side effect of integrating CMSIS with FreeRTOS.

Misuse of sizeof() Operator in osMessageQDef_t Structure Definition

The root cause of the issue lies in the misuse of the sizeof() operator within the osMessageQDef_t structure definition in the CMSIS library. The osMessageQDef_t structure is used to define the properties of a message queue, including the queue size and the size of each item in the queue. The original implementation incorrectly applies the sizeof() operator to the type parameter, which is intended to represent the size of the queue item.

The osMessageQDef_t structure is defined as follows in the cmsis_os.c file:

const osMessageQDef_t os_messageQ_def_##name = { (queue_sz), sizeof (type), NULL, NULL };

Here, type is expected to be the size of the queue item, but the use of sizeof(type) implies that type is a data type rather than a size value. This leads to a misinterpretation of the item size, particularly when type is passed as a numerical value (e.g., 20) rather than a data type (e.g., uint16_t). As a result, the queue is configured with an incorrect item size, causing only the first 4 bytes of the structure to be transferred.

The fix involves removing the sizeof() operator, as shown below:

const osMessageQDef_t os_messageQ_def_##name = { (queue_sz), type, NULL, NULL };

This change ensures that the type parameter is interpreted as the size of the queue item, allowing the full 20-byte structure to be transferred correctly.

Correcting Queue Implementation and Validating Data Transfer

To resolve the issue and ensure proper data transfer in the CMSIS queue implementation, follow these steps:

1. Modify the osMessageQDef_t Structure Definition: Locate the cmsis_os.c file in your project and navigate to the definition of the osMessageQDef_t structure. Replace the line containing sizeof(type) with type to ensure that the type parameter is interpreted as the size of the queue item. This modification should be applied as follows:

   const osMessageQDef_t os_messageQ_def_##name = { (queue_sz), type, NULL, NULL };
   

2. Rebuild the Project: After making the necessary changes to the cmsis_os.c file, rebuild your project to ensure that the modifications are correctly applied. This step is crucial to verify that the changes do not introduce any compilation errors or warnings.

3. Validate Data Transfer: Test the queue implementation by creating a queue with a custom item size (e.g., 20 bytes) and transferring a structure of this size. Use debugging tools to verify that the full structure is being transferred correctly. Pay particular attention to the memory addresses and data values to ensure that no data is being truncated or corrupted.

4. Check for Side Effects: While the modification resolves the immediate issue, it is essential to check for any potential side effects, particularly in other parts of the code that may rely on the original implementation. Ensure that the change does not impact other queue operations or introduce new bugs.

5. Report the Issue: If the issue is confirmed to be a bug in the CMSIS library, consider reporting it to the maintainers. Provide a detailed description of the problem, the steps to reproduce it, and the proposed fix. This will help ensure that the issue is addressed in future releases of the library.

6. Document the Solution: Document the changes made to the cmsis_os.c file and the rationale behind them. This documentation will be valuable for future reference and for other developers who may encounter the same issue.

By following these steps, you can resolve the issue and ensure that the CMSIS queue implementation works correctly with FreeRTOS on the STM32F103RB microcontroller. This approach not only addresses the immediate problem but also provides a framework for identifying and resolving similar issues in the future.

This detailed troubleshooting guide provides a comprehensive analysis of the issue, its root cause, and the steps required to resolve it. By understanding the underlying problem and applying the recommended fixes, developers can ensure reliable and efficient operation of their embedded systems.