Overview: This webinar makes the case that, for all but the smallest 8-bit microcontroller-based systems, an operating system of some form makes sense. We begin by defining the problem: how can we most effectively organize the software/firmware of an embedded device to maximize performance within the constraints of the provided hardware?
We'll examine the polling loop model and analyze its shortcomings. Then we'll look at asynchronous hardware interrupts and see that they are the source of much of the complexity of device-based software. The real-time operating system will be introduced as a way to abstract out the inherent complexity of asynchronous interrupts. We'll then dive into the characteristics and features of operating systems: the tasking model, the scheduler, inter-task communication and synchronization, timing, and of course interrupt handling. We'll consider the problems of sharing resources among multiple tasks. We'll discuss the distinction between an operating system and a kernel. FreeRTOS, a small Open Source kernel, will serve as the model for this entire section.
Next we'll explore design considerations for an OS-based system. How to partition the problem into tasks. We'll look at the idea of dynamic task creation, that is, creating and destroying tasks while the system is running. Solving the resource sharing problem sometimes introduces problems of its own. We'll look at two of these problems, priority inversion and deadly embrace, and assess tech-niques for dealing with them.
Finally, we'll survey some other popular operating systems, both Open Source and pro-prietary, to see where they fit in the grand scheme of things.
Why should you attend: If you're designing and building embedded devices, you really should consider basing the firmware on a real-time operating system (RTOS). Especially in this age of "the Internet of Things", the need for low latency, and in many cases deterministic, response becomes ever more important. Polling loops just can't keep up. The operating system model has a number of advantages. It tends to make systems more modular and reliable. Code breaks down into smaller, more comprehensible units. It scales well. The ultimate result is faster, more efficient software development.
An operating system isn't as mysterious as you might think. It is based on relatively straightforward design principles. It may take some effort to master programming for an OS, but once you do you'll wonder why you wasted time coding polling loops. And operating systems don't always require excessive resources either. Free RTOS, for example, will even run on PIC microcontrollers.
Areas Covered in the Session:
Who Will Benefit:
We'll examine the polling loop model and analyze its shortcomings. Then we'll look at asynchronous hardware interrupts and see that they are the source of much of the complexity of device-based software. The real-time operating system will be introduced as a way to abstract out the inherent complexity of asynchronous interrupts. We'll then dive into the characteristics and features of operating systems: the tasking model, the scheduler, inter-task communication and synchronization, timing, and of course interrupt handling. We'll consider the problems of sharing resources among multiple tasks. We'll discuss the distinction between an operating system and a kernel. FreeRTOS, a small Open Source kernel, will serve as the model for this entire section.
Next we'll explore design considerations for an OS-based system. How to partition the problem into tasks. We'll look at the idea of dynamic task creation, that is, creating and destroying tasks while the system is running. Solving the resource sharing problem sometimes introduces problems of its own. We'll look at two of these problems, priority inversion and deadly embrace, and assess tech-niques for dealing with them.
Finally, we'll survey some other popular operating systems, both Open Source and pro-prietary, to see where they fit in the grand scheme of things.
Why should you attend: If you're designing and building embedded devices, you really should consider basing the firmware on a real-time operating system (RTOS). Especially in this age of "the Internet of Things", the need for low latency, and in many cases deterministic, response becomes ever more important. Polling loops just can't keep up. The operating system model has a number of advantages. It tends to make systems more modular and reliable. Code breaks down into smaller, more comprehensible units. It scales well. The ultimate result is faster, more efficient software development.
An operating system isn't as mysterious as you might think. It is based on relatively straightforward design principles. It may take some effort to master programming for an OS, but once you do you'll wonder why you wasted time coding polling loops. And operating systems don't always require excessive resources either. Free RTOS, for example, will even run on PIC microcontrollers.
Areas Covered in the Session:
- Background
- Nature of Device Programming
- Polling Loop
- What is an interrupt
- Introducing Multi-tasking Operating Systems
- What is a task?
- Inter-task Communication and Synchronization
- Managing Time
- Handling Interrupts
- Designing with a Multi-tasking OS
- Task Partitioning
- Dynamically Creating Tasks
- Problems with Solving the Resource Sharing Problem
- Survey of Multi-tasking Operating Systems
- Open Source
- "Kind of" Open Source
- Commercial/Proprietary
Who Will Benefit:
- Embedded engineer
- Software engineer
- Firmware engineer
- System architect
- Engineering Manager
No comments:
Post a Comment