IOCAN

# Controllers

A **controller** is the transmission control strategy that runs on the device (in

the schema it is called a **driver**). It turns engine and chassis

[inputs](Configuring_Inputs) into the signals a transmission needs, and exposes

transmission state back through [outputs](Configuring_Outputs) and

[CAN presets](Working_with_the_CAN_Bus#can-presets). Read

[Configuration Concepts](Configuration_Concepts) first — it explains where a

controller sits in the signal flow.

Each controller is selected for the device and then **calibrated** through its own

set of parameters and [maps/tables](Scaling_and_Maps). The pages below document

one controller per page.

## Driver catalogue

The configuration app offers these controllers. Which ones are available depends

on the **device type** (serial-number prefix): a **CANbus Gateway** (`CGW…`) and an

**IOcan** (`IOC…`) run the gateway and emulation drivers; a **GCU** (`GCU…`) runs

the standalone transmission drivers.

| Controller (driver) | Runs on | Role | Page |

|---|---|---|---|

| **8HP OEM Gateway** (Gateway BMW OEM) | CANbus Gateway, IOcan | Engine emulation to a factory BMW / ZF **8HPxx** TCU | [8HP OEM Gateway](8HP_OEM_Gateway) |

| **OEM PDK Gateway** (Gateway PDK OEM) | CANbus Gateway, IOcan | Engine emulation to a factory Porsche **PDK / 7DT45** TCU | [OEM PDK Gateway](OEM_PDK_Gateway) |

| Shifter emulator | CANbus Gateway, IOcan | Emulates an OEM gear selector (GWS) | _planned_ |

| Passthrough | CANbus Gateway, IOcan, GCU | Forwards frames between CAN buses | _planned_ |

| GCU DCT / DL800 / PDK / DQ250 / DQ500 / TR9080 / Getrag 6DCT470 / ZF 8HPxx | GCU | Standalone transmission control (drives the gearbox directly) | _planned_ |

> The **GCU PDK** driver controls the 7DT45 gearbox hardware directly (clutch and

> line-pressure solenoids, gear actuators) and is **not** the same thing as the

> *OEM PDK Gateway*, which talks to the car's factory PDK controller. See

> [OEM PDK Gateway](OEM_PDK_Gateway#related).

## OEM gateway drivers

The **8HP OEM Gateway** and **OEM PDK Gateway** are the same kind of driver: an

**OEM gateway**. They let you keep the **factory transmission controller (TCU)**

and run it behind a standalone/aftermarket ECU. The TCU still does the gear

shifting; the gateway gives it the engine picture it expects.

```

Aftermarket ECU ─inputs→  OEM Gateway driver  ─CAN preset→  Factory TCU

   (RPM, TPS,             (emulates the engine,            (8HP / PDK

    torque, …)             reports gear state)              mechatronics)

Outputs / dash  ←─────────  gear, mode, speed  ←───────────  TCU state

```

What the gateway driver does:

- **Emulates the engine** towards the TCU — most importantly **engine torque**, plus

  RPM, throttle/pedal, MAP, temperatures and chassis signals. Factory TCUs schedule

  shifts and set clutch/line pressure from the torque signal, which aftermarket ECUs

  rarely broadcast in the OEM format.

- **Reports transmission state** back to the rest of the car — current/next gear,

  gearbox mode, ratios, shaft speeds, temperature, vehicle speed, reverse light.

- **Handles clutchless shifts** with the [DBW Modifier](#dbw-modifier) (torque cut on

  upshift, blip on downshift).

The on-wire conversation with the TCU is implemented by a **transmission-emulation

[CAN preset](Working_with_the_CAN_Bus#can-presets)** (one per platform/generation),

which you pair with the driver — they are listed on each driver page.

### Engine torque estimation

Because the torque signal matters so much, the driver can obtain it several ways.

The **Torque calculation method** parameter selects one; the tables it needs are

filled on the driver page.

| Method | How torque is produced | Tables it uses |

|---|---|---|

| **Torque Tables** | Looked up directly from measured engine data | Engine-torque tables (TPS·RPM, MAP·RPM) |

| **External Inputs** | Taken straight from ECU torque inputs | none (uses the torque inputs) |

| **Internal Calculation** | Air-model from displacement, MAP, VE | VE tables + engine parameters |

| **Fuel Calculation / v2** | From injector flow and fuel energy | Injector + fuel tables |

| **Fuel Only / Air Only** | Single-path variants of the above | the matching subset |

Drag maps (engine-speed / throttle / MAP) and the lambda-efficiency map correct the

estimate for engine braking and mixture. Not every method needs every table — fill

the ones for the method you choose.

### DBW Modifier

The **DBW (drive-by-wire) Modifier** produces clean, fast shifts without lifting by

momentarily overriding the electronic throttle / pedal request:

- **Cut** (upshift) — pulls the request **down** to unload the driveline, then ramps

  it back. Calibrated by *limit position* and *ramp-in / ramp-out* time tables.

- **Blip** (downshift) — pushes the request **up** to match revs, then ramps back.

  Calibrated by *target position*, *time*, and *ramp-in / ramp-out* time tables.

The cut/blip tables are indexed by gear and by load (torque) or rev-match need

(ΔRPM), so the override is sized to the shift. See each driver page for the exact

axes.

### Fuel / injector model

When torque is derived from fuelling, the driver models each injector set

(**primary** and optional **secondary**) with injector size, nominal pressure and a

**dead-time** table, plus **fuel density**, **stoichiometric AFR** and **fuel

energy** tables so flex-fuel and temperature are accounted for.

## How the reference tables are written

Each driver page lists its **inputs**, **outputs**, **parameters** and

**calibration tables (maps)**. Names, units, ranges and defaults are taken from the

driver's UI definition in `config-studio-data/controllers/*.json`; the on-wire

fields and tags come from the matching `*.proto` message. Map axes, scaling and

interpolation follow [Scaling and Maps](Scaling_and_Maps).

## Related

- [Configuration Concepts](Configuration_Concepts) — controllers in the signal flow

- [Working with the CAN Bus](Working_with_the_CAN_Bus) — CAN presets and networks

- [Scaling and Maps](Scaling_and_Maps) — how maps/tables are entered and interpolated

- [Supported transmissions](Supported_transmissions)