Differences

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

--- en:safeav:softsys:softstacks [2026/04/06 11:38] – airi
+++ 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 }}
 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:
@@ Line 136: / Line 135: @@
 | Efficiency | Reduces cost, redundancy, and integration risk. |
-====== Software Lifecycle and Typical Lifecycle Models ======
+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.
-The software lifecycle defines the complete process by which software is conceived, developed, deployed, maintained, and eventually retired. In the context of modern engineering — particularly for complex systems such as autonomous platforms, embedded systems, or enterprise solutions — understanding the lifecycle is essential to ensure quality, reliability, and maintainability. The lifecycle acts as a roadmap that guides project teams through stages of development and management. Each stage defines specific deliverables, milestones, and feedback loops, ensuring that the software evolves in a controlled, traceable, and predictable way [92].
-**Definition**
-“The software lifecycle refers to a structured sequence of processes and activities required to develop, maintain, and retire a software system.” — [93] In other words, the lifecycle describes how a software product transitions from idea to obsolescence — incorporating all the engineering, management, and maintenance steps along the way. The lifecycle ensures:
-* **Consistency:** A common framework for teams and stakeholders.
-  * **Quality assurance:** Enables verification and validation at each stage.
-  * **Traceability:** Establishes clear relationships between requirements, design, code, and tests.
-  * **Risk management:** Provides checkpoints to detect and correct issues early.
-  * **Scalability:** Supports integration of multiple teams, technologies, and versions.
-In regulated domains like aerospace, automotive, and medical devices, adherence to a defined lifecycle is also a legal requirement for certification and compliance (e.g., ISO/IEC 12207, DO-178C, ISO 26262).
-The main lifecycle models, Configuration management and configuration management tools are discussed in the following chapters:
-===== Typical Software Lifecycle Models =====
-Different industries and projects adopt specific lifecycle models based on their goals, risk tolerance, and team structure. The most widely used models are explained in this chapter.
-**The Waterfall Model**
-The Waterfall Model is one of the earliest and most widely recognised software lifecycle models. It follows a linear sequence of stages where each phase must be completed before the next begins [94].
-{{:en:safeav:softsys:figure4b.jpg?600|}}
-Advantages:
-====== Software architectures ======
-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 ((Thrun, S. (2010). Toward robotic cars. Communications of the ACM, 53(4), 99–106))((Lee, E. A., & Seshia, S. A. (2020). Introduction to Embedded Systems: A Cyber-Physical Systems Approach (3rd ed.). MIT Press.)). 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 needs robust fault tolerance and safety compliance.
-  * It supports continuous learning and adaptation through AI.
-  * It often spans distributed systems, connecting vehicles, edge servers, 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 ((Russell, S. J., & Norvig, P. (2021). Artificial Intelligence: A Modern Approach (4th ed.). Pearson))((Brooks, R. A. (1991). Intelligence without representation. Artificial Intelligence, 47(1–3), 139–159.)):
-  * **Perception** – sensing and interpreting the environment (via LiDAR, radar, cameras, sonar, etc.).
-  * **Localisation** – estimating the system’s precise position and orientation in the world.
-  * **Planning** – generating paths or behaviours that fulfil 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. | Enables certification and trust. |
-| Scalability | Supports increased sensor data and compute complexity. | Allows future upgrades. |
-| Interoperability | Integrates diverse hardware, OSs, and middleware. | Facilitates reusability. |
-| Resilience | Must continue functioning despite partial failures. | Critical for mission continuity. |
-| Adaptivity | 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).
-===== 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 ((Object Management Group. (2023). Data Distribution Service (DDS) Standard. OMG)). 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), and
-  * 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 ((Baruah, S., Baker, T. P., & Burns, A. (2012). Real-time scheduling theory: A historical perspective. Real-Time Systems, 28(2–3), 101–155)).
-  * 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 ((AUTOSAR Consortium. (2023). AUTOSAR Adaptive Platform Specification. AUTOSAR.)).
-==== 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 ((Fowler, M. (2021). Patterns of Enterprise Software Architecture. Addison-Wesley.)).
-==== 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 ((Maruyama, Y., Kato, S., & Azumi, T. (2016). Exploring the performance of ROS 2. Proceedings of the 13th Embedded Real-Time Systems Workshop (ERTS 2016))).
-==== 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/softstacks.1775464698.txt.gz · Last modified: 2026/04/06 11:38 by airi