FreeRTOS heap implementations (heap_1 to heap_5) - Mini Project: Build & Apply

Explore FreeRTOS Heap Implementations (heap_1 to heap_5)

📖 Scenario: You are working on an embedded system project using FreeRTOS. Memory management is critical for your system's stability and performance. FreeRTOS offers five different heap implementations (heap_1 to heap_5), each with unique features and trade-offs.Understanding these heap implementations will help you choose the right one for your project.

🎯 Goal: Build a simple FreeRTOS project that demonstrates the use of each heap implementation (heap_1 to heap_5) by setting up the heap configuration and showing how memory allocation behaves differently.

📋 What You'll Learn

Create a FreeRTOS configuration file with heap_1 enabled

Add a configuration variable to select heap_2

Implement a function to allocate memory using the selected heap implementation

Print the result of memory allocation to observe behavior

💡 Why This Matters

🌍 Real World

Embedded systems often have limited memory. Choosing the right FreeRTOS heap implementation ensures efficient and safe memory use.

💼 Career

Embedded developers and firmware engineers must understand FreeRTOS memory management to build reliable real-time applications.

1

Setup FreeRTOS configuration with heap_1

Create a FreeRTOS configuration file named FreeRTOSConfig.h that includes the line #define configFRTOS_MEMORY_SCHEME 1 to select heap_1 implementation.

FreeRTOS

// Your code here
// Create FreeRTOSConfig.h with heap_1 selection

Hint

Use #define configFRTOS_MEMORY_SCHEME 1 to select heap_1.

2

Add configuration variable to select heap_2

Add a new line in FreeRTOSConfig.h to define configFRTOS_MEMORY_SCHEME as 2 to select heap_2 implementation instead of heap_1.

FreeRTOS

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H

#define configFRTOS_MEMORY_SCHEME 1
// Change to heap_2 by defining configFRTOS_MEMORY_SCHEME as 2
// Your code here

#endif /* FREERTOS_CONFIG_H */

Hint

Replace the previous definition with #define configFRTOS_MEMORY_SCHEME 2.

3

Implement memory allocation function using selected heap

Write a function named void *myMalloc(size_t size) that calls pvPortMalloc(size) to allocate memory using the FreeRTOS heap selected by configFRTOS_MEMORY_SCHEME.

FreeRTOS

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H

#define configFRTOS_MEMORY_SCHEME 2

#endif /* FREERTOS_CONFIG_H */

// Your code here
// Implement myMalloc function

Hint

Use pvPortMalloc(size) inside myMalloc to allocate memory.

4

Print the result of memory allocation

Call myMalloc(100) and print the returned pointer value using printf to observe the allocation result.

FreeRTOS

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H

#define configFRTOS_MEMORY_SCHEME 2

#endif /* FREERTOS_CONFIG_H */

#include "FreeRTOS.h"
#include "task.h"
#include 

void *myMalloc(size_t size) {
    return pvPortMalloc(size);
}

int main() {
    // Call myMalloc and print the pointer
    // Your code here
}

Hint

Use void *ptr = myMalloc(100); and printf("Allocated memory pointer: %p\n", ptr);.

Practice

1. Which FreeRTOS heap implementation does NOT support freeing allocated memory?

easy

A. heap_1

B. heap_2

C. heap_3

D. heap_4

Solution

1. Step 1: Understand heap_1 behavior

   heap_1 only allows allocation but does not provide a function to free memory once allocated.

2. Step 2: Compare with other heaps

   heap_2, heap_3, and heap_4 all support freeing memory, with heap_3 using standard malloc/free.

3. Final Answer:

   heap_1 -> Option A

4. Quick Check:

   heap_1 no free support = heap_1 [OK]

Hint: heap_1 never frees memory, others do [OK]

Common Mistakes:

• Confusing heap_1 with heap_2 which supports free
• Assuming all heaps support freeing memory
• Mixing heap_3's malloc/free with heap_1's behavior

2. Which of the following is the correct way to include the heap_3 implementation in your FreeRTOS project?

easy

A. #include "heap3.c"

B. #include "heap_3.c"

C. #include "FreeRTOSHeap3.c"

D. #include

Solution

1. Step 1: Check FreeRTOS heap file naming

   Heap implementations are included by adding the corresponding .c file, e.g., "heap_3.c".

2. Step 2: Verify correct syntax

   Using #include "heap_3.c" is the standard way to include heap_3 in the build.

3. Final Answer:

   #include "heap_3.c" -> Option B

4. Quick Check:

   Include heap_3.c with quotes = D [OK]

Hint: Include heap source file with quotes, not angle brackets [OK]

Common Mistakes:

• Using angle brackets instead of quotes
• Incorrect file name spelling or casing
• Trying to include a header instead of the .c file

3. Given the following code snippet using heap_4, what will be the output if the allocation fails?

void *ptr = pvPortMalloc(1000);
if(ptr == NULL) {
    printf("Allocation failed\n");
} else {
    printf("Allocation succeeded\n");
}

medium

A. Compilation error

B. Allocation succeeded

C. Allocation failed

D. No output

Solution

1. Step 1: Understand heap_4 allocation behavior

   heap_4 supports allocation and freeing with coalescing. If memory is insufficient, pvPortMalloc returns NULL.

2. Step 2: Analyze the if condition

   If ptr is NULL, the code prints "Allocation failed"; otherwise, it prints "Allocation succeeded".

3. Final Answer:

   Allocation failed -> Option C

4. Quick Check:

   pvPortMalloc NULL means failure = A [OK]

Hint: pvPortMalloc returns NULL on failure [OK]

Common Mistakes:

• Assuming allocation always succeeds
• Confusing NULL with zero pointer
• Ignoring the if condition logic

4. You are using heap_2 in your FreeRTOS project but notice memory is not being freed properly. Which of the following is the most likely cause?

medium

A. heap_2 does not support freeing memory

B. heap_2 uses standard malloc/free which is not thread-safe

C. heap_2 requires manual coalescing of free blocks

D. You forgot to call vPortFree() after allocation

Solution

1. Step 1: Recall heap_2 features

   heap_2 supports freeing memory via vPortFree(), but does not coalesce free blocks.

2. Step 2: Identify common mistake

   If memory is not freed, the most common cause is forgetting to call vPortFree() after allocation.

3. Final Answer:

   You forgot to call vPortFree() after allocation -> Option D

4. Quick Check:

   Missing vPortFree causes leaks = B [OK]

Hint: Always call vPortFree() to release heap_2 memory [OK]

Common Mistakes:

• Assuming heap_2 lacks free support
• Confusing heap_2 with heap_1 or heap_3
• Thinking heap_2 uses malloc/free internally

5. You want to use a FreeRTOS heap implementation that supports both allocation and freeing, minimizes fragmentation by coalescing adjacent free blocks, and is suitable for real-time systems. Which heap should you choose?

hard

A. heap_4

B. heap_2

C. heap_1

D. heap_5

Solution

1. Step 1: Review heap features

   heap_1 does not support freeing; heap_2 supports free but no coalescing; heap_4 supports free and coalesces adjacent free blocks; heap_5 extends heap_4 with multiple memory regions.

2. Step 2: Match requirements

   For minimizing fragmentation and real-time suitability, heap_4 is ideal as it coalesces free blocks and is deterministic.

3. Final Answer:

   heap_4 -> Option A

4. Quick Check:

   heap_4 coalesces free blocks = A [OK]

Hint: heap_4 coalesces free blocks, best for fragmentation [OK]

Common Mistakes:

• Choosing heap_5 without needing multiple regions
• Assuming heap_2 coalesces free blocks
• Picking heap_1 which lacks free support