Home

Welcome to the Adaptive Runtime AUTOSAR Linux Simulator wiki! The project wiki consists of pages related to the project goal, the project scope and its alignment with the AUTOSAR Adaptive standard, the project timeline, and technical design documents. The aim of this project is to provide students/researchers in the automotive engineering a big picture of Adaptive Runtime AUTOSAR and an overview about how its interfaces should be implemented. This repository does not rely on any hardware requirement (e.g., an ECU emulator), but it is able to interact with some hardware interfaces (i.e., CAN bus, LIN bus, and Ethernet).

Project scope

The project does not cover fully the AUTOSAR Adaptive standard. Following table indicates the different domains of the standard, and the project compatibility with each domain:

User Application
Communication Management	RESTful	Time Synchronization	Diagnostics	State Management
	Persistency	Platform Health Management	Log & Trace	Network Management
Core Types	Execution Management	Identity Access Management	Cryptography	Update and Configuration Management
Operating System Interface
(Virtual) Machine / Container / Hardware

User Application

A sample of LIN bus communication is part of the scope.

Communication Management

Partially implemented based on R20-11:

• E2E communication protection (ara::com::e2e) implementation is not planned yet.

• Raw data streaming (ara::com::raw) is out of scope.

• Communication Group (ara::com::cg) is not fully implemented yet.

• Network binding is limited to SOME/IP (Signal-Based and DDS network bindings are out of scope):

  • SOME/IP Service Discovery (SD) only supports IPv4 endpoints.

  • Network link status change is not simulated in the SD finite state machine (FSM).

  • SD Client Requested_but_not_read state is removed from the FSM.

  • The ara::com::someip::sd and ara::com::someip::pubsub namespaces and their sub-namespaces are not part of the official standard.

• Secure Onboard Communication (ara::com::secoc) is out of scope.

RESTful

Fully implementation is not part of the plan, and the scope is limited to an integration with Volvo Extended Vehicle and Connected Vehicle APIs.

Time Synchronization

Out of scope

Diagnostics

Interfaces are partially defined based on R21-11 and the plan is to at last enable the functional cluster to communicate with OBD-II, UDS and DoIP.

State Management

The scope of the State Management is limited to control only the Power Mode via interaction with the Diagnostics functional cluster.The State Management development is in progress based on R21-11.

Persistency

Out of scope

Platform Health Management

It is part of the plan, but the scope is not determined yet.

Log & Trace

The Log & Trace is mostly implemented based on R20-11:

• Log sinks are limited to console and file sinks (network sink is out of scope).

• The ara::log::sink namespace is not part of the official standard.

• Current implementation does not support hexadecimal format, binary format, and ClientState logging.

Network Management

Out of scope

Core Types

It is barely implemented partly based on R21-11 and partly based on R20-11 (which finally will migrate to R21-11 as well). The implementation scope is as follows:

Data type	Implementation revision	Compatibility	Replaced alternative
ErrorDomain	R21-11	Lacking SupportData	-
ErrorCode	R21-11	Lacking SupportData	-
Exception	-	-	std::exception
Result	R20-11	Incompatible noexcept specifiers, dedicated specialized global (in)equality operator, and lacking non-member swap method	-
Future	R21-11 (planned)	Unknown	std::future
Promise	R21-11 (planned)	Unknown	std::promise
Array	-	-	std::array
Vector	-	-	std::vector
Map	-	-	std::map
Optional	C++17	Some constructor overloads are missing	-
Variant	-	-	Out of scope
StringView	-	-	std::string
String	-	-	std::string
Span	-	-	Out of scope
SteadyClock	-	-	std::chrono::steady_clock
InstanceSpecifier	R21-11	Replacing ara::core::StringView with std::string	-
ScaleLinearAndTexttable	-	-	Out of scope
Byte	-	-	uint8_t

Execution Management

The development is in progress based on R21-11:

• Execution Error Event struct:

  • In contrast with the standard, the structure keeps pointer to the Function Group in Undefined State instead of the Function Group itself.

• Execution Client class:

  • There is no default constructor same as the standard and the object owner should pass the Instance Identifier and the Communication Layer (e.g., FIFO IPC).

• Deterministic Client class:

  • noexcept specifiers are not aligned with the standard.

• Function Group class:

  • noexcept specifiers are not aligned with the standard.
  • No ARXML meta-model validation mechanism is implemented.
  • GetInstance method is not aligned with the standard.

• Function Group State class:

  • noexcept specifiers are not aligned with the standard.
  • No ARXML meta-model validation mechanism is implemented.
  • GetFunctionGroup and GetState methods are not aligned with the standard.

• Exec Exception class:

  • MakeErrorCode method does not consider manufacture specific SupportData.

• State Client class:

  • The class constructor takes IPC abstraction layer as well which is not aligned with the standard.
  • noexcept and const specifiers are not aligned with the standard.
  • Undefined Function Group State concept is not implemented.

Identity Access Management

Out of scope

Cryptography

Out of scope

Update and Configuration Management

Out of scope

Operating System Interface

Currently, there is a wrapper interface around BSD sockets to enable functional clusters (e.g., Communication Management) for interacting via TCP/IP protocol.

Project milestones and timeline

Following is the project timeline and its specified milestones within 4 years:

Milestone	Start date	End date	Status
Studying R19-11	January 2020	December 2020	Done
Updating to R20-11	January 2021	May 2021	Done
Launching the repository	May 2021	June 2021	Done
Doxygenizing	September 2021	September 2021	Done
Integrating Async-BSD-Socket-Lib	October 2021	October 2021	Done
Implementing SOME/IP	October 2021	December 2021	Done
Implementing EM and SM	December 2021	January 2022	Done
Developing CAN OBD-II Linux Driver	January 2022	February 2022	Done
Implementing DoIP and UDS within DM	February 2022	August 2022	Done
Integrating DM with EM and SM	September 2022	November 2022	In progress
Developing LIN bus bare-metal hardware interface	November 2022	December 2022	To do
Implementing RESTful	January 2023	March 2023	To do
Implementing LIN bus and CAN bus Adaptive Application	April 2023	May 2023	To do
Finalizing ARA Core (ara::core::Future/Promise implementation)	June 2023	June 2023	To do
Implementing PHM	July 2023	August 2023	To do
Implementing E2E communication protection	September 2023	September 2023	To do
Investigating LIN bus AA integration with OpenAMP	October 2023	January 2024	To do