Table of Contents

1 Preface

• 1.1 Multitasking in Small Embedded Systems
  • 1.1.1 About the FreeRTOS Kernel
  • 1.1.2 Value Proposition
  • 1.1.3 A Note About Terminology
  • 1.1.4 Why Use an RTOS?
  • 1.1.5 FreeRTOS Kernel Features
  • 1.1.6 Licensing, and The FreeRTOS, OpenRTOS, and SafeRTOS Family
• 1.2 Included Source Files and Projects
  • 1.2.1 Obtaining the Examples that Accompany this Book

2 The FreeRTOS Kernel Distribution

• 2.1 Introduction
• 2.2 Understanding the FreeRTOS Distribution
  • 2.2.1 Definition: FreeRTOS Port
  • 2.2.2 Building FreeRTOS
  • 2.2.3 FreeRTOSConfig.h
  • 2.2.4 Official Distributions
  • 2.2.5 FreeRTOS Source Files Common to All Ports
  • 2.2.6 FreeRTOS Source Files Specific to a Port
  • 2.2.7 Include Paths
  • 2.2.8 Header Files
• 2.3 Demo Applications
• 2.4 Creating a FreeRTOS Project
  • 2.4.1 Adapting One of the Supplied Demo Projects
  • 2.4.2 Creating a New Project from Scratch
• 2.5 Data Types and Coding Style Guide
  • 2.5.1 Data Types
  • 2.5.2 Variable Names
  • 2.5.3 Function Names
  • 2.5.4 Formatting
  • 2.5.5 Macro Names
  • 2.5.6 Rationale for Excessive Type Casting

3 Heap Memory Management

• 3.1 Introduction
  • 3.1.1 Prerequisites
  • 3.1.2 Scope
  • 3.1.3 Switching Between Static and Dynamic Memory Allocation
  • 3.1.4 Using Dynamic Memory Allocation
  • 3.1.5 Options for Dynamic Memory Allocation
• 3.2 Example Memory Allocation Schemes
  • 3.2.1 Heap_1
  • 3.2.2 Heap_2
  • 3.2.3 Heap_3
  • 3.2.4 Heap_4
  • 3.2.5 Heap_5
  • 3.2.6 Initialising heap_5: The vPortDefineHeapRegions() API Function
• 3.3 Heap Related Utility Functions and Macros
  • 3.3.1 Defining the Heap Start Address
  • 3.3.2 The xPortGetFreeHeapSize() API Function
  • 3.3.3 The xPortGetMinimumEverFreeHeapSize() API Function
  • 3.3.4 The vPortGetHeapStats() API Function
  • 3.3.5 Collecting Per-task Heap Usage Statistics
  • 3.3.6 Malloc Failed Hook Functions
  • 3.3.7 Placing Task Stacks in Fast Memory
• 3.4 Using Static Memory Allocation
  • 3.4.1 Enabling Static Memory Allocation
  • 3.4.2 Static Internal Kernel Memory
    • 3.4.2.1 vApplicationGetTimerTaskMemory
    • 3.4.2.2 vApplicationGetIdleTaskMemory

4 Task Management

• 4.1 Introduction
  • 4.1.1 Scope
• 4.2 Task Functions
• 4.3 Top Level Task States
• 4.4 Task Creation
  • 4.4.1 The xTaskCreate() API Function
• 4.5 Task Priorities
  • Generic Scheduler
  • Architecture-Optimized Scheduler
• 4.6 Time Measurement and the Tick Interrupt
• 4.7 Expanding the Not Running State
  • 4.7.1 The Blocked State
  • 4.7.2 The Suspended State
  • 4.7.3 The Ready State
  • 4.7.4 Completing the State Transition Diagram
  • 4.7.5 The vTaskDelayUntil() API Function
• 4.8 The Idle Task and the Idle Task Hook
  • 4.8.1 Idle Task Hook Functions
  • 4.8.2 Limitations on the Implementation of Idle Task Hook Functions
• 4.9 Changing the Priority of a Task
  • 4.9.1 The vTaskPrioritySet() API Function
  • 4.9.2 The uxTaskPriorityGet() API Function
• 4.10 Deleting a Task
  • 4.10.1 The vTaskDelete() API Function
• 4.11 Thread Local Storage and Reentrancy
  • 4.11.1 C Runtime Thread Local Storage Implementations
  • 4.11.2 Custom C Runtime Thread Local Storage
  • 4.11.3 Application Thread Local Storage
• 4.12 Scheduling Algorithms
  • 4.12.1 A Recap of Task States and Events
  • 4.12.2 Selecting the Scheduling Algorithm
  • 4.12.3 Prioritized Preemptive Scheduling with Time Slicing
  • 4.12.4 Prioritized Preemptive Scheduling without Time Slicing
  • 4.12.5 Cooperative Scheduling

5 Queue Management

• 5.1 Introduction
  • 5.1.1 Scope
• 5.2 Characteristics of a Queue
  • 5.2.1 Data Storage
  • 5.2.2 Access by Multiple Tasks
  • 5.2.3 Blocking on Queue Reads
  • 5.2.4 Blocking on Queue Writes
  • 5.2.5 Blocking on Multiple Queues
  • 5.2.6 Creating Queues: Statically Allocated and Dynamically Allocated Queues
• 5.3 Using a Queue
  • 5.3.1 The xQueueCreate() API Function
  • 5.3.2 The xQueueSendToBack() and xQueueSendToFront() API Functions
  • 5.3.3 The xQueueReceive() API Function
  • 5.3.4 The uxQueueMessagesWaiting() API Function
• 5.4 Receiving Data From Multiple Sources
• 5.5 Working with Large or Variable Sized Data
  • 5.5.1 Queuing Pointers
  • 5.5.2 Using a Queue to Send Different Types and Lengths of Data[^9]
• 5.6 Receiving From Multiple Queues
  • 5.6.1 Queue Sets
  • 5.6.2 The xQueueCreateSet() API Function
  • 5.6.3 The xQueueAddToSet() API Function
  • 5.6.4 The xQueueSelectFromSet() API Function
  • 5.6.5 More Realistic Queue Set Use Cases
• 5.7 Using a Queue to Create a Mailbox
  • 5.7.1 The xQueueOverwrite() API Function
  • 5.7.2 The xQueuePeek() API Function

6 Software Timer Management

• 6.1 Chapter Introduction and Scope
  • 6.1.1 Scope
• 6.2 Software Timer Callback Functions
• 6.3 Attributes and States of a Software Timer
  • 6.3.1 Period of a Software Timer
  • 6.3.2 One-shot and Auto-reload Timers
  • 6.3.3 Software Timer States
• 6.4 The Context of a Software Timer
  • 6.4.1 The RTOS Daemon (Timer Service) Task
  • 6.4.2 The Timer Command Queue
  • 6.4.3 Daemon Task Scheduling
• 6.5 Creating and Starting a Software Timer
  • 6.5.1 The xTimerCreate() API Function
  • 6.5.2 The xTimerStart() API Function
• 6.6 The Timer ID
  • 6.6.1 The vTimerSetTimerID() API Function
  • 6.6.2 The pvTimerGetTimerID() API Function
• 6.7 Changing the Period of a Timer
  • 6.7.1 The xTimerChangePeriod() API Function
• 6.8 Resetting a Software Timer
  • 6.8.1 The xTimerReset() API Function

7 Interrupt Management

• 7.1 Introduction
  • 7.1.1 Events
  • 7.1.2 Scope
• 7.2 Using the FreeRTOS API from an ISR
  • 7.2.1 The Interrupt Safe API
  • 7.2.2 The Benefits of Using a Separate Interrupt Safe API
  • 7.2.3 The Disadvantages of Using a Separate, Interrupt Safe API
  • 7.2.4 The xHigherPriorityTaskWoken Parameter
  • 7.2.5 The portYIELD_FROM_ISR() and portEND_SWITCHING_ISR() Macros
• 7.3 Deferred Interrupt Processing
• 7.4 Binary Semaphores Used for Synchronization
  • 7.4.1 The xSemaphoreCreateBinary() API Function
  • 7.4.2 The xSemaphoreTake() API Function
  • 7.4.3 The xSemaphoreGiveFromISR() API Function
  • 7.4.4 Improving the Implementation of the Task Used in Example 7.1
• 7.5 Counting Semaphores
  • 7.5.1 The xSemaphoreCreateCounting() API Function
• 7.6 Deferring Work to the RTOS Daemon Task
  • 7.6.1 The xTimerPendFunctionCallFromISR() API Function
• 7.7 Using Queues within an Interrupt Service Routine
  • 7.7.1 The xQueueSendToFrontFromISR() and xQueueSendToBackFromISR() API Functions
  • 7.7.2 Considerations When Using a Queue From an ISR
• 7.8 Interrupt Nesting
  • 7.8.1 A Note to ARM Cortex-M[^22] and ARM GIC Users

8 Resource Management

• 8.1 Chapter Introduction and Scope
  • 8.1.1 Mutual Exclusion
  • 8.1.2 Scope
• 8.2 Critical Sections and Suspending the Scheduler
  • 8.2.1 Basic Critical Sections
  • 8.2.2 Suspending (or Locking) the Scheduler
  • 8.2.3 The vTaskSuspendAll() API Function
  • 8.2.4 The xTaskResumeAll() API Function
• 8.3 Mutexes (and Binary Semaphores)
  • 8.3.1 The xSemaphoreCreateMutex() API Function
  • 8.3.2 Priority Inversion
  • 8.3.3 Priority Inheritance
  • 8.3.4 Deadlock (or Deadly Embrace)
  • 8.3.5 Recursive Mutexes
  • 8.3.6 Mutexes and Task Scheduling
• 8.4 Gatekeeper Tasks
  • 8.4.1 Re-writing vPrintString() to use a gatekeeper task

9 Event Groups

• 9.1 Chapter Introduction and Scope
  • 9.1.1 Scope
• 9.2 Characteristics of an Event Group
  • 9.2.1 Event Groups, Event Flags and Event Bits
  • 9.2.2 More About the EventBits_t Data Type
  • 9.2.3 Access by Multiple Tasks
  • 9.2.4 A Practical Example of Using an Event Group
• 9.3 Event Management Using Event Groups
  • 9.3.1 The xEventGroupCreate() API Function
  • 9.3.2 The xEventGroupSetBits() API Function
  • 9.3.3 The xEventGroupSetBitsFromISR() API Function
  • 9.3.4 The xEventGroupWaitBits() API Function
  • 9.3.5 The xEventGroupGetStaticBuffer() API Function
• 9.4 Task Synchronization Using an Event Group
  • 9.4.1 The xEventGroupSync() API Function

10 Task Notifications

• 10.1 Introduction
  • 10.1.1 Communicating Through Intermediary Objects
  • 10.1.2 Task Notifications—Direct to Task Communication
  • 10.1.3 Scope
• 10.2 Task Notifications; Benefits and Limitations
  • 10.2.1 Performance Benefits of Task Notifications
  • 10.2.2 RAM Footprint Benefits of Task Notifications
  • 10.2.3 Limitations of Task Notifications
• 10.3 Using Task Notifications
  • 10.3.1 Task Notification API Options
    • 10.3.1.1 The complete list of API functions ²⁷
  • 10.3.2 The xTaskNotifyGive() API Functions
  • 10.3.3 The vTaskNotifyGiveFromISR() API Function
  • 10.3.4 The ulTaskNotifyTake() API Function
  • 10.3.5 The xTaskNotify() and xTaskNotifyFromISR() API Functions
  • 10.3.6 The xTaskNotifyWait() API Function
  • 10.3.7 Task Notifications Used in Peripheral Device Drivers: UART Example
  • 10.3.8 Task Notifications Used in Peripheral Device Drivers: ADC Example
  • 10.3.9 Task Notifications Used Directly Within an Application

11 Low Power Support

• 11.1 Power Saving Introduction
• 11.2 FreeRTOS Sleep Modes
• 11.3 Functions and Enabling Built-in Tickless Idle Functionality
  • 11.3.1 The portSUPPRESS_TICKS_AND_SLEEP() Macro
  • 11.3.2 The vPortSuppressTicksAndSleep Function
  • 11.3.3 The eTaskConfirmSleepModeStatus Function
  • 11.3.4 The configPRE_SLEEP_PROCESSING configuration
  • 11.3.5 The configPOST_SLEEP_PROCESSING configuration
• 11.4 Implementing portSUPPRESS_TICKS_AND_SLEEP() Macro
• 11.5 Idle Task Hook Function

12 Developer Support

• 12.1 Introduction
• 12.2 configASSERT()
  • 12.2.1 Example configASSERT() definitions
• 12.3 Tracealyzer for FreeRTOS
• 12.4 Debug Related Hook (Callback) Functions
  • 12.4.1 Malloc failed hook
• 12.5 Viewing Run-time and Task State Information
  • 12.5.1 Task Run-Time Statistics
  • 12.5.2 The Run-Time Statistics Clock
  • 12.5.3 Configuring an Application to Collect Run-Time Statistics
  • 12.5.4 The uxTaskGetSystemState() API Function
  • 12.5.5 The vTaskListTasks() Helper Function
  • 12.5.6 The vTaskGetRunTimeStatistics() Helper Function
  • 12.5.7 Generating and Displaying Run-Time Statistics, a Worked Example
• 12.6 Trace Hook Macros
  • 12.6.1 Available Trace Hook Macros
  • 12.6.2 Defining Trace Hook Macros
  • 12.6.3 FreeRTOS Aware Debugger Plug-ins

13 Troubleshooting

• 13.1 Chapter Introduction and Scope
• 13.2 Interrupt Priorities
• 13.3 Stack Overflow
  • 13.3.1 The uxTaskGetStackHighWaterMark() API Function
  • 13.3.2 Run Time Stack Checking—Overview
  • 13.3.3 Run Time Stack Checking—Method 1
  • 13.3.4 Run Time Stack Checking—Method 2
  • 13.3.4 Run Time Stack Checking—Method 3
• 13.4 Use of printf() and sprintf()
  • 13.4.1 Printf-stdarg.c
• 13.5 Other Common Sources of Error
  • 13.5.1 Symptom: Adding a simple task to a demo causes the demo to crash
  • 13.5.2 Symptom: Using an API function within an interrupt causes the application to crash
  • 13.5.3 Symptom: Sometimes the application crashes within an interrupt service routine
  • 13.5.4 Symptom: The scheduler crashes when attempting to start the first task
  • 13.5.5 Symptom: Interrupts are unexpectedly left disabled, or critical sections do not nest correctly
  • 13.5.6 Symptom: The application crashes even before the scheduler is started
  • 13.5.7 Symptom: Calling API functions while the scheduler is suspended, or from inside a critical section, causes the application to crash
• 13.6 Additional Debugging Steps

Examples:

• Example 4.1 Creating tasks
• Example 4.2 Using the task parameter
• Example 4.3 Experimenting with priorities
• Example 4.4 Using the Blocked state to create a delay
• Example 4.5 Converting the example tasks to use vTaskDelayUntil()
• Example 4.6 Combining blocking and non-blocking tasks
• Example 4.7 Defining an idle task hook function
• Example 4.8 Deleting tasks
• Example 5.1 Blocking when receiving from a queue
• Example 5.2 Blocking when sending to a queue, and sending structures on a queue
• Example 5.3 Using a Queue Set
• Example 6.1 Creating one-shot and auto-reload timers
• Example 6.2 Using the callback function parameter and the software timer ID
• Example 6.3 Resetting a software timer
• Example 7.1 Using a binary semaphore to synchronize a task with an interrupt
• Example 7.2 Using a counting semaphore to synchronize a task with an interrupt
• Example 7.3 Centralized deferred interrupt processing
• Example 7.4 Sending and receiving on a queue from within an interrupt
• Example 8.1 Rewriting vPrintString() to use a semaphore
• Example 8.2 The alternative implementation for print task
• Example 9.1 Experimenting with event groups
• Example 9.2 Synchronizing tasks
• Example 10.1 Using a task notification in place of a semaphore, method 1
• Example 10.2 Using a task notification in place of a semaphore, method 2

Figures:

• Figure 2.1 Top level directories within the FreeRTOS distribution
• Figure 2.2 Core FreeRTOS source files within the FreeRTOS directory tree
• Figure 2.3 Port specific source files within the FreeRTOS directory tree
• Figure 2.4 The demo directory hierarchy
• Figure 3.1 RAM being allocated from the heap_1 array each time a task is created
• Figure 3.2 RAM being allocated and freed from the heap_2 array as tasks are created and deleted
• Figure 3.3 RAM being allocated and freed from the heap_4 array
• Figure 3.4 Memory Map
• Figure 4.1 Top level task states and transitions
• Figure 4.2 The output produced when executing Example 4.1
• Figure 4.3 The actual execution pattern of the two Example 4.1 tasks
• Figure 4.4 The execution sequence expanded to show the tick interrupt executing
• Figure 4.5 Running both tasks at different priorities
• Figure 4.6 The execution pattern when one task has a higher priority than the…
• Figure 4.7 Full task state machine
• Figure 4.8 The output produced when Example 4.4 is executed
• Figure 4.9 The execution sequence when the tasks use vTaskDelay() in place of the null loop
• Figure 4.10 Bold lines indicate the state transitions performed by the tasks…
• Figure 4.11 The output produced when Example 4.6 is executed
• Figure 4.12 The execution pattern of Example 4.6
• Figure 4.13 The output produced when Example 4.7 is executed
• Figure 4.14 The sequence of task execution when running Example 4.8
• Figure 4.15 The output produced when Example 4.8 is executed
• Figure 4.16 The output produced when Example 4.9 is executed
• Figure 4.17 The execution sequence for Example 4.9
• Figure 4.18 Execution pattern highlighting task prioritization and preemption…
• Figure 4.19 Execution pattern highlighting task prioritization and time slicing…
• Figure 4.20 The execution pattern for the same scenario as shown in Figure 4.19…
• Figure 4.21 Execution pattern that demonstrates how tasks of equal priority can…
• Figure 4.22 Execution pattern demonstrating the behavior of the cooperative scheduler
• Figure 5.1 An example sequence of writes to, and reads from a queue
• Figure 5.2 The output produced when Example 5.1 is executed
• Figure 5.3 The sequence of execution produced by Example 5.1
• Figure 5.4 An example scenario where structures are sent on a queue
• Figure 5.5 The output produced by Example 5.2
• Figure 5.6 The sequence of execution produced by Example 5.2
• Figure 5.7 The output produced when Example 5.3 is executed
• Figure 6.1 The difference in behavior between one-shot and auto-reload software timers
• Figure 6.2 Auto-reload software timer states and transitions
• Figure 6.3 One-shot software timer states and transitions
• Figure 6.4 The timer command queue being used by a software timer API function to communicate with the RTOS daemon task
• Figure 6.5 The execution pattern when the priority of a task calling xTimerStart() is above the priority of the daemon task
• Figure 6.6 The execution pattern when the priority of a task calling xTimerStart() is below the priority of the daemon task
• Figure 6.7 The output produced when Example 6.1 is executed
• Figure 6.8 The output produced when Example 6.2 is executed
• Figure 6.9 Starting and resetting a software timer that has a period of 6 ticks
• Figure 6.10 The output produced when Example 6.3 is executed
• Figure 7.1 Completing interrupt processing in a high priority task
• Figure 7.2 Using a binary semaphore to implement deferred interrupt processing
• Figure 7.3 Using a binary semaphore to synchronize a task with an interrupt
• Figure 7.4 The output produced when Example 7.1 is executed
• Figure 7.5 The sequence of execution when Example 7.1 is executed
• Figure 7.6 The scenario when one interrupt occurs before the task has finished processing the first event
• Figure 7.7 The scenario when two interrupts occur before the task has finished processing the first event
• Figure 7.8 Using a counting semaphore to
• Figure 7.9 The output produced when Example 7.2 is executed
• Figure 7.10 The output produced when Example 7.3 is executed
• Figure 7.11 The sequence of execution when Example 7.3 is executed
• Figure 7.12 The output produced when Example 7.4 is executed
• Figure 7.13 The sequence of execution produced by Example 7.4
• Figure 7.14 Constants affecting interrupt nesting behavior
• Figure 7.15 How a priority of binary 101 is stored by a Cortex-M microcontroller that implements four priority bits
• Figure 8.1 Mutual exclusion implemented using a mutex
• Figure 8.2 The output produced when Example 8.1 is executed
• Figure 8.3 A possible sequence of execution for Example 8.1
• Figure 8.4 A worst case priority inversion scenario
• Figure 8.5 Priority inheritance minimizing the effect of priority inversion
• Figure 8.6 A possible sequence of execution when tasks that have the same priority use the same mutex
• Figure 8.7 A sequence of execution that could occur if two instances of the task shown by Listing 8.15 are created at the same priority
• Figure 8.8 The output produced when Example 8.2 is executed
• Figure 9.1 Event flag to bit number mapping in a variable of type EventBits_t
• Figure 9.2 An event group in which only bits 1, 4 and 7 are set, and all the other event flags are clear, making the event group
• Figure 9.3 The output produced when Example 9.1 is executed with xWaitForAllBits set to pdFALSE
• Figure 9.4 The output produced when Example 9.1 is executed with xWaitForAllBits set to pdTRUE
• Figure 9.5 The output produced when Example 9.2 is executed
• Figure 10.1 A communication object being used to send an event from one task to another
• Figure 10.2 A task notification used to send an event directly from one task to another
• Figure 10.3 The output produced when Example 7.1 is executed
• Figure 10.4 The sequence of execution when Example 10.1 is executed
• Figure 10.5 The output produced when Example 10.2 is executed
• Figure 10.6 The communication paths from the application tasks to the cloud server, and back again
• Figure 12.1 FreeRTOS+Trace includes more than 20 interconnected views
• Figure 12.2 FreeRTOS+Trace main trace view - one of more than 20 interconnected trace views
• Figure 12.3 FreeRTOS+Trace CPU load view - one of more than 20 interconnected trace views
• Figure 12.4 FreeRTOS+Trace response time view - one of more than 20 interconnected trace views
• Figure 12.5 FreeRTOS+Trace user event plot view - one of more than 20 interconnected trace views
• Figure 12.6 FreeRTOS+Trace kernel object history view - one of more than 20 interconnected trace views
• Figure 12.7 Example output generated by vTaskListTasks()
• Figure 12.8 Example output generated by vTaskGetRunTimeStatistics()

Listings:

• Listing 2.1 The template for a new main() function
• Listing 3.1 The vPortDefineHeapRegions() API function prototype
• Listing 3.2 The HeapRegion_t structure
• Listing 3.3 An array of HeapRegion_t structures that together describe the 3 regions of RAM in their entirety
• Listing 3.4 An array of HeapRegion_t structures that describe all of RAM2, all of RAM3, but only part of RAM1
• Listing 3.5 Using GCC syntax to declare the array that will be used by heap_4, and place the array in a memory section named .my_heap
• Listing 3.6 Using IAR syntax to declare the array that will be used by heap_4, and place the array at the absolute address 0x20000000
• Listing 3.7 The xPortGetFreeHeapSize() API function prototype
• Listing 3.8 The xPortGetMinimumEverFreeHeapSize() API function prototype
• Listing 3.9 The vPortGetHeapStatus() API function prototype
• Listing 3.10 The HeapStatus_t() structure
• Listing 3.11 The malloc failed hook function name and prototype
• Listing 3.12 Mapping the pvPortMallocStack() and vPortFreeStack() macros to an application defined memory allcator
• Listing 3.13 Typical implementation of vApplicationGetTimerTaskMemory
• Listing 3.14 Typical implementation of vApplicationGetIdleTaskMemory
• Listing 4.1 The task function prototype
• Listing 4.2 The structure of a typical task function
• Listing 4.3 The xTaskCreate() API function prototype
• Listing 4.4 Implementation of the first task used in Example 4.1
• Listing 4.5 Implementation of the second task used in Example 4.1
• Listing 4.6 Starting the Example 4.1 tasks
• Listing 4.7 Creating a task from within another task after the scheduler has started
• Listing 4.8 The single task function used to create two tasks in Example 4.2
• Listing 4.9 The main() function for Example 2
• Listing 4.10 Using the pdMS_TO_TICKS() macro to convert 200 milliseconds…
• Listing 4.11. Creating two tasks at different priorities
• Listing 4.12 The vTaskDelay() API function prototype
• Listing 4.13 The source code for the example task after replacing the null loop delay with a call…
• Listing 4.14 vTaskDelayUntil() API function prototype
• Listing 4.15 The implementation of the example task using vTaskDelayUntil()
• Listing 4.16 The continuous processing task used in Example 4.6
• Listing 4.17 The periodic task used in Example 4.6
• Listing 4.18 The idle task hook function name and prototype
• Listing 4.19 A very simple Idle hook function
• Listing 4.20 The source code for the example task now prints out the ulIdleCycleCount value
• Listing 4.21 The vTaskPrioritySet() API function prototype
• Listing 4.22 The uxTaskPriorityGet() API function prototype
• Listing 4.23 The implementation of Task 1 in Example 4.8
• Listing 4.24 The implementation of Task 2 in Example 4.8
• Listing 4.25 The implementation of main() for Example 4.8
• Listing 4.26 The vTaskDelete() API function prototype
• Listing 4.27 The implementation of main() for Example 4.9
• Listing 4.28 The implementation of Task 1 for Example 4.9
• Listing 4.29 The implementation of Task 2 for Example 4.9
• Listing 4.30 Function prototypes of the Thread Local Storage Pointer API functions
• Listing 5.1 The xQueueCreate() API function prototype
• Listing 5.2 The xQueueSendToFront() API function prototype
• Listing 5.3 The xQueueSendToBack() API function prototype
• Listing 5.4 The xQueueReceive() API function prototype
• Listing 5.5 The uxQueueMessagesWaiting() API function prototype
• Listing 5.6 Implementation of the sending task used in Example 5.1
• Listing 5.7 Implementation of the receiver task for Example 5.1
• Listing 5.8 The implementation of main() in Example 5.1
• Listing 5.9 The definition of the structure that is to be passed on a queue, plus the declaration of two variables for use by the example
• Listing 5.10 The implementation of the sending task for Example 5.2
• Listing 5.11 The definition of the receiving task for Example 5.2
• Listing 5.12 The implementation of main() for Example 5.2
• Listing 5.13 Creating a queue that holds pointers
• Listing 5.14 Using a queue to send a pointer to a buffer
• Listing 5.15 Using a queue to receive a pointer to a buffer
• Listing 5.16 The structure used to send events to the TCP/IP stack task in FreeRTOS+TCP
• Listing 5.17 Pseudo code showing how an IPStackEvent_t structure is used to send data received from the network to the TCP/IP task
• Listing 5.18 Pseudo code showing how an IPStackEvent_t structure is used to send the handle of a socket that is accepting a connection to the TCP/IP task
• Listing 5.19 Pseudo code showing how an IPStackEvent_t structure is used to send a network down event to the TCP/IP task
• Listing 5.20 Pseudo code showing how an IPStackEvent_t structure is received and processed
• Listing 5.21 The xQueueCreateSet() API function prototype
• Listing 5.22 The xQueueAddToSet() API function prototype
• Listing 5.23 The xQueueSelectFromSet() API function prototype
• Listing 5.24 Implementation of main() for Example 5.3
• Listing 5.25 The sending tasks used in Example 5.3
• Listing 5.26 The receive task used in Example 5.3
• Listing 5.27 Using a queue set that contains queues and semaphores
• Listing 5.28 A queue being created for use as a mailbox
• Listing 5.29 The xQueueOverwrite() API function prototype
• Listing 5.30 Using the xQueueOverwrite() API function
• Listing 5.31 The xQueuePeek() API function prototype
• Listing 5.32 Using the xQueuePeek() API function
• Listing 6.1 The software timer callback function prototype
• Listing 6.2 The xTimerDelete() API function prototype
• Listing 6.3 The xTimerCreate() API function prototype
• Listing 6.4 The xTimerStart() API function prototype
• Listing 6.5 Creating and starting the timers used in Example 6.1
• Listing 6.6 The callback function used by the one-shot timer in Example 6.1
• Listing 6.7 The callback function used by the auto-reload timer in Example 6.1
• Listing 6.8 The vTimerSetTimerID() API function prototype
• Listing 6.9 The pvTimerGetTimerID() API function prototype
• Listing 6.10 Creating the timers used in Example 6.2
• Listing 6.11 The timer callback function used in Example 6.2
• Listing 6.12 The xTimerChangePeriod() API function prototype
• Listing 6.13 Using xTimerChangePeriod()
• Listing 6.14 The xTimerReset() API function prototype
• Listing 6.15 The callback function for the one-shot timer used in Example 6.3
• Listing 6.16 The task used to reset the software timer in Example 6.3
• Listing 7.1 The portEND_SWITCHING_ISR() macros
• Listing 7.2 The portYIELD_FROM_ISR() macros
• Listing 7.3 The xSemaphoreCreateBinary() API function prototype
• Listing 7.4 The xSemaphoreTake() API function prototype
• Listing 7.5 The xSemaphoreGiveFromISR() API function prototype
• Listing 7.6 Implementation of the task that periodically generates a software interrupt in Example 7.1
• Listing 7.7 The implementation of the task to which the interrupt processing is deferred (the task that…
• Listing 7.8 The ISR for the software interrupt used in Example 7.1
• Listing 7.9 The implementation of main() for Example 7.1
• Listing 7.10 The recommended structure of a deferred interrupt processing task, using a UART receive…
• Listing 7.11 The xSemaphoreCreateCounting() API function prototype
• Listing 7.12 The call to xSemaphoreCreateCounting() used to create the counting semaphore in Example 7.2
• Listing 7.13 The implementation of the interrupt service routine used by Example 7.2
• Listing 7.14 The xTimerPendFunctionCallFromISR() API function prototype
• Listing 7.15 The prototype to which a function passed in the xFunctionToPend parameter of xTimerPendFunctionCallFromISR()…
• Listing 7.16 The software interrupt handler used in Example 7.3
• Listing 7.17 The function that performs the processing necessitated by the interrupt in Example 7.3
• Listing 7.18 The implementation of main() for Example 7.3
• Listing 7.19 The xQueueSendToFrontFromISR() API function prototype
• Listing 7.20 The xQueueSendToBackFromISR() API function prototype
• Listing 7.21 The implementation of the task that writes to the queue in Example 7.4
• Listing 7.22 The implementation of the interrupt service routine used by Example 7.4
• Listing 7.23 The task that prints out the strings received from the interrupt service routine in Example 7.4
• Listing 7.24 The main() function for Example 7.4
• Listing 8.1 An example read, modify, write sequence
• Listing 8.2 An example of a reentrant function
• Listing 8.3 An example of a function that is not reentrant
• Listing 8.4 Using a critical section to guard access to a register
• Listing 8.5 A possible implementation of vPrintString()
• Listing 8.6 Using a critical section in an interrupt service routine
• Listing 8.7 The vTaskSuspendAll() API function prototype
• Listing 8.8 The xTaskResumeAll() API function prototype
• Listing 8.9 The implementation of vPrintString()
• Listing 8.10 The xSemaphoreCreateMutex() API function prototype
• Listing 8.11 The implementation of prvNewPrintString()
• Listing 8.12 The implementation of prvPrintTask() for Example 8.1
• Listing 8.13 The implementation of main() for Example 8.1
• Listing 8.14 Creating and using a recursive mutex
• Listing 8.15 A task that uses a mutex in a tight loop
• Listing 8.16 Ensuring tasks that use a mutex in a loop receive a more equal amount of processing time…
• Listing 8.17 The name and prototype for a tick hook function
• Listing 8.18 The gatekeeper task
• Listing 8.19 The print task implementation for Example 8.2
• Listing 8.20 The tick hook implementation
• Listing 8.21 The implementation of main() for Example 8.2
• Listing 9.1 The xEventGroupCreate() API function prototype
• Listing 9.2. The xEventGroupSetBits() API function prototype
• Listing 9.3 The xEventGroupSetBitsFromISR() API function prototype
• Listing 9.4 The xEventGroupWaitBits() API function prototype
• Listing 9.5 The xEventGroupGetStaticBuffer() API function prototype
• Listing 9.6 Event bit definitions used in Example 9.1
• Listing 9.7 The task that sets two bits in the event group in Example 9.1
• Listing 9.8 The ISR that sets bit 2 in the event group in Example 9.1
• Listing 9.9 The task that blocks to wait for event bits to become set in Example 9.1
• Listing 9.10 Creating the event group and tasks in Example 9.1
• Listing 9.11 Pseudo code for two tasks that synchronize with each other to ensure a shared TCP socket…
• Listing 9.12 The xEventGroupSync() API function prototype
• Listing 9.13 The implementation of the task used in Example 9.2
• Listing 9.14 The main() function used in Example 9.2
• Listing 10.1 The xTaskNotifyGive() API function prototype
• Listing 10.2 The vTaskNotifyGiveFromISR() API function prototype
• Listing 10.3 The ulTaskNotifyTake() API function prototype
• Listing 10.4 The implementation of the task to which the interrupt processing is deferred (the task that…
• Listing 10.5 The implementation of the interrupt service routine used in Example 10.1
• Listing 10.6 The implementation of the task to which the interrupt processing is deferred (the task…
• Listing 10.7 The implementation of the interrupt service routine used in Example 10.2
• Listing 10.8 Prototypes for the xTaskNotify() and xTaskNotifyFromISR() API functions
• Listing 10.9 The xTaskNotifyWait() API function prototype
• Listing 10.10 Pseudo code demonstrating how a binary semaphore can be used in a driver library transmit…
• Listing 10.11 Pseudo code demonstrating how a task notification can be used in a driver library transmit…
• Listing 10.12 Pseudo code demonstrating how a task notification can be used in a driver library receive…
• Listing 10.13 Pseudo code demonstrating how a task notification can be used to pass a value to a task
• Listing 10.14 The structure and data type sent on a queue to the server task
• Listing 10.15 The Implementation of the Cloud Read API Function
• Listing 10.16 The Server Task Processing a Read Request
• Listing 10.17 The Implementation of the Cloud Write API Function
• Listing 10.18 The Server Task Processing a Send Request
• Listing 11.1 The prototype for the portSUPPRESS_TICKS_AND_SLEEP macro
• Listing 11.2 The vPortSuppressTicksAndSleep API function prototype
• Listing 11.3 The eTaskConfirmSleepModeStatus API function prototype
• Listing 11.4 The prototype for the configPRE_SLEEP_PROCESSING macro
• Listing 11.5 The prototype for the configPOST_SLEEP_PROCESSING macro
• Listing 11.6 An example of a user defined implementation of portSUPPRESS_TICKS_AND_SLEEP()
• Listing 11.7 The vApplicationIdleHook API function prototype
• Listing 12.1 Using the standard C assert() macro to check pxMyPointer is not NULL
• Listing 12.2 A simple configASSERT() definition useful when executing under the control of a debugger
• Listing 12.3 A configASSERT() definition that records the source code line that failed an assertion
• Listing 12.4 The uxTaskGetSystemState() API function prototype
• Listing 12.5 The TaskStatus_t structure
• Listing 12.6 The vTaskListTasks() API function prototype
• Listing 12.7 The vTaskList() API function prototype
• Listing 12.8 The vTaskGetRunTimeStatistics() API function prototype
• Listing 12.9 The vTaskGetRunTimeStats() API function prototype
• Listing 12.10 16-bit timer overflow interrupt handler used to count timer overflows
• Listing 12.11 Macros added to FreeRTOSConfig.h to enable the collection of run-time statistics
• Listing 12.12 The task that prints out the collected run-time statistics
• Listing 13.1 The uxTaskGetStackHighWaterMark() API function prototype
• Listing 13.2 The uxTaskGetStackHighWaterMark2() API function prototype
• Listing 13.3 The stack overflow hook function prototype

Tables:

• Table 1 FreeRTOS source files to include in the project
• Table 2 TickType_t data type and the configTICK_TYPE_WIDTH_IN_BITS configuration
• Table 3 Macro prefixes
• Table 4 Common macro definitions
• Table 5 The FreeRTOSConfig.h settings to configure the kernel scheduling algorithms
• Table 6 The Effect of the uxBitsToWaitFor and xWaitForAllBits Parameters