---
title: "Describing the platform"
description: "Describe your vehicle platform for RemotiveTopology with ARXML, DBC and other databases, and add to or combine them in a RemotiveTopology platform file."
source: https://developer.remotivelabs.com/docs/remotive-topology/concepts/platform
last_updated: 2026-11-20
---

# Describing the platform

The platform describes which ECUs and services that exist and how they communicate. In RemotiveTopology you can describe your platform in a number of different ways:

- An `ARXML` ECU extract
- An `ARXML` system description (contains all ECUs)
- A `DBC` file describing a CAN channel and all ECUs on that channel. Notice that DBC doesn't include which channel it's describing!
- RemotiveTopology `platform.yaml` to add additional information or combining other files

Normally you can use your existing platform databases, such as ARXML, DBC, Fibex etc. However, sometimes these files aren't yet available or are missing some data. In those situations you can add additional platform information using `platform.yaml` files.

See full [topology schema](https://developer.remotivelabs.com/apis/json/topology) for details.

## Showing a platform

The easiest way to understand what a file contains is to

```sh
$ remotive topology show platform <file>
```

This shows the platform contents as `platform.yaml` and includes all channels and ECUs described by the file.

## Combining platforms

### Using ARXML

ARXML contains channels, ECUs, and how the ECUs are connected to the channels. Simply add ARXML as includes:

```yaml
schema: remotive-topology-platform:0.18
includes:
  - ../databases/my-ecu-a.arxml
  - ../databases/my-ecu-b.arxml
```

Notice that all included files must be compatible! This means that the referenced ECUs and channels must have the same names and settings. Ensure that the files are from the same version.

### Using DBC

DBC only contains ECUs and doesn't contain the channel name. This means that you must specify what channel should use the DBC using the `database` field:

```yaml
schema: remotive-topology-platform:0.18
channels:
  DriverCan0:
    type: can
    database: ../databases/driver_can.dbc
```

This automatically adds the ECUs that are part of the DBC and connect these to the channel, i.e.:

```sh
$ remotive topology show platform topology/simple.platform.yaml
---
schema: remotive-topology-platform:0.18
channels:
  DriverCan0:
    type: can
    database: .../databases/driver_can.dbc
ecus:
  BCM:
    channels:
      DriverCan0:
        database: .../databases/driver_can.dbc
  SCCM:
    channels:
      DriverCan0:
        database: .../databases/driver_can.dbc
```

Notice how `database` is also set for the ECU channels. The reason is that these ECUs use that database to decode signals. Sometimes it's useful to only allow an ECU a partial view of the channel. To do this you can override the ECU channel database.

### Using LIN description files

A LIN Description file (LDF) contains information about the ECUs connected to a LIN bus, but not the name of the bus itself. Just like for DBC files, the channel is specified explicitly and the database file is added to it:

```yaml
schema: remotive-topology-platform:0.18
channels:
  RearLightLin:
    type: lin
    database: ../databases/my-lin-bus.ldf
```

### Using `platform.yaml`

A key principle in RemotiveTopology is modularity. This means that combining platform subsystems is very easy using `includes`:

```yaml
schema: remotive-topology-platform:0.18
includes:
  - ./lighting.platform.yaml
  - ./climate.platform.yaml
  - ./driver.platform.yaml
```

## Channels and ECUs

Channels define how ECUs communicate with each other.

### CAN channel

CAN channels are very easy to add. All RemotiveTopology need to know is that the channel exists:

```yaml
channels:
  DriverCan0:
    type: can
```

You can also add missing information, if needed. While this information may be available in ARXML files, it's missing from DBC files. For example, if you need RemotiveTopology to configure a network interface, it needs to know the baud rate of the bus and whether or not to use CANFD bit rate switching:

```yaml
channels:
  DriverCan0:
    type: can
    baudrate: 500000
    baudrate_fd: 500000
    brs: true
```

To define that an ECU is connected to a CAN channel you simply specify that the channel exists on the ECU:

```yaml
ecus:
  BCM:
    channels:
      DriverCan0:
```

### LIN channel

LIN channels can only be added with [LDF files](#using-lin-description-files). LDF files don't include information about the physical layer, so this should be added in the platform file if needed:

```yaml
channels:
  RearLightLin:
    type: lin
    database: ../databases/my-lin-bus.ldf
    baudrate: 19200
```

### Ethernet channel

Ethernet channels require more information such as subnet and VLAN, but also about the services that are available. See below how different services are specified.

```yaml
channels:
  MyEth:
    type: ethernet
    subnet: 10.1.0.0/24
    vlan: 2
```

- `subnet` is required
- `vlan` is optional

To define that an ECU is connected to an ethernet channel you must specify the IP address of the ECU:

```yaml
ecus:
  BCM:
    channels:
      MyEth:
        config:
          type: ethernet
          host: 10.1.0.50
```

#### Ethernet PDUs

Ethernet PDUs allow point to point communication and are defined by using a combination of endpoint and named sockets. An `endpoint` describe the host. A `socket` describes the port and what services are available on that port. The following example specifies that there exists UDP communication between 10.1.0.50:12345 and 10.1.0.51:17000.

```yaml
channels:
  MyEth:
    type: ethernet
    endpoints:
      SomeServiceProvider:
        host: 10.1.0.51
        sockets:
          SomeService:
            type: udp
            port: 17000
            socket_connections:
              - SomeClient
      SomeServiceConsumer:
        host: 10.1.0.50
        sockets:
          SomeClient:
            type: udp
            port: 12345
            socket_connections:
              - SomeService
```

Notice:

- Multiple `endpoints` can share the same IP number
- Socket names must be unique within a channel
- the ethernet PDUs must be defined in the signal database to decode/encode the messages
- `socket_connections` doesn't imply a direction of communication, instead it only specifies that the sockets are communicating.

In addition to the channel information you must also declare which ECU that provides (i.e. owns) each endpoint.

```yaml
ecus:
  SomeECU:
    channels:
      MyEth:
        config:
          type: ethernet
          provided_endpoints:
            - SomeServiceProvider
```

> **Note**
>
> All this information is normally specified in ARXML and RemotiveTopology use the information from the ARXML if included!

> **Tip**
>
> Use `remotive topology show topolygy <some.arxml>` to see the endpoints that are declared in ARXML.

Notice that when using ECU extract in ARXML only endpoints and sockets that are relevant to the extracted ECU are included in the ECU extract. This means the following isn't included:

- which ECU that provides the remote endpoints
- the fact that the remote sockets are communicating with your ECU sockets (i.e. you only see the `socket_connections` of the extracted ECU)

#### SOME/IP

When using SOME/IP on an ethernet channel the platform should specify:

- all service instances (`service_id`, `instance_id`, `major_version`)
- where the service instance is provided
- optionally where the service instance is consumed

```yaml
channels:
  MyEth:
    type: ethernet
    endpoints:
      MyServiceProvider:
        host: 10.1.0.43
        sockets:
          MyServiceProviderPort:
            type: udp
            port: 12345
            provided_service_instances:
              - MyService_instance
      MyServiceConsumer:
        host: 10.1.0.17
        sockets:
          MyServiceConsumerPort:
            type: udp
            port: 12345
            consumed_service_instances:
              - MyService_instance
    someip:
      services:
        MyService_instance:
          service_id: 1234
          instance_id: 1
          version_major: 1
```

Notice that the SOME/IP service interfaces must be defined in the signal database to know what methods and events exist.

> **Note**
>
> All this information is normally specified in ARXML and RemotiveTopology use the information from the ARXML if included!

> **Tip**
>
> Use `remotive topology show topolygy <some.arxml>` to see the services that are declared in ARXML.

## Grouping ECUs into a single broker

By default each ECU is instantiated with its own RemotiveBroker. To group several ECUs to one broker, use the `alias_for` property of the ECUs in your platform file. This example groups `ECU_1` and `ECU_2` to use the same broker:

```yaml
schema: remotive-topology-platform:0.18
ecus:
  ECU_1:
    alias_for: can_broker

  ECU_2:
    alias_for: can_broker
```

> **Note**
>
> `alias_for` doesn't work for ECUs with Ethernet channels.
