FreeRTOS

Course Outline:

1. RTOS Introduction and Concepts

• Real-time operating systems core principles
• Deterministic and predictability
• Priority-based scheduling, preemption

2. Bare-metal vs. RTOS implementations

• Pros and cons of each approach
• When to choose RTOS over bare-metal implementation

3. RTOS main building blocks

• Task management and scheduling
• Inter-task communication and synchronization mechanisms
• Time management and timer services
• Memory management in RTOS

4. The Development Environment

• Toolchain & IDE, common output formats
• Flash organization, linker scripts
• Flash & RAM consumption, map file

5. FreeRTOS Introduction

• Overview of FreeRTOS API organization
• Understanding naming conventions and function categories
• Documentation and resources available

6. How FreeRTOS works

• FreeRTOS architecture and core components
• Kernel internals and scheduling algorithm
• Configuration options and customization possibilities

7. Heap memory management

• FreeRTOS memory management schemes
• Comparing different heap implementations
• Best practices for dynamic memory allocation in real-time systems

8. Timer tick

• System ticks in FreeRTOS
• Configuring tick rate and its impact on system performance

9. What’s in a Task?

• Task structure and attributes in FreeRTOS
• Stack allocation and management for tasks
• Task control block (TCB) and its role in task management
• System tasks

10. Task creation

• API functions for creating tasks in FreeRTOS
• Parameters involved in task creation
• Static and dynamic creation

11. Task priority

• Understanding priority levels in FreeRTOS
• Implementing priority-based scheduling
• Avoiding priority inversion and using priority inheritance

12. Task Life Cycle

• Understanding the different states a task can be in
• Transitions between task states and their triggers
• API functions for manipulating task states

13. Round-Robin & Time-Slicing

• FreeRTOS scheduling policies
• Implementing round-robin scheduling for tasks of equal priority
• Time-slicing and its effects

14. Tasks control API

• FreeRTOS task management functions
• Suspending, resuming, and deleting tasks
• Changing task priorities dynamically

15. Delay functions

• Using vTaskDelay() and vTaskDelayUntil() for task timing
• Relative and absolute delays
• Periodic tasks

16. Application Timers

• FreeRTOS software timers
• One-shot and periodic timers
• Timer callback functions and their execution context

17. Interrupt handling with Tasks

• Integrating ISRs with FreeRTOS tasks
• Deferred interrupt processing
• API functions safe for use in interrupt context

18. Message Queues

• FreeRTOS queue data structure
• Using queues for inter-task communication
• Blocking and non-blocking queue operations

19. Counting vs. Binary Semaphores

• Differentiating between counting and binary semaphores
• Implementing synchronization and signaling using semaphores

20. Mutex synchronization objects

• FreeRTOS mutual exclusion (mutex)
• Creating and using mutexes to protect shared resources
• Avoiding deadlocks and priority inversion

21. Direct task communication

• FreeRTOS direct-to-task notifications
• Comparing task notifications with other communication methods

22. Event Flag Groups

• FreeRTOS event groups
• Creating and manipulating event flags
• Synchronizing tasks using event groups

23. Memory Buffers

• Stream buffers
• Message buffers

24. Debugging Mechanisms

• Assertions
• Using the debugger
• Debugging considerations
• FreeRTOS Run-time statistics
• FreeRTOS Stack overflow detection
• FreeRTOS Tracing

25. FreeRTOS & Low power

• Tickless idle mode
• Wakeup sources

26. Best Practices & Considerations

• Tasks allocation
• SysTick optimization
• Critical sections
• Memory allocations
• ISR efficiency
• Waiting efficiency