EDA223/DIT162 Real-Time Systems
Official course information: [ EDA223, DIT162, TimeEdit ]
The course encompasses lectures, exercise sessions, special sessions and a laboratory assignment.
The lectures aim at introducing fundamental theories and concepts as well as a programming paradigm, and demonstrating how theory and paradigm are applied.
The exercise sessions focus on the specific topics covered during the main lectures. At each session, selected parts of the course contents are highlighted, and solutions to relevant problems are demonstrated.
The special sessions are a complement to the lectures and exercises. Here, it is possible to get additional help with the laboratory assignment regarding, for example, software design methods, functionality of development tools or music theory. It also offers an opportunity to discuss solutions to exercise problems or old exam problems.
In the laboratory assignment the students (in small project groups) should implement the software for an embedded real-time application running on stand-alone hardware system, that should later be interconnected by a bus network and perform a collective task.
At the end of the course the students document their laboratory assignment in a written project report.
Aim and content
An embedded system is a computer system designed to perform one or a few dedicated functions. It is embedded in the sense that it is part of a complete device, often including electrical hardware and mechanical parts. For reasons of safety and usability, some embedded systems have strict constraints on non-functional behavior such as computational delay and periodicity. Such systems are referred to as real-time systems. Examples of real-time systems are control systems for cars, aircraft and space vehicles as well as computer games and multimedia applications. This course is intended to give basic knowledge about methods for the design and analysis of real-time systems.
After the course the students shall be able to
- Formulate requirements for embedded systems with strict constraints on computational delay and periodicity.
- Construct concurrently-executing tasks (software units) for real-time applications that interface to hardware devices (sensors/actuators).
- Describe the principles and mechanisms used for designing run-time systems and communication networks for real-time applications.
- Apply the basic analysis methods used for verifying the temporal correctness of a set of executing tasks.
Due to the extremely high costs associated with late discovery of problems in embedded systems, it is important to follow a good design methodology during the development of the software and hardware. One means for that is to use a system architecture that offers good component abstractions and facilitates simple interfacing of components.
The system architecture philosophy dictates that the software of an embedded system is organized into multiple concurrently-executing tasks, where each task (or group of tasks) implements a specific functionality in the system. This approach allows for an intuitive way of decomposing a complex system into smaller software units that are simple to comprehend, implement and maintain. The software environment used in the course is based on the C programming language, enhanced with a software library that provides support for programming of concurrent tasks with timing (delay and periodicity) constraints. To that end, a main objective of the course is to demonstrate how the enhanced C programming language is used for implementing communication/synchronization between tasks, resource management and mutual exclusion. Since other programming languages uses monitors or semaphores to implement these functions, the course also contains a presentation of such techniques. In addition, the course demonstrates how to use low-level programming in C to implement interrupt-driven interaction with hardware devices. To demonstrate the general principles in real-time programming, the course also gives examples of how these techniques are implemented in other programming languages, such as Ada and Java.
In order to execute a program containing concurrent tasks there is a run-time system (real-time kernel) that distributes the available capacity of the microprocessor(s) among the tasks. The course shows how a simple run-time system is organized. The run-time system determines the order of execution for the tasks by means of a scheduling algorithm. To that end, the course presents techniques based on cyclic time-table based scheduling as well as scheduling techniques using static or dynamic task priorities. In addition, protocols for the management of shared hardware and software resources are presented. Since many contemporary real-time applications are distributed over multiple computer nodes, the course also presents topologies and medium access mechanisms for some commonly-used communication networks.
In real-time systems, where tasks have strict timing constraints, it is necessary to make a pre-run-time analysis of the system schedulability. The course presents three different analysis methods for systems that schedule tasks using static or dynamic priorities: utilization-based analysis, response-time analysis, and processor-demand analysis. In conjunction with this, the course also gives an account on how to derive the maximum resource requirement (worst-case execution time) of a task.
||First lecture, 13:15 - 15:00 (conducted on-line via Zoom)
||Deadline - registration to project group
||Loan equipment pick-up (by appointment only)
||Study week 3
||Trial on-line session (development software installation)
||Study week 4
||First on-line laboratory session (compulsory attendance)
||Study week 8
||Final on-line laboratory session (preliminary lab grade given)
||Written exam, morning, remote examination
||Loan equipment return (by appointment only)
||Deadline - submission of project report
||Deadline - approval of project report (final lab grade given)
The student is evaluated through a final written exam (4.5 hec) and a compulsory laboratory assignment (3.0 hec).
The final grade, according to the scale Fail (U) or Pass (3, 4, 5), is given based on the individual grades for the written exam and the laboratory assignment.
Permitted aids at the written exam are the compendium J. Nordlander: Programming with the TinyTimber kernel and a Chalmers-approved calculator.
Additional information regarding the written exam can be found on the Examination page in Canvas.
Additional information regarding the laboratory assignment can be found on the Assignment page in Canvas.
Your progress regarding the different examination objectives can be viewed via the Modules menu in Canvas.
||Lecture notes. Department of Computer Science and Engineering, Chalmers, 2021. Mandatory reading.
Can be downloaded from the Lectures and Exercises pages in Canvas.
||Selected texts from archival journals, conference proceedings and books. Not mandatory reading, but useful for gaining both deeper and broader topic knowledge.
Can be downloaded from the Lectures page in Canvas.
||Exercise compendium. Department of Computer Science and Engineering, Chalmers, 2012.
Can be downloaded from the Resources page in Canvas.
||Development tools and tutorials related to the laboratory assignment.
Can be downloaded from the Resources page in Canvas.
Changes taking effect during spring 2021:
- Due to the corona virus outbreak all teaching will be carried out remotely. Lectures will take place on-line (via Zoom) and laboratory assignment work will be done at home (using loan equipment).
- The written exam will have a new grading procedure, encompassing a Basic part and an Advanced part. The Basic part contains problems that must be solved by all students to secure the minimum grade for passing the exam. The Advanced part contains problems that should be solved by students that aim for the higher grades.
- The number of course participants is restricted to 56 Chalmers students and 8 GU students.
Students in the MPHPC, MPCSN, MPEES and MPSOF master programmes have priority to this course.
Other students who fulfill the prerequisites are admitted if seats are available.
Changes from previous years:
- The course web pages are hosted by the Canvas system (since 2019)
- The laboratory sessions take place at the Lindholmen campus (since 2019)
- The final grade is based on the grades for the 'Examination' and 'Laboratory' course elements (since 2018).
- The 'Laboratory' course element (Chalmers) uses the grading scale U, 3, 4, 5 (since 2018).
- The 'Laboratory' course element (GU) uses the grading scale U, G, VG (since 2018).
- The laboratory assignment uses new hardware and development software (since 2017).