Setup: Infineon Aurix Drivecore Autosar Scalable Software User Manual

Content

Overview

Aurix Drivecore Autosar Scalable Software is a pre-integrated AUTOSAR development bundle for Infineon AURIX TC4x-class automotive projects, built to speed up ECU software development for domain and zonal controllers. It combines Infineon MCAL drivers, Elektrobit EB zoneo software, EB tresos AutoCore, and the TASKING SmartCode compiler toolchain into a single workflow-focused package.

This guide is aimed at engineers setting up the bundle for the first time, importing the demo project, generating code, building the application, and exploring the hardware-accelerated gateway examples that are included in the package.

The primary value of Aurix Drivecore Autosar Scalable Software is reduced integration effort: the bundle is designed to simplify configuration, accelerate setup, and provide a working starting point for AUTOSAR-based ECU development.

Specifications

Platform focus: Infineon AURIX TC4x automotive microcontrollers
Software stack: EB tresos AutoCore, EB zoneo GatewayCore, EB zoneo ACM8 Eth, Infineon MCAL drivers
Compiler toolchain: TASKING SmartCode v10.2r1 with patch v10.2r1p1
Configuration tool: EB tresos Studio for ACG 9, version 32.1.1
OS component: EB tresos AutoCore OS 6.1.275
Base package: EB tresos AutoCore Base Package 9.3.2
Ethernet package: EB tresos AutoCore Generic Ethernet Package 9.3.2
GatewayCore version: 1.0.0
ACM8 Eth version: 1.0.0
Target board: TriBoard TC4D9 Zone Gateway Board
Example hardware setup: 1x KIT_TC4D_ZONE_GW_BTX_APP 2.0 and 2x GW CAN extension boards
Supported transport/demo areas: CAN, Ethernet, IEEE 1722, and PDUR routing

Detailed description

Aurix Drivecore Autosar Scalable Software is organized around a complete AUTOSAR Classic workflow rather than a single driver or library. The bundle brings together hardware abstraction, configuration tooling, code generation, and build support so teams can move from imported project data to a runnable demo with fewer manual integration steps.

The bundle is centered on two Elektrobit components. EB zoneo GatewayCore is the hardware-dependent complex device driver that enables communication acceleration features on the target platform, while EB zoneo ACM8 Eth provides the Ethernet driver abstraction required by the AUTOSAR Ethernet interface layer.

In practical terms, the package demonstrates how hardware acceleration on TC4-class devices can be used for gateway-style communication. The included demo covers both hardware-accelerated routing and software PDUR routing, showing CAN-to-CAN, CAN-to-MEM, CAN-to-ETH.IEEE1722, and ETH.IEEE1722-to-CAN paths alongside classic software routes such as CAN-to-ETH, ETH-to-CAN, and ETH-to-ETH.

The software workflow uses EB tresos Studio to import configuration files, validate them, generate output artifacts, and prepare the build inputs. The example project is then compiled with TASKING SmartCode, and an optional winIDEA workspace is available for flashing and debugging.

Setup

Prerequisites

Before installation, the package expects a valid set of software files, licenses, and target hardware. The provided materials include the GatewayCore user guide, EB tresos package files, the TASKING compiler installer and patch, and the delivered plugin content used by the demo project.

The required licenses are for EB tresos and the TASKING compiler. The target hardware is the TriBoard TC4D9 Zone Gateway Board.

Install EB tresos Studio

The recommended installation method is the provided setup script, which extracts nested archives automatically so the installer can find all modules. That approach is preferred over a simple top-level installer run because it avoids missing plugin files during project import.

During setup, install the EB tresos license and the workspace package supplied with the bundle. The workspace is delivered as an installation package and is installed through the EB tresos Studio installer.

Install TASKING SmartCode

The compiler must be installed in two stages. First install TASKING SmartCode v10.2r1, then apply the v10.2r1p1 patch. The base installer is run from the provided archive, and the patch is installed afterward using the same process.

The installation path should not contain spaces, because path handling problems can break the build system. The compiler license is node-locked and becomes bound to the first machine that uses it.

Hardware setup

The demo hardware setup uses the TC4D zone gateway board together with two GW CAN extension boards. The CAN extension boards connect to the board’s CAN0 and CAN1 connectors, and the setup also uses the board’s Ethernet interface.

The documented physical mapping ties multiple CAN connectors and the GETH0 port to their matching tresos configuration objects. This mapping is used by the imported demo project so routing entries align with the actual wiring.

Operation

Import and generate the demo project

To start the example project, launch EB tresos, choose a workspace directory, and import the existing project into the workspace. The GwCDemo project should be copied into the workspace before finishing the import.

After import, open the ECU project for the TRICORE TC4DXX target and run code generation. If any preset routing values are changed, save the project and generate again before building.

Build the application

The build environment is configured through a launch configuration file that sets the compiler path and working directory. The compiler path must point to the bin folder of the TASKING toolchain, and the work base must point to the directory that contains the EB tresos folder.

To compile the demo, run the launch script and then invoke the make process. Successful code generation is required before compilation, including after a clean build.

Flashing and debugging

After a successful build, the binary is created in the demo output folder. Flashing can be done through the TC4D Zone Gateway board’s supported programming and debug interfaces, including the on-board miniWiggler and the board’s DAP and HSTCU connectors.

An optional preconfigured winIDEA workspace is included for users who want a quicker path to flashing and debugging. The workspace is set up for SMP use in a multi-core environment.

Demo routing examples

The bundled demo demonstrates several routing styles to illustrate how Aurix Drivecore Autosar Scalable Software handles both hardware-accelerated and software-based communication paths.

Hardware-accelerated CAN-to-CAN routing for unicast and multicast traffic
Hardware-accelerated CAN-to-MEM routing
Hardware-accelerated CAN-to-ETH.IEEE1722 routing
Hardware-accelerated ETH.IEEE1722-to-CAN routing
Software PDUR routing for CAN-to-CAN, CAN-to-ETH, ETH-to-CAN, and ETH-to-ETH traffic

Some Ethernet-bridging examples require EthQoSSupport to be enabled before generation and build. The routing names follow a structured naming pattern so entries remain readable and easy to maintain in the configuration tool.

Development resources

The package includes additional guidance for communication acceleration configuration, along with a short routing guide for PDUR setup. These resources are intended to help engineers adjust the existing demo rather than build everything from scratch.

For CAN receive, the configuration uses filtered hardware objects, CanIf receive mappings, receive PDU collection entries, and a PDUR routing path that points to the destination transmit configuration. For CAN transmit, the setup uses a transmit-capable hardware object, CanIf transmit mappings, transmit PDU configuration, and a PDUR destination PDU.

For ETH transmit, the configuration covers SoAd routes and socket connections, TCP/IP local address and controller settings, EthIf controller setup, ComM network channel mapping, and a PDUR destination PDU. For ETH receive, the path uses a SoAd socket route, receive PDU collection, a PDUR routing path, and a destination linked to either CAN transmit or ETH transmit.

Troubleshooting

The most common setup issues are related to compiler path configuration, Ethernet QoS, missing generated files, and incomplete module installation. Most of these problems can be corrected by checking the installation layout and regenerating the project after configuration changes.

If the compiler is not found, verify that the compiler path points to the correct bin folder and does not use quotation marks.
If the build fails on CAN-to-ETH.IEEE1722 or ETH.IEEE1722-to-CAN routing, confirm that EthQoSSupport is enabled and that the configuration was saved before generation.
If make reports that a target is missing, regenerate the project before rebuilding and remove the output folder if the issue persists.
If modules are missing during project import, check that the plugins were installed correctly and that the archives were fully extracted.

Safety

The documentation is intended for technically trained users and places responsibility on the integrator to evaluate whether the product is suitable for the intended application. It also notes that the product information is not a guarantee of specific conditions or characteristics.

Users should treat the bundle as development software for automotive engineering, where application compliance, standards conformance, and final suitability remain the responsibility of the customer’s technical team. The product may contain dangerous substances, and it must not be used in applications where failure could reasonably be expected to cause personal injury unless explicitly approved in writing.

Pros & Cons

Pros: Pre-integrated AUTOSAR workflow for AURIX TC4x projects
Pros: Includes hardware-accelerated gateway examples and software routing examples
Pros: Combines configuration, code generation, compiler support, and debugging setup
Pros: Helps reduce integration effort for domain and zonal ECU development
Cons: Requires careful setup of licenses, paths, and module installation order
Cons: Some Ethernet routing examples depend on QoS support being enabled
Cons: Build and debug success depend on matching the documented hardware and software versions

Aurix Drivecore Autosar Scalable Software is best suited to engineering teams that want a structured AUTOSAR starting point with clear demo coverage, controlled toolchain setup, and a ready-made path from configuration to flashing.

PDF

Faqs

What do I need before installing Aurix Drivecore Autosar Scalable Software?

Before installation, make sure you have the required documents, software packages, licenses, and target hardware ready. The guide calls for EB tresos Studio, TASKING SmartCode v10.2r1p1, the EB-zoneo GatewayCore user guide, and valid license keys for both EB tresos and the TASKING compiler. You also need the supported evaluation board and the related gateway extension boards. Having everything prepared first helps avoid missing-module and compiler-path problems during setup.

Should I use setup.bat or setup.exe to install EB tresos Studio for the Aurix Drivecore Autosar demo?

The recommended choice is setup.bat because it automatically unzips the bundled module files recursively before installation. That reduces the chance of missing plugins later in EB tresos Studio. setup.exe can work, but it only looks at top-level files, so any compressed module packages may need to be extracted manually first. Using setup.bat is the safer option when preparing the DriveCore demo workspace and plugins.

Why do I need to install TASKING SmartCode baseline and patch in a specific order?

The guide requires installing TASKING SmartCode v10.2r1 first and then applying the v10.2r1p1 patch afterward. The patch depends on the baseline compiler being already present, so reversing the order can leave the toolchain incomplete or unusable for the demo build. After installation, keep the compiler path simple and avoid spaces in the install directory, because the build scripts are sensitive to path formatting.

How is the TC4D Zone Gateway hardware connected in the Aurix Drivecore Autosar demo?

The demo hardware setup uses the TC4D Zone Gateway board together with two CAN extension boards. The CAN extension boards connect to the board’s CAN0 and CAN1 connectors, and the setup also uses the board Ethernet interface GETH0. The guide maps the physical connectors to configured software controllers in EB tresos, so wiring must match the expected controller names for CAN and Ethernet routing to work correctly.

How do I import and generate the GatewayCore demo project in EB tresos Studio?

Start EB tresos Studio, select or create the workspace, and import the existing project into that workspace. Make sure the GwCDemo project is selected and copied into the workspace. After import, open the ECU configuration for the TC4DXX project and click Generate. If you change any preset routing or configuration values, save the project and generate again so the build assets stay in sync.

What is the correct build workflow after generating the Aurix Drivecore Autosar demo project?

First run the launch script so the environment variables from launch_cfg.bat are loaded, including the compiler path and workspace location. Then start the build with make -j. The guide notes that code generation must already be complete before compilation, and this also applies after a make clean. Once compilation succeeds, the binary is placed in the output bin folder of the GwCDemo project.

Why does the build fail with a compiler not found error in Aurix Drivecore Autosar?

This usually means the compiler path in the build configuration is wrong or the installation path contains spaces. The guide warns not to wrap TOOLPATH_COMPILER in quotation marks, because that can break the automatic path handling used by the make files. It also recommends installing TASKING SmartCode in a directory without white spaces. Correcting the compiler path and reinstalling into a clean path often resolves the issue.

What should I check if CAN-to-Ethernet or Ethernet-to-CAN forwarding does not work in the demo?

The first thing to check is whether Ethernet QoS support is enabled, because hardware CAN-to-ETH.IEEE1722 and ETH.IEEE1722-to-CAN forwarding depends on it. After enabling the setting, save the configuration before generating code again. If forwarding still fails, confirm that the project was regenerated and rebuilt after the change, since stale generated files can keep the routing from matching the active configuration.