Category: Featured

Before discussing operating systems, it is necessary to understand the platform we will be using, including both the hardware, which is the NXP S32K144-Q100 board, and the software, which in our case will be the preconfigured RTD drivers and TrampolineRTOS.

We will learn theoretical concepts such as schedulers, tasks, priorities, preemption, and semaphores. We will also cover the features that distinguish an OSEK/VDX-type operating system, as well as its configuration parameters.

The foundation of any program with an operating system is tasks, and in this second part, we will learn how to define them in the OSEK operating system and configure their attributes, such as priority, number of activations, and task type. We will also cover the concept of events and how events help us synchronize tasks. Examples and initial exercises with the operating system will help reinforce these concepts.

Tasks can be considered as autonomous programs, but an application consists of multiple tasks interacting with each other. This week, we will explore the mechanisms of inter-task communication to coordinate the information exchanged between them.
OSEK defines the concept of “message objects” for both receiving and transmitting between tasks. These are also used as notification mechanisms to establish events, invoke callbacks, and activate tasks.

System tick configuration (Main Counter) to establish the time base for the entire system. OSEK defines the concept of timers as alarms, which are mechanisms used to determine task execution, establish events, or invoke callback functions. Additionally, we will explore how these alarms can be modified at runtime.

In a multitasking system, there are potential risks if more than one task tries to access the same resource. In this final week, we will learn how to manage system resources efficiently to prevent data corruption issues and how the OSEK Priority Ceiling protocol works for ensuring resource access control.

No system can operate without using interrupts for handling real-time external stimuli. We will also explore how to establish communication between interrupts and tasks that are waiting for messages.

• The software architect role
• Interactions of software architecture with stakeholders and the organization

• Working with SW requirements and Low-Level Requirements

Real-Time Operating Systems (RTOS) are a cornerstone of modern embedded systems. You’ll learn about the predictability, multitasking capabilities, and scalability that RTOS brings to embedded designs. Additionally, we will discuss real-world applications, highlighting industries where RTOS is essential for maintaining precision and reliability in critical systems.

Before diving into FreeRTOS, it’s crucial to prepare your development environment and set up debugging capabilities. We will guide you step-by-step through this process, ensuring that your system is ready for efficient development. Special emphasis will be placed on configuring FreeRTOS correctly and avoiding common pitfalls during the setup phase.

Tasks are the building blocks of any RTOS application. In this module, you will gain a deep understanding of what tasks are, how they are created, and how FreeRTOS manages their execution. We will cover the importance of task prioritization and demonstrate the process of task switching. Through hands-on examples, you’ll learn how to implement multitasking efficiently.

Communication between tasks is vital for a well-functioning RTOS application, and queues provide a powerful mechanism for this purpose. In this section, you’ll learn how to create queues in FreeRTOS, use them to pass data between tasks, and manage common patterns like producer-consumer systems.

Timers are essential for tasks that need to run at specific intervals or after a delay. In this module, we will explore the use of FreeRTOS software timers and explain how to set them up for periodic and one-shot operations. Practical examples will illustrate how timers enhance the functionality and precision of your application.

In this module, you will learn how to integrate interrupts with tasks in FreeRTOS through practical examples. We will explore the use of binary semaphores to unblock tasks when interrupts occur, counting semaphores to handle multiple interrupt events, and queues to pass messages from interrupts to tasks, such as controlling an LED’s status. These techniques provide a solid foundation for building responsive and efficient embedded systems.

Synchronization is key to preventing race conditions and ensuring data integrity in multitasking environments. This module focuses on mutexes (mutual exclusions), which are used to protect shared resources. You will learn how to implement mutexes in FreeRTOS, understand priority inheritance to resolve potential deadlocks, and explore real-world scenarios where mutexes are essential.

Direct-to-Task Notifications offer a lightweight and efficient alternative to queues for inter-task communication. In this section, you’ll learn how to send and receive notifications directly between tasks. We’ll discuss scenarios where this feature outperforms traditional communication mechanisms, providing examples that highlight its simplicity and effectiveness in enhancing system performance.

Stream and message buffers offer flexible ways to manage data exchange in FreeRTOS. You will explore how these buffers work, their advantages, and how to implement them. Practical examples will demonstrate their utility in complex applications, and we’ll discuss strategies to optimize buffer size and performance.

Understanding the internals of the FreeRTOS kernel is crucial for advanced users. This section delves into how the kernel manages scheduling, memory, and synchronization. We’ll use tools and techniques to analyze the kernel’s behavior, providing insights into debugging and optimizing your system. By the end, you will have a clearer understanding of what happens behind the scenes in FreeRTOS.

The final project is designed to consolidate everything you’ve learned during the course. You will develop a complete application using FreeRTOS, integrating tasks, queues, timers, and synchronization mechanisms. This project will not only solidify your understanding but also provide a practical demonstration of your skills, preparing you to tackle real-world challenges confidently.

Acquire the professional skill to read complex AUTOSAR and microcontroller documentation, translating technical requirements into precise configurations inside Elektrobit Tresos.

AUTOSAR handles a specification for utilizing any general-purpose timer for time periods, and it’s essential to know how to configure them. We will review the concept of interrupts and how to use them in AUTOSAR, as well as incorporate them with notifications in the GPT driver.

Accelerate your debugging workflow by mastering the Development Error Tracer (DET) module, utilizing a custom pseudo-printf to pinpoint and trace configuration errors instantly.

You will get the full potential of the Analog-to-Digital Converter (ADC), which is one of the industry’s most critical peripherals, by managing real hardware data channels and group configurations mapped to physical board potentiometers.

SPI and PWM are straightforward on bare metal, but AUTOSAR completely redefines them. This week is dedicated to breaking down and mastering high-level concepts required by Tier-1 automotive companies.

You will gain concrete, hands-on experience handling complex data structures such as Jobs, Sequences, and Channels inside the standard SPI stack.

Get into the absolute heart of automotive networking. You will configure the low-level CANDrv and its corresponding CANTrcv from scratch, reviewing the entire production-grade CAN stack.

You will master production-critical concepts, including time quanta, identifier filtering, frame parsing, and data formats (.dbc), alongside essential AUTOSAR network layers like SDU, PDU, and Hardware Object Handlers.

You will design, develop, and integrate a comprehensive parallel software project from scratch, forcing all configured MCAL peripherals to execute and communicate simultaneously on the target hardware.

In this module, we will focus on the options provided by Linux for configuring and compiling the kernel.
By the end, students will be able to replace the kernel of the original distribution with one they have generated, specific to the hardware they will be working with.

By the end of the week, you’ll be interacting with real hardware via GPIOs, learning exactly how Kconfig, DeviceTree, and overlay files bridge the gap between hardware description and software execution.

The module will emphasize two main points:

• Kbuild, the build system (based on Make) used by Linux.
• Cross-platform compilation, distinguishing between build, host, and target platforms.

This module is similar to the previous one, but focuses on the bootloader rather than the kernel.
By the end, students will be able to replace the kernel of the original distribution with one they have generated, specific to the hardware they will be working with.

Upon completion, students will be able to configure and compile a bootloader, which can serve as a substitute for the one included in the original distribution.

Given the variety of options available in this area, we will focus on U-Boot.

This module will provide an introduction to drivers in the context of Linux, covering the differences among character, block, and network drivers, as well as the unified interface exposed by the kernel through device nodes.

Students will write two drivers:

• As an introduction, a character driver similar to the ‘echo’ program.
• To conclude, a driver that enables interaction with a 2×16 character alphanumeric LCD.
• Throughout the module, students will become familiar with the interface provided by the kernel for writing drivers.

In this module, the concept of device trees will be introduced, highlighting the issues they resolve in the context of various embedded systems.

The “Open Firmware Device Tree,” also known as Devicetree (DT), represents a data structure and language used to describe hardware.

It serves as a hardware description readable by an operating system, eliminating the need for the OS to hardcode machine details.

Participants will have the opportunity to write device trees for use with the driver created in the previous module for the alphanumeric LCD, making use of this interface.

To achieve the initial goal of replacing all components of the original distribution, this module will provide information about the root filesystem and its role within a Linux-based system.

Students will be able to utilize Buildroot to generate a root filesystem comprising a set of programs tailored to the system’s requirements.

In this module, we will delve into the role of the C library as a “gateway” to the kernel interface.

Some of the topics to be discussed include:

• Various implementation options for the C library.
• System calls are the interface exposed by the kernel to user-space programs.
• Differentiation between freestanding and hosted in the context of a user-space program

Participants will conclude by writing a program that interacts directly with the kernel without using the C library.