• Basic programming experience, including control structures, data types, and function-level modularity;

• General computer science foundations, such as algorithms, memory models, and execution flow;

• Introductory knowledge of computer architecture, including concepts like CPU, RAM, I/O devices, and instruction cycles.

The course offers a technical and vertically structured path through software architectures for space systems, starting from the foundational principles of modern operating systems and progressing toward real-time frameworks and robotics middleware for autonomous missions.

The introductory modules provide the theoretical background needed to understand:

• The role of an operating system as an abstraction layer between hardware and software, including its responsibilities in managing concurrency, protection, resource efficiency, and process isolation;

• The life cycle and internal states of processes and threads, along with inter-process communication and synchronization mechanisms (e.g., pipes, semaphores, message queues, and shared memory);

• Memory management techniques, such as static/dynamic allocation, segmentation, paging, virtual memory abstraction, and page replacement strategies.

To support the development of embedded and real-time software, the course includes dedicated modules on:

• Modern C++ programming, with a focus on object-oriented design patterns applicable to low-level, timing-sensitive applications;

• Build systems using CMake, covering modular compilation, dependency handling, and cross-compilation for embedded targets;

• Low-level debugging with GDB, teaching how to analyze execution flow, inspect memory/registers, and trace faults in complex embedded systems.

Building on these core skills, the course focuses on:

• POSIX-compliant real-time operating systems (RTOSs), such as NuttX, used in aerospace and satellite-grade systems;

• Flight control frameworks like PX4 and NASA Core Flight System (cFS), exploring modules for state estimation, navigation, control loops, and telemetry;

• ROS 2 middleware, enabling distributed robotic architectures, real-time data flow, and integration with simulators like Gazebo and jMAVSim for software-in-the-loop (SITL) testing.

Students will analyze open-source software stacks and implement practical configurations to gain hands-on experience with the design constraints, toolchains, and architectural trade-offs typical of aerospace-grade embedded systems.

• Gain the ability to analyze and architect real-time operating system (RTOS) components, with a focus on task scheduling strategies, interrupt service routines, inter-process communication (IPC), and synchronization mechanisms in mission-critical contexts.

• Acquire a deep understanding of operating system internals, including process lifecycle management, memory organization techniques, protection models, execution environments, and software abstractions tailored to embedded domains.

• Learn how to structure and develop modular C++ applications for embedded platforms, employing object-oriented paradigms optimized for predictable timing behavior and constrained computational resources.

• Become familiar with the design principles and configuration workflows of PX4 and NASA cFS, emphasizing control flow management, navigation subsystems, actuator coordination, and telemetry integration for autonomous aerial systems.

• Explore the architectural patterns behind ROS 2 as a distributed middleware, mastering the use of publish/subscribe communication, service endpoints, asynchronous actions, and launch systems for robotic mission coordination.

• Develop proficiency in setting up and operating advanced build and debugging toolchains, including CMake, GCC, GDB, and Git, to enable robust cross-compilation, stepwise debugging, and reproducible development workflows.

The course combines:

• Lectures with a technical focus, supported by architectural diagrams, source code analysis, and system-level breakdowns;

• Hands-on programming sessions, including software-in-the-loop simulations with PX4, ROS 2, and Gazebo;

• Code inspection and configuration analysis based on real projects (e.g., PX4 modules like commander, navigator, uORB);

• Structured delivery of materials via Microsoft Teams, organized by module and linked to official documentation and example repositories.

Assessment consists of a written exam structured into:

• Open-ended questions to assess design and system-level reasoning;

• True/false with justification, focused on deep understanding of real-time behavior, OS mechanisms, and middleware architecture.

Lecture Slides

Technical Documentation and Textbooks

• R. H. Arpaci-Dusseau – Operating Systems: Three Easy Pieces

• A. Silberschatz, P. Galvin – Operating System Concepts, Wiley

• PX4 Developer Guide – https://docs.px4.io/

• NASA Core Flight System – https://cfs.gsfc.nasa.gov/

• ROS 2 Official Docs – https://docs.ros.org/en/rolling/