====== Autonomy Software Stacks ======
{{:en:iot-open:czapka_b.png?50| Bachelors (1st level) classification icon }}

Modern autonomous systems — from self-driving cars and unmanned aerial vehicles (UAVs) to marine robots and industrial co-bots — depend fundamentally on software architectures capable of real-time sensing, decision-making, and control. While mechanical and electronic components define what a system can do, the software stack defines how it does it — how it perceives the world, interprets data, plans actions, and interacts safely with its environment [66,67]. Autonomy software differs from conventional embedded or enterprise software in several critical ways:

  * It operates under strict real-time constraints.
  * It must integrate data from heterogeneous sensors.
  * It must support fault tolerance and safety compliance.
  * It supports continuous learning and adaptation through AI.
  * It interacts with physical systems, connected networks, edge devices, and cloud services.

This combination of safety-critical engineering and AI-driven decision-making makes autonomy software one of the most challenging areas in modern computing.

===== Core Functional Requirements of Autonomy Software =====

Autonomy software must achieve four key functional objectives [68,69]:

  * **Perception:** sensing and interpreting the environment (via LiDAR, radar, cameras, sonar, etc.).
  * **Localization:** estimating the system’s precise position and orientation in the world.
  * **Planning:** generating paths or behaviors that fulfill mission goals while avoiding obstacles.
  * **Control:** executing actions safely and stably, compensating for environmental changes.

Each of these objectives corresponds to distinct software layers and modules in the autonomy stack.

===== Software Characteristics Unique to Autonomy =====

^ Characteristic ^ Description ^ Importance ^
| Real-time Execution | Must process sensor data and react within milliseconds. | Ensures safety and stability. |
| Determinism | Predictable behaviour under defined conditions. | Required for validation and trust. |
| Scalability | Supports increased sensor data and compute complexity. | Allows future upgrades. |
| Interoperability | Integrates diverse hardware, OS, and middleware. | Facilitates modularity. |
| Resilience | Must continue functioning despite partial failures. | Critical for mission continuity. |
| Adaptability | Learns from data or updates behaviour dynamically. | Key for AI-driven autonomy. |

These characteristics drive architectural decisions and the choice of frameworks (e.g., ROS, AUTOSAR Adaptive, DDS).

===== Autonomy Software as a Multi-Layered System =====

Autonomy software is layered, combining multiple software technologies:

  * **Low-level embedded firmware** (real-time control and drivers).
  * **Middleware and communication frameworks** (data exchange and scheduling).
  * **High-level AI algorithms** (perception, decision-making).
  * **Supervisory or cloud-level systems** (fleet management, updates, data analytics).

The combination of these layers forms the autonomy software stack, which enables complex behaviour while maintaining reliability. A defining aspect of autonomy software is its reliance on middleware — frameworks that manage interprocess communication (IPC), data distribution, and time synchronisation across distributed computing nodes. Some of the widely used standards:

  * ROS / ROS 2 (Robot Operating System): Modular publish-subscribe communication.
  * DDS (Data Distribution Service): Real-time, QoS-based messaging standard.
  * MQTT / ZeroMQ: Lightweight protocols for cloud and IoT integration.

A complete software stack is a layered collection of software components, frameworks, and libraries that work together to deliver a complete set of system functionalities. Each layer provides services to the layer above it and depends on the layer below it. Middleware, which is an essential part of the multi-layered architectures, ensures that all layers of the software stack can exchange information deterministically and safely [70]. In autonomous systems, the software stack enables integration between:

  * Hardware abstraction (sensors, actuators, compute units).
  * Middleware (communication and data exchange).
  * Application-level modules (AI perception, planning, control).
  * System management (diagnostics, simulation, fleet updates).

It’s the backbone that allows autonomy to function as a cohesive system rather than a set of disconnected modules (Quigley et al., 2009; Maruyama et al., 2016). From a technical perspective, the software stack defines how functionality, data flow, and control are structured within the system.

**Modularity and Abstraction**

Each layer isolates complexity by providing a clean interface to the one above.

  * Developers can modify one layer (e.g., perception algorithms) without altering lower layers (e.g., drivers).
  * Enables easier testing, debugging, and reuse across multiple vehicles or applications.

**Real-Time and Deterministic Behaviour**

Autonomous systems rely on real-time responses. The stack architecture ensures:

  * Timely communication between perception, planning, and control.
  * Deterministic scheduling using RTOS kernels or real-time Linux patches [71].
  * Synchronisation of data streams from multiple sensors using timestamping and time-sensitive networking (TSN).

**Interoperability**

Middleware such as ROS 2 or DDS standardises interprocess communication. This allows different vendors’ software modules (e.g., LiDAR driver from Company A and planner from Company B) to work together.

**Fault Tolerance and Redundancy**

Stack layering supports redundant paths for safety-critical functions. If a perception node fails, a backup process may take over seamlessly — ensuring resilience, especially in aerospace and automotive systems [72].

**Continuous Integration and Simulation**

A layered design allows developers to:

  * Integrate software components progressively.
  * Test them using Hardware-in-the-Loop (HIL) and Software-in-the-Loop (SIL) methods.
  * Use simulators (e.g., CARLA, Gazebo, AirSim) to validate upper-layer modules without risking hardware damage.

**Management and Organisational Importance**

From a software engineering management perspective, a defined software stack provides structure and governance for the development process, which provides the following main advantages: Division of Labour. Teams can specialise by layer — e.g., one group handles perception, another control, another middleware. This parallelises development and allows use of domain expertise without interference.
 
**Reusability and Version Control** Reusable modules and APIs speed up development. Tools like Git, Docker, and CI/CD pipelines ensure traceability, maintainability, and fast updates across distributed teams.

**Scalability and Lifecycle Management** A well-structured stack can be extended with new sensors or algorithms without re-architecting the entire system. Lifecycle management tools (e.g., ROS 2 launch systems, AUTOSAR Adaptive manifests) maintain version consistency and dependency control.

**Quality Assurance (QA) and Certification** Layered software stacks make it easier to apply quality control and compliance frameworks, such as: ISO 26262 (Automotive safety software), DO-178C (Aerospace software) or IEC 61508 (Functional safety in automation). Each layer can be validated separately, simplifying documentation and certification workflows.

**Cost and Risk Reduction** When multiple projects share a unified software stack, the cost of testing, validation, and maintenance drops significantly. This approach underpins industry-wide initiatives like AUTOSAR, which standardises vehicle software to lower integration costs.

**The Layered Stack as an Organisational Blueprint**

In large autonomy projects (e.g., Waymo, Tesla), the software stack also serves as an organisational structure. Teams are aligned with layers:

  * Perception team handles sensor fusion and computer vision.
  * Planning & Control team develops behavioural logic and trajectory generation.
  * Systems team manages middleware and data distribution.
  * Infrastructure team maintains OS builds, simulation, and DevOps pipelines.

Thus, the software stack doubles as both a technical architecture and an organisational map for coordination and accountability [73].

**Real-World Example: ROS 2 as a Layered Stack**

The Robot Operating System 2 (ROS 2) exemplifies how modular software stacks are implemented:

  * Application Layer: Navigation, mapping, perception nodes.
  * Middleware Layer: DDS for data exchange, QoS configuration.
  * OS Layer: Linux or RTOS with POSIX APIs.
  * Hardware Abstraction: Drivers for cameras, IMUs, LiDARs.
  * Build & Deployment Layer: CMake, Colcon, Docker for reproducibility.

This layered model has become the foundation for numerous autonomous systems in academia and industry
— from mobile robots to autonomous vehicles [74]).

**Advantages of a Well-Defined Software Stack**

^ Advantage ^ Description ^
| Clarity and Structure | Simplifies system understanding and onboarding. |
| Parallel Development | Enables multiple teams to work concurrently. |
| Interchangeability | Supports component replacement without total redesign. |
| Scalability | Allows future expansion with minimal rework. |
| Maintainability | Facilitates debugging, upgrades, and certification. |
| Efficiency | Reduces cost, redundancy, and integration risk. |

In essence, a software stack is not merely a technical artefact — it’s a strategic enabler that aligns engineering processes, organisational structure, and long-term sustainability of autonomous platforms. Autonomy software stack and Development and Maintenance challenges are discussed in the following chapters.


<WRAP excludefrompdf>
  * [[en:safeav:softsys:autonomysoftstack]]
  * [[en:safeav:softsys:developmentchalenges]]
</WRAP>