Welcome aboard, coders!!
Whether you are a beginner exploring RTOS for the first time or an experienced developer enhancing your skills, this course provides the tools and knowledge to design and implement efficient, responsive, and scalable embedded applications using FreeRTOS.
This course is designed for engineers, students, and developers who want to gain a comprehensive understanding of FreeRTOS and its practical applications in embedded systems.
No prior experience with real-time operating systems is required, as we will cover foundational concepts at the beginning of the course.
Course Content
Phase 1: Introduction to Real-Time Operating Systems (RTOS)
Real-Time Operating Systems (RTOS) are a cornerstone of modern embedded systems. You’ll learn about the predictability, multitasking capabilities, and scalability that RTOS brings to embedded designs. Additionally, we will discuss real-world applications, highlighting industries where RTOS is essential for maintaining precision and reliability in critical systems.
Phase 2: Setting Up Your Tools
Before diving into FreeRTOS, it’s crucial to prepare your development environment and set up debugging capabilities. We will guide you step-by-step through this process, ensuring that your system is ready for efficient development. Special emphasis will be placed on configuring FreeRTOS correctly and avoiding common pitfalls during the setup phase.
Phase 3: Tasks
Tasks are the building blocks of any RTOS application. In this module, you will gain a deep understanding of what tasks are, how they are created, and how FreeRTOS manages their execution. We will cover the importance of task prioritization and demonstrate the process of task switching. Through hands-on examples, you’ll learn how to implement multitasking efficiently.
Phase 4: Queues
Communication between tasks is vital for a well-functioning RTOS application, and queues provide a powerful mechanism for this purpose. In this section, you’ll learn how to create queues in FreeRTOS, use them to pass data between tasks, and manage common patterns like producer-consumer systems.
Phase 5: Timers
Timers are essential for tasks that need to run at specific intervals or after a delay. In this module, we will explore the use of FreeRTOS software timers and explain how to set them up for periodic and one-shot operations. Practical examples will illustrate how timers enhance the functionality and precision of your application.
Phase 6: Interrupts
In this module, you will learn how to integrate interrupts with tasks in FreeRTOS through practical examples. We will explore the use of binary semaphores to unblock tasks when interrupts occur, counting semaphores to handle multiple interrupt events, and queues to pass messages from interrupts to tasks, such as controlling an LED’s status. These techniques provide a solid foundation for building responsive and efficient embedded systems.
Phase 7: Mutexes
Synchronization is key to preventing race conditions and ensuring data integrity in multitasking environments. This module focuses on mutexes (mutual exclusions), which are used to protect shared resources. You will learn how to implement mutexes in FreeRTOS, understand priority inheritance to resolve potential deadlocks, and explore real-world scenarios where mutexes are essential.
Phase 8: Direct to Task Notifications
Direct-to-Task Notifications offer a lightweight and efficient alternative to queues for inter-task communication. In this section, you’ll learn how to send and receive notifications directly between tasks. We’ll discuss scenarios where this feature outperforms traditional communication mechanisms, providing examples that highlight its simplicity and effectiveness in enhancing system performance.
Phase 9: Direct to Task Notifications
Stream and message buffers offer flexible ways to manage data exchange in FreeRTOS. You will explore how these buffers work, their advantages, and how to implement them. Practical examples will demonstrate their utility in complex applications, and we’ll discuss strategies to optimize buffer size and performance.
Phase 10: FreeRTOS Kernel Analysis
Understanding the internals of the FreeRTOS kernel is crucial for advanced users. This section delves into how the kernel manages scheduling, memory, and synchronization. We’ll use tools and techniques to analyze the kernel’s behavior, providing insights into debugging and optimizing your system. By the end, you will have a clearer understanding of what happens behind the scenes in FreeRTOS.
Final Project: The final challenge
The final project is designed to consolidate everything you’ve learned during the course. You will develop a complete application using FreeRTOS, integrating tasks, queues, timers, and synchronization mechanisms. This project will not only solidify your understanding but also provide a practical demonstration of your skills, preparing you to tackle real-world challenges confidently.
For more information:
Requirements
- Laptop Linux or Windows
- Basic understanding of embedded systems, including familiarity with C programming, microcontroller, and debugging tools.
Resources
- GO board
- private Slack group for participants
Duration
- Duration of the upskilling: 6 weeks
- Session with instructor: 2 remote sessions per week (90 minutes each)
- Independent activities: 6 hours per week for assigned practical tasks.
Free
Self-paced learning with limited access.
Free
Limited access to course content using Embedded House
Professional
Mentored with a hardware kit.
$17,400 MXN
Full access to the course content
Dev kit included
Weekly group mentorship
Badge and Certificate of Completion
Enterprise
Custom training for engineering teams.
Custom
Full access to the course content
Custom driver modules
Dedicated support
