Development of Real-Time Systems

Go to Course: https://www.coursera.org/learn/real-time-systems

Introduction

# Review of the Coursera Course: Development of Real-Time Systems In today’s fast-paced technology landscape, the ability to develop real-time systems is more crucial than ever. For those seeking to enhance their skills in embedded systems programming, the **Development of Real-Time Systems** course on Coursera is a must-try. This course adeptly combines theoretical knowledge with practical application, empowering learners to successfully design and implement real-time systems. ## Course Overview The **Development of Real-Time Systems** course is primarily geared towards individuals interested in practical programming and problem-solving within the realm of embedded systems. The focus is on achieving timing correctness—ensuring that systems respond within specific real-time constraints. As we delve deeper into essential examples such as airbags, emergency brakes, avionics, and multimedia systems (like video playback), participants will emerge with a holistic understanding of real-time requirements and the means to address them effectively. ### Course Syllabus The course is structured into several comprehensive modules, each building upon the previous one, offering a step-by-step approach to mastering real-time systems. 1. **Introduction to Real-Time Systems** - This opening week lays the groundwork for your journey into real-time systems. You will learn about essential concepts such as task structures, scheduler types, and the significant differences between pre-emptive and non-pre-emptive tasks. - Outcomes Include: Understanding what constitutes a real-time system and identifying key requirements. 2. **Static Scheduling** - Here, you’ll dive into scheduling, starting with the clock-driven scheduler and advancing to fixed priority and monotonic schedulers. This module focuses on scheduling strategies and the validation of task overloads. - Outcomes Include: Scheduling tasks effectively and utilizing FreeRTOS for task prioritization. 3. **Dynamic Scheduling** - Building on previous knowledge, this module introduces dynamic scheduling methods, including the Least Slack Time (LST) and Earliest Deadline First (EDF) algorithms. - Outcomes Include: Mastering feasibility determination for task sets and practical scheduling methodologies. 4. **Non-Periodic Jobs** - As the course evolves, you’ll tackle the complexity introduced by non-periodic jobs. This week emphasizes optimization techniques and validation processes when sporadic tasks appear. - Outcomes Include: Applying slack stealing methods and designing efficient schedules accommodating unpredictable tasks. 5. **Real-Time Operating Systems** - The final week of the course is perhaps the most anticipated. It dives into the mechanisms of FreeRTOS and introduces the intricacies of multi-core real-time system architectures and scheduling methods. - Outcomes Include: Understanding the FreeRTOS internals and multi-core scheduling approaches. ## Course Experience One of the biggest advantages of this course is its balance between theoretical knowledge and practical implementation. Each week combines video lectures, readings, quizzes, and hands-on programming exercises, ensuring a well-rounded learning experience. The course materials are well-organized and facilitate ease of understanding the complex concepts inherent in real-time systems. Moreover, having access to a community of peers allows for collaboration and support, enhancing the learning experience even further. The feedback provided on assignments is constructive, pushing participants to refine their understanding and application of course materials. ## Recommendation I highly recommend the **Development of Real-Time Systems** course on Coursera for anyone involved or interested in the field of embedded systems. Whether you are a student looking to gain foundational skills or a working professional aiming to deepen your knowledge, this course provides a comprehensive guide into the intricate world of real-time systems. With its practical focus and expert-designed curriculum, you're not just learning concepts; you are preparing to apply them in real-world scenarios, making this course an invaluable investment in your career. **Pros:** - Well-structured syllabus designed for both beginners and experienced programmers. - Hands-on programming exercises enhance practical skills. - Engaging teaching methodologies that reinforce key concepts. **Cons:** - The complexity of topics may be challenging for absolute beginners without any prior programming experience. Embark on this exciting journey into real-time systems, and equip yourself with the skills to make a meaningful impact in the tech industry today!

Syllabus

Introduction to Real-Time Systems

Here is where it all starts! We will make a brave attempt to start your future career in real-time systems! This week starts by learning the basic building stones in real-time systems and the system parameters required to successfully construct a real-time system. We introduce you to the corner stone of real-time systems, namely the scheduler – and its task in real-time schedules. You learn also what kind of real-time guarantees are needed in which systems. Concretely, you will learn (1) What is needed to create a real-time system (2) Where real-time requirements are needed. (3) The task and job structure and the parameters needed to schedule a task. (4) Difference between pre-emptive and non-pre-emptive tasks. This course is also part of a Blended Master Programme in Embedded Systems.

In this week we start to actually do some scheduling. We firstly have a look at the simplest type of scheduler – the clock driven scheduler. After this we deepen our learning with the fixed priority scheduler and the monotonic schedulers. We learn how the priorities are determined using these schedulers and we learn when/when not to use these schedulers. Secondly we learn how to determine if a system is overloaded in order to validate schedules without complete system simulation.Concretely, after attending this week you will be able to: (1) Schedule a set of tasks with the clock driven scheduler, with the fixed priority scheduler, with the monotonic schedulers. (2) Determine if a system is overloaded using the total-utilization method and the Urm method. (3) Program FreeRTOS to schedule a set of tasks using the fixed priority scheduler

In the previous week we learned the limitations of the total-utilization method and the Urm method. We start this week off by extending these tests to tasks with short response times. The new method is also, as usual, used in practice! We then focus on improving the optimality of real-time schedules. This is done by learning the principles behind dynamic scheduling methods. Two new schedulers using the dynamic scheduling principle is learned and used in practice with a few examples; the LST scheduler and the EDF scheduler.Concretely, you will learn: (1) How to determine feasibility of a set of tasks using the time demand analysis method. (2) How to schedule a set of tasks using LST and EDF. (3) To determine when a dynamic scheduler is appropriate and when it is not appropriate.

All things are easy and nice when not caring about non-periodic jobs. When including non-periodic jobs, the schedulers must take these into account to make a feasible schedule, which we learn this week. The problem is that a non-periodic job can arrive at any time, even if a periodic job is already scheduled. We learn both how to optimize a schedule for non-periodic jobs and how to validate a schedule when non-periodic jobs arrive to the schedule. Concretely, we will learn: (1) How to use the slack stealing method to optimize a schedule with non-periodic jobs (2) How to use the LRT scheduler to optimize a schedule with non-periodic jobs (3) How to use the deferrable server to optimize a schedule with non-periodic jobs (4) Formally verify a schedule with non-periodic jobs

This week is what we all have been waiting for! We will deepen our learning of FreeRTOS, its kernel and the functionalities. We demonstrate the importance of predictable computer architectures for example when determining the context switch and factors influencing this overhead. As we head towards the future, we finish this course by introducing you to multi-core real-time systems and scheduling methods for multi-core real-time systems. Concretely, you will learn: (1) The internal mechanisms of FreeRTOS, for example mutexes/semaphores and message queues. (2) Multi-core computer architectures for real-time systems. (3) Multi-core scheduling methods.