Training Courses |
Embedded Systems Development with Real-Time Operating Systems in C/C++Course id: 0025 SynopsisAs consumer electronic devices continue to flood the market, their applications are moving from single function to multi-function smart devices. As a result, simple hard-coded embedded software is no longer sufficient to cater to market demand and the use of a Real-Time Operating System (RTOS) for even simple applications is becoming prevalent.
Course highlights
Participants would be using the popular FreeRTOS that supports 27 embedded architectures for this course. What you will learnThis course concentrates on the theoretical and practical knowledge to allow participants to achieve the following learning outcomes. Upon completing the course, participants would be able to:
- Understand the concept of real-time, task, multitasking, scheduling and context switching
- Design programs based on a collection of tasks executing pseudo-concurrently
- Use queues, semaphores and mutaxes for inter-task communication
- Implement proper resource sharing methods to prevent task deadlocks and priority inversions
- Respond and handle interrupts in a timely manner
- Debug multi-task programs using RTOS constructs
Who should attendBoth hardware and software engineers who are working closely in the embedded space. Anyone who is interested to learn more about Real-Time Operating Systems.PrerequisiteC knowledge, general computer architecture, some embedded-systems experience, basic assembly.Course methodologyThis course is presented classroom style, with lab exercises/demonstrations.Course duration4 days.Course structure
- What is a Real-Time Operating System (RTOS)?
- Operating System: overview
- Real-Time: overview and justifications
- Hard vs Soft: overview and applications
- What is a task?
- Tasks: overview, states, transitions, priorities etc
- Kernel: Cyclic-executive and multi-tasking
- What is an interrupt?
- Interrupt response: overview of each stage of an interrupt response
- Interrupt handling: how to handle interrupts, multiple interrupts, etc
- What is context switching?
- Machine context: what is it?
- Context-switching: how does it work?
- Kernel classifications: Co-operative/Pre-emptive
- How do we perform scheduling?
- Priorities: static vs dynamic
- Scheduling: static vs dynamic
- Determinism: deterministic and non-deterministic
- What is FreeRTOS?
- FreeRTOS: overview, architecture and features
- Licensing: GPL vs FreeRTOS licensing
- Lab 1
- Installing and setting up the tool-chain
- Overview of the FreeRTOS files and directory structure
- Building FreeRTOS demo
- Inter-task communication
- Queues: overview, how to use
- Semaphores: overview, how to write and use
- Mutexes: as a binary semaphore
- Cooperative Kernel
- Overview: what it is and applications
- FreeRTOS as a cooperative kernel
- Lab 2
- Building FreeRTOS cooperative kernel
- Running multiple tasks
- Inter-task communication - sizing the producer-consumer problem
- Preemptive Kernel
- Overview: what it is and applications
- FreeRTOS as a preemptive kernel
- Resource sharing
- Critial section: identification and demarcation
- Using mutexes: locking/releasing resources
- Deadlocks: avoidance strategies
- Priority inversion: avoidance strategies
- Lab 3
- Building the FreeRTOS pre-emptive kernel
- Resource sharing problems - I/O devices and memory
- Interrupt handling
- Deferred interrupt processing
- Synchronisation with task
- Queue processing within interrupt
- Memory management
- Overview: understanding how the OS handles memory
- FreeRTOS memory allocation schemes
- Debugging
- Watch: call stack, queue, semaphore, mutex states
- Memory usage
- Tracing: legacy method, Trace Hook macros
- Lab 4
- Memory management schemes
- Synchronisation queues
- Advance topics/discussion
- FreeRTOS memory foot-print
- FreeRTOS performance testing
- Using FreeRTOS with C++ applications
- Others
|
Course Schedule |
