Book Image

Hands-On RTOS with Microcontrollers

By : Brian Amos
Book Image

Hands-On RTOS with Microcontrollers

By: Brian Amos

Overview of this book

A real-time operating system (RTOS) is used to develop systems that respond to events within strict timelines. Real-time embedded systems have applications in various industries, from automotive and aerospace through to laboratory test equipment and consumer electronics. These systems provide consistent and reliable timing and are designed to run without intervention for years. This microcontrollers book starts by introducing you to the concept of RTOS and compares some other alternative methods for achieving real-time performance. Once you've understood the fundamentals, such as tasks, queues, mutexes, and semaphores, you'll learn what to look for when selecting a microcontroller and development environment. By working through examples that use an STM32F7 Nucleo board, the STM32CubeIDE, and SEGGER debug tools, including SEGGER J-Link, Ozone, and SystemView, you'll gain an understanding of preemptive scheduling policies and task communication. The book will then help you develop highly efficient low-level drivers and analyze their real-time performance and CPU utilization. Finally, you'll cover tips for troubleshooting and be able to take your new-found skills to the next level. By the end of this book, you'll have built on your embedded system skills and will be able to create real-time systems using microcontrollers and FreeRTOS.

Related Content you might be interested in

Current Title:

Small book image
Hands-On RTOS with Microcontrollers
Brian Amos
May, 2020 | 496 pages
Small book image
Architecting High-Performance Embedded Systems
Jim Ledin
Feb, 2021 | 376 pages
Small book image
Embedded Systems Architecture
Daniele Lacamera
Jan, 2023 | 342 pages
Small book image
The Insider’s Guide to Arm Cortex-M Development
Pareena Verma | Jason Andrews | Zachary Lasiuk
Oct, 2022 | 276 pages
Table of Contents (24 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
Section 1: Introduction and RTOS Concepts
Section 1: Introduction and RTOS Concepts
Free Chapter
2
Introducing Real-Time Systems
Introducing Real-Time Systems
Technical requirements
What is real-time anyway?
Defining RTOS
Deciding when to use an RTOS
Summary
Questions
3
Understanding RTOS Tasks
Understanding RTOS Tasks
Technical requirements
Introducing super loop programming
Achieving parallel operations with super loops
Comparing RTOS tasks to super loops
Achieving parallel operations with RTOS tasks
RTOS tasks versus super loops – pros and cons
Summary
Questions
Further reading
4
Task Signaling and Communication Mechanisms
Task Signaling and Communication Mechanisms
Technical requirements
RTOS queues
RTOS semaphores
RTOS mutexes
Summary
Questions
5
Section 2: Toolchain Setup
Section 2: Toolchain Setup
6
Selecting the Right MCU
Selecting the Right MCU
Technical requirements
The importance of MCU selection
MCU considerations
Development board considerations
Introducing the STM32 product line
How our development board was selected
Summary
Questions
Further reading
7
Selecting an IDE
Selecting an IDE
Technical requirements
The IDE selection criteria
Free MCU vendor IDEs and hardware-centric IDEs
Platform-abstracted IDEs
Open source/free IDEs
Proprietary IDEs
Selecting the IDE used in this book
Considering STM32Cube
Setting up our IDE
Summary
Questions
Further reading
8
Debugging Tools for Real-Time Systems
Debugging Tools for Real-Time Systems
Technical requirements
The importance of excellent debugging tools
Using SEGGER J-Link
Using SEGGER Ozone
Using SEGGER SystemView
Other great tools
Summary
Questions
Further reading
9
Section 3: RTOS Application Examples
Section 3: RTOS Application Examples
10
The FreeRTOS Scheduler
The FreeRTOS Scheduler
Technical requirements
Creating tasks and starting the scheduler
Deleting tasks
Trying out the code
Task memory allocation
Understanding FreeRTOS task states
Troubleshooting startup problems
Summary
Questions
Further reading
11
Protecting Data and Synchronizing Tasks
Protecting Data and Synchronizing Tasks
Technical requirements
Using semaphores
Using mutexes
Avoiding race conditions
Using software timers
Summary
Questions
Further reading
12
Intertask Communication
Intertask Communication
Technical requirements
Passing data through queues by value
Passing data through queues by reference
Direct task notifications
Summary
Questions
Further reading
13
Section 4: Advanced RTOS Techniques
Section 4: Advanced RTOS Techniques
14
Drivers and ISRs
Drivers and ISRs
Technical requirements
Introducing the UART
Creating a polled UART driver
Differentiating between tasks and ISRs
Creating ISR-based drivers
Creating DMA-based drivers
Stream buffers (FreeRTOS 10+)
Choosing a driver model
Using third-party libraries (STM HAL)
Summary
Questions
Further reading
15
Sharing Hardware Peripherals across Tasks
Sharing Hardware Peripherals across Tasks
Technical requirements
Understanding shared peripherals
Introducing the STM USB driver stack
Developing a StreamBuffer USB virtual COM port
Using mutexes for access control
Summary
Questions
16
Tips for Creating a Well-Abstracted Architecture
Tips for Creating a Well-Abstracted Architecture
Technical requirements
Understanding abstraction
Writing reusable code
Organizing source code
Summary
Questions
Further reading
17
Creating Loose Coupling with Queues
Creating Loose Coupling with Queues
Technical requirements
Understanding queues as interfaces
Creating a command queue
Reusing a queue definition for a new target
Summary
Questions
18
Choosing an RTOS API
Choosing an RTOS API
Technical requirements
Understanding generic RTOS APIs
Comparing FreeRTOS and CMSIS-RTOS
FreeRTOS and POSIX
Deciding which API to use
Summary
Questions
Further reading
19
FreeRTOS Memory Management
FreeRTOS Memory Management
Technical requirements
Understanding memory allocation
Static and dynamic allocation of FreeRTOS primitives
Comparing FreeRTOS heap implementations
Replacing malloc and free
Implementing FreeRTOS memory hooks
Using a memory protection unit (MPU)
Summary
Questions
Further reading
20
Multi-Processor and Multi-Core Systems
Multi-Processor and Multi-Core Systems
Technical requirements
Introducing multi-core and multi-processor systems
Exploring multi-core systems
Exploring multi-processor systems
Exploring inter-processor communication
Choosing between multi-core and multi-processor systems
Summary
Questions
Further reading
21
Troubleshooting Tips and Next Steps
Troubleshooting Tips and Next Steps
Technical requirements
Useful tips
Using assertions
Next steps
Summary
Questions
22
Assessments
Assessments
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13
Chapter 14
Chapter 15
Chapter 16
Chapter 17
23
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Technical requirements

To complete the hands-on exercises in this chapter, you will require the following:

  • Nucleo F767 development board
  • Micro USB cable
  • ST/Atollic STM32CubeIDE and its source code (the instructions for this can be found in Chapter 5, Selecting an IDE – Setting Up Our IDE)
  • SEGGER JLink, Ozone, and SystemView (Chapter 6, Debugging Tools for Real-Time Systems)

The easiest way to build the examples in this chapter is to build all Eclipse configurations at once, and then load and view them using Ozone. To do this, follow these steps:

  1. In STM32CubeIDE, right-click on the project.
  2. Select Build.
  3. Select Build All. All the examples will be built into their own named subdirectory (this may take a while).
  4. In Ozone, you can now quickly load each <exampleName>.elf file. See Chapter 6, Debugging Tools for Real-Time Systems, for instructions on how to do this...
Previous Section
End of Section 2
Next Section