Differences

This shows you the differences between two versions of the page.

--- en:safeav:softsys:softstacks [2025/06/05 15:08] – pczekalski
+++ en:safeav:softsys:softstacks [2026/04/24 09:47] (current) – raivo.sell
@@ Line 1: / Line 1: @@
 ====== Autonomy Software Stacks ======
-{{:en:iot-open:czapka_b.png?50| Bachelors (1st level) classification icon }}
-<todo @karlisberkolds></todo>
+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>

en/safeav/softsys/softstacks.1749125336.txt.gz · Last modified: 2025/06/05 15:08 by pczekalski