From 6c9cb2da4a8590f2f5f8c6e8ccd4ef56a0a3fa7b Mon Sep 17 00:00:00 2001 From: Jason Andrews Date: Wed, 16 Apr 2025 13:46:24 -0500 Subject: [PATCH] Review Open AD Kit Learning Path --- .../openadkit1_container/1_sdv_soafee.md | 16 ++-- .../2_automotive_softwares.md | 33 ++++---- .../openadkit1_container/3_setup_openadkit.md | 34 ++++---- .../openadkit1_container/4_run_openadkit.md | 83 ++++++++++--------- .../automotive/openadkit1_container/_index.md | 36 ++++---- 5 files changed, 109 insertions(+), 93 deletions(-) diff --git a/content/learning-paths/automotive/openadkit1_container/1_sdv_soafee.md b/content/learning-paths/automotive/openadkit1_container/1_sdv_soafee.md index d375374966..43ed12c1ac 100644 --- a/content/learning-paths/automotive/openadkit1_container/1_sdv_soafee.md +++ b/content/learning-paths/automotive/openadkit1_container/1_sdv_soafee.md @@ -1,5 +1,5 @@ --- -title: Software-Defined Vehicle (SDV) and SOAFEE +title: About Software-Defined Vehicles and SOAFEE weight: 2 ### FIXED, DO NOT MODIFY @@ -8,17 +8,17 @@ layout: learningpathall ## Introduction to Software-Defined Vehicles -In recent years, the automotive industry has been undergoing a transformation driven by software, with the concept of the Software-Defined Vehicle (SDV) emerging as a key paradigm for the future of intelligent cars. As the number of Electronic Control Units (ECUs) increases and vehicle systems become more complex, the traditional hardware-driven development approach is no longer sufficient. To improve development efficiency and product quality, automotive software development is shifting toward a Shift-Left approach, accelerating validation and deployment processes. +In recent years, the automotive industry has been undergoing a transformation driven by software, with the concept of the Software-Defined Vehicle (SDV) emerging as a key paradigm for the future of intelligent cars. As the number of Electronic Control Units (ECUs) increases and vehicle systems become more complex, the traditional hardware-driven development approach is no longer sufficient. To improve development efficiency and product quality, automotive software development is moving to a Shift-Left approach, accelerating validation and deployment processes. -## The Evolution of Software-Defined Vehicles +## The evolution of Software-Defined Vehicles The core idea of SDV is to make software the primary differentiating factor of a vehicle, enabling continuous feature updates via Over-The-Air (OTA) technology. This approach allows manufacturers to shorten development cycles while continuously improving safety and performance after a vehicle is released. Moreover, SDV promotes the adoption of Service-Oriented Architecture (SOA), enabling modular and scalable software that integrates seamlessly with cloud services. However, this transition introduces new challenges, particularly in software development and validation. The traditional V-model development process struggles to meet SDV demands since defects are often detected late in development, leading to costly fixes. As a result, Shift-Left has become a crucial strategy to address these challenges. -One useful Arm Automotive [landing page](https://www.arm.com/markets/automotive/software-defined-vehicles) that you can read. +You can read more about [Software Defined Vehicles](https://www.arm.com/markets/automotive/software-defined-vehicles). -## Shift-Left: Detecting Issues Early to Enhance Development Efficiency +## Shift-Left: detecting issues early to enhance development efficiency Shift-Left refers to moving testing, validation, and security assessments earlier in the development process to reduce costs and improve reliability. In the SDV context, this means incorporating software architecture design, virtual testing, and automated validation in the early stages to ensure the final product meets safety and performance requirements. @@ -32,9 +32,9 @@ The key benefits of Shift-Left include: However, Shift-Left requires appropriate tools and frameworks to support its implementation; otherwise, it can increase testing complexity. This is where SOAFEE (Scalable Open Architecture for Embedded Edge) plays a critical role. -Check this [blog](https://newsroom.arm.com/blog/automotive-virtual-platforms) understand how to use virtual platforms enable the automotive industry to accelerate the silicon and software development process through virtual prototyping. +Read [Virtual Platforms from Arm and Partners Available Now to Accelerate and Transform Automotive Development](https://newsroom.arm.com/blog/automotive-virtual-platforms) to understand how virtual platforms enable the automotive industry to accelerate the silicon and software development process through virtual prototyping. -## SOAFEE: A Standardized Solution for SDV Development +## SOAFEE: a standardized solution for SDV development SOAFEE, an open architecture initiative led by Arm and industry partners, aims to provide a unified framework for software-defined vehicles. It leverages cloud-native technologies and is optimized for embedded environments, enabling developers to adopt modern DevOps workflows to accelerate software development. @@ -52,6 +52,6 @@ As the Software-Defined Vehicle paradigm gains traction, the automotive industry With the adoption of SOAFEE, automotive software development will become more standardized and efficient, enabling companies to realize the vision of SDVs faster while delivering a safer, smarter, and more flexible vehicle experience. -Visit [SOAFEE](https://www.soafee.io/) website to find more detail. +Visit the [SOAFEE](https://www.soafee.io/) website to learn more. In the following sections, you will explore a Shift-Left demonstration example that leverages SOAFEE to enable early deployment of autonomous driving software before the hardware is ready. diff --git a/content/learning-paths/automotive/openadkit1_container/2_automotive_softwares.md b/content/learning-paths/automotive/openadkit1_container/2_automotive_softwares.md index a9fa5775f6..a133f31592 100644 --- a/content/learning-paths/automotive/openadkit1_container/2_automotive_softwares.md +++ b/content/learning-paths/automotive/openadkit1_container/2_automotive_softwares.md @@ -1,14 +1,14 @@ --- -title: Essential Automotive Software Technologies +title: Essential automotive software technologies weight: 3 ### FIXED, DO NOT MODIFY layout: learningpathall --- -Before diving into the Deep Dive section of this learning path, I would like to first introduce a few essential software technologies that you need to understand. +Before getting into technical details, there are two essential technologies used in automotive software that you need to understand, ROS 2 and Open AD Kit. -## Robot Operating System 2 (ROS 2) +## What is Robot Operating System 2 (ROS 2)? Robot Operating System 2 (ROS 2) is an open-source robotics middleware designed to provide a flexible, scalable, and real-time capable framework for robot development. It builds upon the foundations of ROS 1, addressing limitations in distributed computing, security, and multi-robot collaboration. ROS 2 is widely used in autonomous systems, industrial automation, and research applications. @@ -27,28 +27,31 @@ Applications of ROS 2: - ROS 2 is used in autonomous vehicles, robotic arms, drones, and medical robots. It supports simulation tools like Gazebo and integrates with AI frameworks for advanced robotics applications. -- ROS 2’s enhanced performance and flexibility make it a crucial enabler for the future of robotics, providing developers with a powerful platform for building intelligent, autonomous systems. +- ROS 2's enhanced performance and flexibility make it a crucial enabler for the future of robotics, providing developers with a powerful platform for building intelligent, autonomous systems. -Arm’s computing platform fully supports ROS 2 operations. You can use this [link](/install-guides/ros2/) to learn how to install it on an Arm-based machine. +Arm's computing platform fully supports ROS 2 operations. You can use the [ROS install guide](/install-guides/ros2/) to install it on an Arm-based machine. -## Autoware Open AD Kit +## Connecting ROS 2 and Automotive Applications -The [Open AD Kit](https://autoware.org/open-ad-kit/), the first SOAFEE blueprint, is a collaborative initiative within the [Autoware](https://autoware.org/) and SOAFEE ecosystems. Developed with contributions from Autoware Foundation members and alliance partners, its goal is to enable Autoware as a fully software-defined platform. +ROS 2 serves as the foundation for many modern automotive software platforms, particularly in autonomous driving applications. Its real-time capabilities, distributed architecture, and robust communication framework make it ideal for processing sensor data, implementing decision-making algorithms, and controlling vehicle systems. This is where Open AD Kit comes into play - it leverages ROS 2's capabilities to create a comprehensive autonomous driving platform that bridges the gap between robotics middleware and automotive-specific requirements. Together, these technologies enable developers to build sophisticated autonomous driving systems with standardized interfaces, scalable architectures, and the flexibility to deploy across various hardware configurations. -The Autoware Foundation hosts Autoware, the world’s leading open-source autonomous driving project. +## What is Autoware Open AD Kit? + +[Open AD Kit](https://autoware.org/open-ad-kit/), the first SOAFEE blueprint, is a collaborative initiative within the [Autoware](https://autoware.org/) and SOAFEE ecosystems. Developed with contributions from Autoware Foundation members and alliance partners, its goal is to enable Autoware as a fully software-defined platform. + +The Autoware Foundation hosts Autoware, the world's leading open-source autonomous driving project. Autoware, built on ROS, features a modular AD stack with well-defined interfaces and APIs for perception, localization, planning, and control. It supports diverse sensors and hardware, enabling adaptability across vehicle types and applications, from research to commercial deployment. Committed to democratizing AD technology, Autoware fosters collaboration among industry, researchers, and developers. By promoting open standards and innovation, the foundation accelerates autonomous driving adoption while ensuring safety, scalability, and real-world usability, driving the future of autonomous mobility through open-source development and ecosystem synergy. The Open AD Kit Blueprint has evolved through multiple iterations of containerized Autoware software. It supports both cloud and edge deployments in physical and virtual environments, with OTA updates enabling seamless software upgrades. -The Open AD Kit project continues to be developed at the Open AD Kit working group, and the following are the main goals and principles of the collaborative project: -• Introducing modern cloud-native development and deployment methodologies for the Autoware use -• Introducing mixed-critical orchestration, paving the way for safety and certifiability -• Enabling validation using virtual prototyping platforms to achieve shift-left paradigms -• Providing a consistent production environment to deploy Autoware using hardware abstraction technologies to enable hardware-agnostic solutions +The Open AD Kit project continues to be developed by the Open AD Kit working group, and the following are the main goals and principles of the collaborative project: +- Introducing modern cloud-native development and deployment methodologies for the Autoware use +- Introducing mixed-critical orchestration, paving the way for safety and certifiability +- Enabling validation using virtual prototyping platforms to achieve shift-left paradigms +- Providing a consistent production environment to deploy Autoware using hardware abstraction technologies to enable hardware-agnostic solutions The Open AD Kit Blueprint has been widely adopted by many ecosystem players to develop their own custom-flavored implementations. The blueprint provides a practical and demonstrable example of building SDV applications, particularly in the autonomous driving domain. Additionally, it serves as a model for creating SOAFEE blueprints, fostering a dynamic ecosystem around them. -In the following sessions, you will learn how to use the OpenAD Kit autonomous driving simulation environment to run SOAFEE within container and facilitate communication through ROS 2. - +In the following sections, you will learn how to use the Open AD Kit autonomous driving simulation environment to run SOAFEE within a container and facilitate communication through ROS 2. diff --git a/content/learning-paths/automotive/openadkit1_container/3_setup_openadkit.md b/content/learning-paths/automotive/openadkit1_container/3_setup_openadkit.md index d4c6997760..df396181c4 100644 --- a/content/learning-paths/automotive/openadkit1_container/3_setup_openadkit.md +++ b/content/learning-paths/automotive/openadkit1_container/3_setup_openadkit.md @@ -1,24 +1,23 @@ --- -title: Setup OpenAD Kit +title: Set up Open AD Kit weight: 4 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## Execute Autoware Open AD Kit on Arm platform +## Execute Autoware Open AD Kit on an Arm Neoverse platform -Leveraging the high-performance computing power of Arm Neoverse CPUs and its comprehensive software ecosystem, you can run automotive software simulations on any Neoverse computing platforms. +Leveraging the high-performance computing power of Arm Neoverse CPUs and their comprehensive software ecosystem, you can run automotive software simulations on any Neoverse computing platforms. -This learning path can be seamlessly deployed in two type of development environments: Arm Cloud Instances and On-Premise servers. -This example has been tested on [AWS EC2](https://aws.amazon.com/ec2/) and [Ampere Altra workstation](https://www.ipi.wiki/products/ampere-altra-developer-platform), allowing you to choose the most suitable setup based on your needs. +You can use either an Arm Cloud Instance or on-premise servers to run Open AD Kit. +The example has been tested on [AWS EC2](https://aws.amazon.com/ec2/) and an [Ampere Altra workstation](https://www.ipi.wiki/products/ampere-altra-developer-platform), allowing you to choose the most suitable setup based on your needs. ## Installation -This learning path requires Docker to run OpenAD Kit. -You can refer to [here](https://learn.arm.com/install-guides/docker/) to learn how to install Docker on an Arm platform. +You need Docker to run Open AD Kit. Refer to the [Docker install guide](https://learn.arm.com/install-guides/docker/) to learn how to install Docker on an Arm platform. -First, verify whether Docker is installed on your development environment by running: +First, verify Docker is installed on your development computer by running: ```bash docker --version @@ -27,7 +26,7 @@ docker --version If Docker is installed, it will display version information similar to the output below: ```output -Docker version 27.2.0, build 3ab4256 +Docker version 28.0.4, build b8034c0 ``` Clone the demo repository using: @@ -36,8 +35,7 @@ Clone the demo repository using: git clone https://github.com/autowarefoundation/openadkit_demo.autoware.git ``` -The project is containerized within three Docker images, so you do not need to install additional software. - +The project is containerized in three Docker images, so you do not need to install any additional software. ## Understanding the Open AD Kit Demo Packages @@ -51,15 +49,15 @@ The Key Functions of Simulator are: - Simulates autonomous driving environments - Generates sensor data (LiDAR, cameras, radar, IMU) -- Publishes vehicle state information (position, speed, heading) via ROS 2 topics for other components to process. +- Publishes vehicle state information (position, speed, heading) via ROS 2 topics for other components to process - Feeds data to planning-control for trajectory planning - Acts as a data source for visualizer to render the simulation -Interaction with Other Components +Interaction with Other Components: - Provides vehicle states and sensor data to planning-control - Acts as the primary data source for visualizer -It is an example to starts a new Docker container named `simulator`, ensuring it runs in interactive mode with a terminal and is automatically removed upon stopping, while using a predefined Docker image pulled from the GitHub Container Registry. +The command below starts a new Docker container named `simulator`, ensuring it runs in interactive mode with a terminal and is automatically removed upon stopping, while using a predefined Docker image pulled from the GitHub Container Registry. ```bash docker run --name simulator --rm -it ghcr.io/autowarefoundation/demo-packages:simulator @@ -72,10 +70,10 @@ The planning-control module is responsible for path planning and vehicle control The Key Functions of Planning-Control: - Receives sensor data and map information from simulator - Computes motion planning and generates optimal trajectories -- Generates control commands (steering, acceleration, braking) and sends them to the simulator for execution in the virtual environment. +- Generates control commands (steering, acceleration, braking) and sends them to the simulator for execution in the virtual environment - Acts as the decision-making unit for vehicle movement -Interaction with Other Components +Interaction with Other Components: - Receives sensor inputs and vehicle states from simulator - Sends planned trajectories and control commands back to simulator - Feeds trajectory and control data to visualizer for display @@ -96,7 +94,7 @@ The Key Functions of Visualizer: - Uses RViz & VNC for rendering visual outputs - Supports remote access via Ngrok or VNC -Interaction with Other Components +Interaction with Other Components: - Receives sensor and vehicle state data from simulator - Receives planned trajectories and control commands from planning-control - Presents a visual representation of all ROS 2 topic data @@ -107,4 +105,4 @@ This command starts a new Docker container named `visualizer`, ensuring it runs docker run --name visualizer --rm -it -p 6080:6080 ghcr.io/autowarefoundation/demo-packages:visualizer ``` -After gaining a basic understanding of OpenAD Kit, the next section will guide you you through running three containers simultaneously on a single physical machine. +After gaining a basic understanding of Open AD Kit, the next section will guide you through running three containers simultaneously on a single physical machine. diff --git a/content/learning-paths/automotive/openadkit1_container/4_run_openadkit.md b/content/learning-paths/automotive/openadkit1_container/4_run_openadkit.md index b2d9eaa649..6ad1904a0f 100644 --- a/content/learning-paths/automotive/openadkit1_container/4_run_openadkit.md +++ b/content/learning-paths/automotive/openadkit1_container/4_run_openadkit.md @@ -1,21 +1,21 @@ --- -title: Open AD Kit Demo +title: Run the Open AD Kit demo weight: 5 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## Execute Autoware Open AD Kit by Docker Compose +## Execute Autoware Open AD Kit using Docker Compose -Open AD Kit leverages Docker Compose technology to integrate all container initialization and corresponding configurations, allowing you to start with all the settings from the previous session without any modifications. +Open AD Kit leverages Docker Compose to integrate all container initialization and corresponding configurations, allowing you to start with all the settings from the previous session without any modifications. -That said, we can still gain a deeper understanding of the system by examining the `docker/docker-compose.yml` file. +That said, you can still gain a deeper understanding of the system by examining the `docker/docker-compose.yml` file. -The script first starts the Visualizer service in detached mode, followed by the continuous execution of Planning & Simulation. The detailed ROS commands are defined in the docker/docker-compose.yml file. +The script first starts the Visualizer service in detached mode, followed by the continuous execution of Planning and Simulation. The detailed ROS commands are defined in the `docker/docker-compose.yml` file. -### Visualizer Configuration +### Visualizer configuration Similar to the example in the previous session, this Docker Compose service configures and runs a visualization tool (Visualizer) within a Docker container. It renders real-time simulation data using RViz and allows remote access via VNC and Ngrok. @@ -23,7 +23,7 @@ The `visualizer` service maps: - **volume `./etc/simulation:/autoware/scenario-sim`** - The volume mapping `./etc/simulation:/autoware/scenario-sim` mounts a local directory (./etc/simulation) to a specific path inside the container (/autoware/scenario-sim). This means that files stored in the ./etc/simulation directory on the host machine will be accessible from inside the container at /autoware/scenario-sim. + The volume mapping `./etc/simulation:/autoware/scenario-sim` mounts a local directory `./etc/simulation` to a specific path inside the container `/autoware/scenario-sim`. This means that files stored in `./etc/simulation` on the host machine will be accessible from inside the container at `/autoware/scenario-sim`. - **Port `6080:6080`** @@ -32,10 +32,13 @@ The `visualizer` service maps: Inside the container, VNC is enabled via the `VNC_ENABLED=true` environment variable, ensuring that the VNC server is running. The VNC server listens on port 6080, making it accessible through a web-based interface, which simplifies remote monitoring and control of autonomous driving simulations, improving development and testing efficiency. Enable VNC-based remote visualization to interact with the Autoware environment remotely. + To access the visualization interface: - On the same machine, open: `http://localhost:6080` - From another device, use: `http://:6080` +Here is the Docker Compose file: + ```yml visualizer: image: ghcr.io/autowarefoundation/demo-packages:visualizer @@ -53,22 +56,24 @@ The `visualizer` service maps: - NGROK_URL=${NGROK_URL} ``` +### Planning-Control module + +The second Docker Compose service defines the `planning-control` module within a simulation environment. The planning-control container is responsible for motion planning, trajectory generation, and vehicle control. -### Planning-Control Module -The second Docker Compose service defines the `planning-control` module within a simulation environment. The planning-control container is responsible for Motion planning, Trajectory generation, Vehicle control +One key aspect to mention is the `depends_on` directive. -One key aspect to mention is the depends_on directive. -To ensure that planning-control receives sensor data from the simulator, use depends_on to make sure the simulator service starts before planning-control begins execution. +To ensure that planning-control receives sensor data from the simulator, use `depends_on` to make sure the simulator service starts before planning-control begins execution. -ROS2 command: -The command starts the planning_simulator.launch.xml launch file, which initializes the motion planning module: -- map_path:=/autoware/scenario-sim/map → Loads the simulation map. -- vehicle_model:=sample_vehicle → Uses a predefined vehicle model for testing. -- sensor_model:=sample_sensor_kit → Loads sensor configurations for perception. -- scenario_simulation:=true → Enables scenario-based simulation. -- rviz:=false → Disables RViz visualization inside this container. -- perception/enable_traffic_light:=false → Disables traffic light recognition for this test. +The `ros2` command starts the `planning_simulator.launch.xml` launch file, which initializes the motion planning module: +- `map_path:=/autoware/scenario-sim/map` → Loads the simulation map. +- `vehicle_model:=sample_vehicle` → Uses a predefined vehicle model for testing. +- `sensor_model:=sample_sensor_kit` → Loads sensor configurations for perception. +- `scenario_simulation:=true` → Enables scenario-based simulation. +- `rviz:=false` → Disables RViz visualization inside this container. +- `perception/enable_traffic_light:=false` → Disables traffic light recognition for this test. + +Here is the Docker Compose file: ```yml planning-control: @@ -97,16 +102,17 @@ The command starts the planning_simulator.launch.xml launch file, which initiali The final Docker Compose service defines the `simulator` module. The simulator is responsible for creating a virtual driving environment, generating sensor data, and providing vehicle state information to other components such as planning-control and visualizer. -Maps local directory (./etc/simulation) to /autoware/scenario-sim inside the container. +Maps local directory `./etc/simulation` to `/autoware/scenario-sim` inside the container. + +The `ros2` command starts the `scenario_test_runner.launch.py` launch file, initializing the Autoware simulation: -ROS2 command: -The following command starts the scenario_test_runner.launch.py launch file, initializing the Autoware simulation: +- `scenario:=/autoware/scenario-sim/scenario/yield_maneuver_demo.yaml` → Specifies the scenario configuration file. +- `sensor_model:=sample_sensor_kit` → Uses a predefined sensor configuration. +- `vehicle_model:=sample_vehicle` → Uses a sample vehicle model. +- `global_frame_rate:=20` → Sets the simulation frame rate to 20 FPS. +- `launch_rviz:=false` → Prevents RViz from launching in the container. -- scenario:=/autoware/scenario-sim/scenario/yield_maneuver_demo.yaml → Specifies the scenario configuration file. -- sensor_model:=sample_sensor_kit → Uses a predefined sensor configuration. -- vehicle_model:=sample_vehicle → Uses a sample vehicle model. -- global_frame_rate:=20 → Sets the simulation frame rate to 20 FPS. -- launch_rviz:=false → Prevents RViz from launching in the container. +Here is the Docker Compose file: ```yml simulator: @@ -130,7 +136,7 @@ The following command starts the scenario_test_runner.launch.py launch file, ini launch_rviz:=false ``` -### Execute Planning Visualizer Demo +### Execute the Planning Visualizer demo To start the Planning Visualizer Demo, execute the following script: @@ -138,18 +144,19 @@ To start the Planning Visualizer Demo, execute the following script: ./docker/run.sh ``` -This Bash script sets up environment variables and orchestrates the execution of Open AD Kit's visualizer, planning-control, and simulator using the previously mentioned Docker Compose setup. The script runs in a loop, continuously testing two different planning configurations: CONF_FILE_FAIL and CONF_FILE_PASS. +This Bash script sets up environment variables and orchestrates the execution of Open AD Kit's visualizer, planning-control, and simulator using the previously mentioned Docker Compose setup. The script runs in a loop, continuously testing two different planning configurations: `CONF_FILE_FAIL` and `CONF_FILE_PASS`. + +Once the script starts successfully, you will see a similar output to the image below. -Once the script starts successfully, you will see a similar output. -You can then use your browser to monitor the simulation data in real-time. +You can use your browser to monitor the simulation data in real-time. ![img1 alt-text#center](vnc_address.png "Figure 1: Execute run.sh") -Now you can use the browser to access visualization at the above's URLs: -In this example is http://34.244.98.151:6080/vnc.html +Now you can use the browser to access visualization. +In this example the URL is http://34.244.98.151:6080/vnc.html {{% notice Note %}} -Ensure that the server allows your IP address and port 6080 to connect. +Ensure that the server allows your IP address and port 6080 to connect. You may need to adjust the security group settings if you are using a cloud instance. {{% /notice %}} To access the visualizer: @@ -159,16 +166,16 @@ To access the visualizer: 3. Enter the default VNC password: **"openadkit"**. ![img3 alt-text#center](openadkit_passwd.jpg "Figure 3: Input VNC password") -You are now entered the OpenAD Kit simulation environment. +You are now in the Open AD Kit simulation environment. -This demo will continuously repeat the two scenarios. +The demo will continuously repeat the two scenarios. - **fail_static_obstacle_avoidance.param.yaml**: In the first scenario, the vehicle remains stationary behind the obstacle. - **pass_static_obstacle_avoidance.param.yaml**: In the second scenario, the vehicle is permitted to change lanes to maneuver around the obstacle. The vehicle starts from a stationary position, moves along the road, and stops when there is a vehicle ahead, waiting for the obstruction to clear before proceeding. -After each simulation run, it will automatically restart after 90 seconds. You can use the mouse to adjust different viewing angles for observation. +After each simulation run, it automatically restarts after 90 seconds. You can use the mouse to adjust different viewing angles for observation. ![img4 alt-text#center](openadkit_1.gif "Figure 4: Simulation") -Congratulations! You have successfully executed the OpenAD Kit demo. +Congratulations! You have successfully executed the Open AD Kit demo. diff --git a/content/learning-paths/automotive/openadkit1_container/_index.md b/content/learning-paths/automotive/openadkit1_container/_index.md index 50084f404e..7f1c86c694 100644 --- a/content/learning-paths/automotive/openadkit1_container/_index.md +++ b/content/learning-paths/automotive/openadkit1_container/_index.md @@ -1,5 +1,5 @@ --- -title: Deploying Mixed-Criticality Autonomous Driving software using Arm containers +title: Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse draft: true cascade: @@ -7,16 +7,16 @@ cascade: minutes_to_complete: 60 -who_is_this_for: This is an introductory topic for automotive developers, aimed at helping them accelerate autonomous driving software development before the automotive computing hardware board is fully ready. +who_is_this_for: This is an introductory topic for automotive developers, aimed at helping them accelerate autonomous driving software development before automotive hardware is available. learning_objectives: - - Introduction to the SOAFEE architecture and its role in supporting Shift-Left software development strategies to optimize the autonomous driving development process. - - Overview of the Autoware OpenADKit simulation environment. - - Running containerized workloads on Arm Neoverse V3AE with Docker, supporting execution on both cloud-based and on-premise servers. - - Exploring advanced configurations and future development prospects. + - Understand the SOAFEE architecture and its role in supporting Shift-Left software development strategies to optimize the autonomous driving development process. + - Use the Autoware Open AD Kit simulation environment. + - Run containerized workloads on Arm Neoverse processors with Docker, supporting execution on both cloud-based and on-premise servers. + - Explore advanced configurations and future development prospects. prerequisites: - - An Arm-based Neoverse cloud instance, or a local Arm Neoverse Linux computer with at least 16 CPUs and 32GB of RAM. - - Familiarity with Docker operation. + - An Arm Neoverse cloud instance, or a local Arm Neoverse Linux computer with at least 16 CPUs and 32GB of RAM. + - Familiarity with Docker and Docker Compose. author: Odin Shen @@ -24,24 +24,32 @@ author: Odin Shen skilllevels: Introductory subjects: Containers and Virtualization armips: - - Neoverse V3AE + - Neoverse tools_software_languages: - Python - Docker - - ROS2 + - ROS 2 operatingsystems: - Linux further_reading: - - resource: - title: ROS2 installation - link: https://learn.arm.com/install-guides/ros2/ - type: documentation - resource: title: Autoware OpenAD Kit demo project link: https://github.com/autowarefoundation/openadkit_demo.autoware/ type: documentation + - resource: + title: SOAFEE (Scalable Open Architecture For Embedded Edge) + link: https://soafee.io/ + type: documentation + - resource: + title: Autoware Foundation + link: https://www.autoware.org/ + type: documentation + - resource: + title: ROS 2 Documentation + link: https://docs.ros.org/en/humble/ + type: documentation