Differences

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

--- en:safeav:softsys:softstacks [2026/04/01 10:35] – airi
+++ en:safeav:softsys:softstacks [2026/04/01 11:30] (current) – airi
@@ Line 37: / Line 37: @@
 ===== 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. |

en/safeav/softsys/softstacks.txt · Last modified: 2026/04/01 11:30 by airi