- Module 1: Description TBD
In this module, you will:
- Learn the basic components of an RTOS
- Learn what an RTOS does
- Module 2: Learn the fundamentals of Azure RTOS ThreadX.
In this module, you will:
- Learn Azure RTOS ThreadX concepts such as scheduling, determinism, priorities, preemption, and threads.
- Explore the services of an RTOS and how they can be used.
- Learn about context switches.
- Module 3: Learn about the memory management options that are available in Azure RTOS ThreadX.
In this module, you will:
- View an overview of Azure RTOS ThreadX services
- Learn about ThreadX primitive data types and service data types
- Learn about ThreadX memory byte pools
- Learn about memory allocation for thread stacks
- Learn about ThreadX memory block pools
- Module 4: Learn how to create a Hello World project by using Azure RTOS ThreadX.
In this module, you will:
- Be introduced to the basics of Azure RTOS ThreadX system development.
- Walk through a simple illustrative example of an Azure RTOS ThreadX project.
- Be given a simple but realistic scenario, identify the essential ThreadX components needed to implement that system.
- Understand the fundamentals required for an Azure RTOS ThreadX real-time solution.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 5: Now that you have created your first Hello World project, have you thought about analyzing the behavior of your system? If so, this is the module you should investigate.
In this module, you will:
- Explore the features and uses of Application Timers and the Thread Info Get services.
- Review the purpose of the internal system clock.
- Obtain a better understanding of the behavior of the Hello World project and modify some of its code.
- Use the internal system clock function to collect timing data for each cycle of the activities performed by the two threads.
- Use an Application Timer to compute and display the total number of cycles each thread completed, the average time for each cycle, and selected values provided by the thread_performance_info_get service.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 6: Learn how to use Wait Abort to break thread suspension in Azure RTOS ThreadX.
In this module, you will:
- Explore the features and uses of counting semaphores and the TX_WAIT_ABORT service.
- Understand the purpose of a monitor thread.
- Use a monitor thread to detect excessive wait times by other threads and break the suspension of those threads.
- Use an application timer to compute and display the total number of cycles each thread completed, the average time for each cycle, and selected values provided by the thread_performance_info_get service.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 7: Learn when to use a mutex and a counting semaphore and consolidate your understanding of the differences.
In this module, you will:
- Use a counting semaphore in an event notification application.
- Use two threads in a producer-consumer scenario.
- Understand the difference between mutual exclusion and event notification.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 8: Learn how to use an event flags group to sync threads in Azure RTOS ThreadX.
In this module, you will:
- Understand how to synchronize threads using an event flags group.
- Use the Set service to clear or initialize an event flags group.
- Use the Get service to retrieve events from an event flags group.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 9: Learn how to have threads send messages to other threads.
In this module, you'll:
- Understand how to send messages from one thread to another thread by using a message queue.
- Understand how to receive messages from a queue.
- Understand how to send a message to the front of a queue, rather than to the rear of the queue.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 10: Learn how to use event-chaining to suspend multiple objects in Azure RTOS ThreadX..
In this module, you will:
- Understand the ThreadX-unique concept of event-chaining.
- Understand how to have one thread suspend on multiple objects.
- Understand the concept of notification callback functions.
- Design and debug the ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Module 11: Learn how preemption threshold and priority inheritance work as solutions to priority inversion in Azure RTOS ThreadX.
In this module, you will:
- Understand the dangers of priority inversion
- Understand how to use priority inheritance to avoid priority inversion problems.
- Understand how to use preemption threshold to avoid priority inversion problems.
- Understand the differences between these two solutions to the priority inversion problem.
- Design and debug a ThreadX solution using a hands-on approach with GitHub Codespace or Visual Studio.
- Study the priority inversion problem, and compare the priority inheritance and preemption threshold solutions.
- Module 12: Learn the next learning path for ThreadX.
In this module, you will:
- Review the concepts and features of ThreadX.
- Explore the components of Azure RTOS.
- Explore the ThreadX user guide.
- Explore the online ThreadX book.
Overview
Syllabus
- Module 1: Module 1: Introduction to Azure RTOS
- Introduction
- Set up your environment
- Module 2: Module 2: Azure RTOS ThreadX fundamentals
- Introduction
- Determinism
- Scheduling
- All about priorities
- Threads and stacks
- Priority-based preemption
- Context switches
- Knowledge check
- Summary
- Module 3: Module 3: Azure RTOS ThreadX memory management
- Introduction
- ThreadX overview
- Memory management
- Memory thread stacks
- Knowledge check
- Summary
- Module 4: Module 4: Azure RTOS ThreadX first project
- Introduction
- Illustrative Azure RTOS ThreadX project
- The Hello World scenario
- Identify ThreadX components
- Design the Hello World project
- Exercise - Build and debug ProjectHelloWorld
- Knowledge check
- Summary
- Module 5: Module 5: Azure RTOS ThreadX — Analyze thread behavior with timing facilities
- Introduction
- ProjectAnalyze
- Application timer
- Obtain run-time cumulative statistics
- Building blocks for ProjectAnalyze
- Exercise: Build and debug in ProjectAnalyze
- Knowledge check
- Summary
- Module 6: Module 6: Use Wait Abort to break thread suspension
- Introduction
- Thread suspension overview
- Project activities
- Counting semaphores
- Design considerations
- Project building blocks
- Exercise - Build and debug
- Knowledge check
- Summary
- Module 7: Module 7: Use a counting semaphore for event notification in Azure RTOS ThreadX
- Introduction
- Counting semaphore versus mutex comparison
- ProjectProducerConsumer scenario
- ProjectProducerConsumer activities
- Design considerations for ProjectProducerConsumer
- Building blocks for ProjectProducerConsumer
- Exercise - Build and debug ProjectProducerConsumer
- Knowledge check
- Summary
- Module 8: Module 8: Use an event flags group to sync threads in ThreadX
- Introduction
- Event flags group overview
- Declare an event flags group
- Event flags group project scenario
- Event flags group project activities
- Design considerations
- Project building blocks
- Exercise - Build and debug
- Knowledge check
- Summary
- Module 9: Module 9: Use message queues for inter-thread communication in Azure RTOS ThreadX
- Introduction
- Message queues
- ProjectMessageQueues scenario
- ProjectMessageQueues activities
- Design considerations for ProjectMessageQueues
- Building blocks for ProjectMessageQueues
- Exercise - Build and debug ProjectMessageQueues
- Knowledge check
- Summary
- Module 10: Module 10: Use event-chaining to suspend multiple objects in ThreadX
- Introduction
- Overview
- Notification callback functions
- Project scenario
- Project activities
- Design considerations
- Project building blocks
- Exercise - Build and debug
- Knowledge check
- Summary
- Module 11: Module 11: ThreadX priority inversion solutions
- Introduction
- Overview
- Project scenario
- Project activities
- Priority inheritance
- Preemption threshold
- Project building blocks
- Exercise - Build and debug
- Knowledge check
- Summary
- Module 12: Module 12: Azure RTOS ThreadX next steps
- Overview
- Azure RTOS components
- ThreadX user guide
- Online ThreadX book
- Summary
