Quantex GmbH
DE RU EN EL
Ihre Region: Europa
  1. Startseite
  2. ScanDoc Development
  3. J2534-Handbuch
  4. Beschreibung der PassThru-Funktionen
  5. PassThruIoctl

DoIP (ISO 13400) Quantex

Diagnose über IP

Letzte Änderung:

Beschreibung

ISO 13400 (DoIP — Diagnostics over IP) ist ein Standard für die Fahrzeugdiagnose über Ethernet. Er wird in modernen Fahrzeugen für Hochgeschwindigkeitsdiagnose und Software-Updates eingesetzt. ScanDoc unterstützt DoIP über den integrierten Ethernet-Adapter.

Für die Nutzung von DoIP wird ein ScanDoc-Adapter mit Ethernet-Unterstützung benötigt (prüfen Sie über GET_DEVICE_INFO den Parameter ETHERNET_NDIS_SUPPORTED).

Ablauf des DoIP-Verbindungsaufbaus

  1. Öffnen Sie einen ISO 13400-Kanal über PassThruConnect(ISO13400_PS)
  2. Führen Sie die Fahrzeugsuche im Netzwerk aus (ISO13400_DISCOVER_VEHICLES) oder setzen Sie die IP-Adresse manuell
  3. Rufen Sie die Informationen des gefundenen Fahrzeugs ab (ISO13400_GET_VEHICLE_INFO)
  4. Konfigurieren Sie die DoIP-Parameter über SET_CONFIG (Adressen SA/TA, IP-Adresse des Steuergeräts)
  5. Bauen Sie die TCP-Verbindung auf (ISO13400_CONNECT_TCP)
  6. Aktivieren Sie das Routing (ISO13400_ACTIVATE_ROUTING)
  7. Verwenden Sie PassThruReadMsgs/PassThruWriteMsgs für die Diagnose

DoIP-Parameter (SET_CONFIG)

Vor der Verwendung der DoIP-Befehle müssen die Parameter über SET_CONFIG konfiguriert werden.

Parameter Wert Beschreibung Standard
ISO13400_SOURCE_ADDR 0x8100 Logische Adresse des Testers (SA). In der Regel 0x0E00-0x0EFF. 0x0E00
ISO13400_TARGET_ADDR 0x8101 Logische Adresse des Steuergeräts (TA). Fahrzeugabhängig. —
ISO13400_ECU_IP_ADDR 0x8102 IP-Adresse des Gateways/Steuergeräts (4 Bytes, Big-Endian) —
ISO13400_ECU_TCP_PORT 0x8103 TCP-Port für die Verbindung 13400
ISO13400_T_TCP_INITIAL 0x8104 Inaktivitäts-Timeout bis zur Routing Activation (ms) 2000
ISO13400_T_TCP_GENERAL 0x8105 Allgemeines TCP-Inaktivitäts-Timeout (ms) 300000
ISO13400_T_DIAG_MSG 0x8106 Timeout für das Warten auf die Diagnose-Antwort (ms) 2000
ISO13400_ACTIVATION_TYPE 0x8107 Routing Activation Type (0x00 — Default, 0x01 — WWH-OBD, 0xE0 — Central Security) 0

DoIP-Befehle

ISO13400_DISCOVER_VEHICLES — Fahrzeugsuche

Sendet eine UDP-Broadcast-Anfrage zur Erkennung von DoIP-fähigen Fahrzeugen im lokalen Netzwerk. Die Ergebnisse werden in einem internen Puffer gespeichert und sind über ISO13400_GET_VEHICLE_INFO abrufbar.

IoctlID 0x8110
pInput NULL
pOutput NULL

Beispiel in C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Von PassThruConnect für ISO13400_PS erhalten
long ret;

ret = PassThruIoctl(ChannelID, ISO13400_DISCOVER_VEHICLES, NULL, NULL);
if (ret == STATUS_NOERROR)
{
    printf("Suche abgeschlossen\n");
}

Beispiel in Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_DISCOVER_VEHICLES, 0, null)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "Suche abgeschlossen")
}

Beispiel in Python

ret = j2534.PassThruIoctl(channel_id, ISO13400_DISCOVER_VEHICLES, None, None)
if ret == 0:
    print("Suche abgeschlossen")

Beispiel in C#

int ret = J2534.PassThruIoctl(channelId, ISO13400_DISCOVER_VEHICLES, IntPtr.Zero, IntPtr.Zero);
if (ret == 0)
    Console.WriteLine("Suche abgeschlossen");

ISO13400_GET_VEHICLE_INFO — Fahrzeuginformationen

Gibt Informationen zum gefundenen Fahrzeug zurück: VIN, logische Adresse, IP-Adresse des Gateways. Wird nach ISO13400_DISCOVER_VEHICLES aufgerufen.

IoctlID 0x8111
pInput NULL
pOutput DOIP_VEHICLE_INFO* — Struktur mit den Informationen zum ersten gefundenen Fahrzeug 
typedef struct {
    char VIN[18];               // VIN-Code (17 Zeichen + '\0')
    unsigned short LogicalAddr; // Logische Adresse des DoIP-Gateways
    unsigned char EID[6];       // Entity Identification (MAC-Adresse)
    unsigned char GID[6];       // Group Identification
    unsigned char FurtherAction;// Weiterverarbeitungs-Code (0x00 — keiner, 0x10 — Routing Activation erforderlich)
    unsigned char SyncStatus;   // Synchronisationsstatus VIN/GID (0x00 — synchronisiert, 0x10 — nicht abgeschlossen)
    unsigned long IPAddr;       // IPv4-Adresse (Big-Endian)
} DOIP_VEHICLE_INFO;

Beispiel in C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Von PassThruConnect für ISO13400_PS erhalten
DOIP_VEHICLE_INFO vehicleInfo;
long ret;

ret = PassThruIoctl(ChannelID, ISO13400_GET_VEHICLE_INFO, NULL, &vehicleInfo);
if (ret == STATUS_NOERROR)
{
    printf("VIN: %s\n", vehicleInfo.VIN);
    printf("Logische Adresse: 0x%04X\n", vehicleInfo.LogicalAddr);
    printf("IP: %d.%d.%d.%d\n",
           (vehicleInfo.IPAddr >> 24) & 0xFF,
           (vehicleInfo.IPAddr >> 16) & 0xFF,
           (vehicleInfo.IPAddr >> 8) & 0xFF,
           vehicleInfo.IPAddr & 0xFF);
}

Beispiel in Kotlin (Android)

val result = j2534.ptGetVehicleInfo(channelID)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "VIN: ${result.vin}")
    Log.i("DoIP", "Logische Adresse: 0x${result.logicalAddr.toString(16).uppercase()}")
    Log.i("DoIP", "IP: ${result.ipAddrString}")
}

Beispiel in Python

from ctypes import *

class DOIP_VEHICLE_INFO(Structure):
    _fields_ = [
        ("VIN", c_char * 18),
        ("LogicalAddr", c_ushort),
        ("EID", c_ubyte * 6),
        ("GID", c_ubyte * 6),
        ("FurtherAction", c_ubyte),
        ("SyncStatus", c_ubyte),
        ("IPAddr", c_ulong)
    ]

vehicle_info = DOIP_VEHICLE_INFO()

ret = j2534.PassThruIoctl(channel_id, ISO13400_GET_VEHICLE_INFO, None, byref(vehicle_info))
if ret == 0:
    ip = vehicle_info.IPAddr
    print(f"VIN: {vehicle_info.VIN.decode()}")
    print(f"Logische Adresse: 0x{vehicle_info.LogicalAddr:04X}")
    print(f"IP: {(ip >> 24) & 0xFF}.{(ip >> 16) & 0xFF}.{(ip >> 8) & 0xFF}.{ip & 0xFF}")

Beispiel in C#

[StructLayout(LayoutKind.Sequential)]
public struct DOIP_VEHICLE_INFO {
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 18)]
    public byte[] VIN;
    public ushort LogicalAddr;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
    public byte[] EID;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
    public byte[] GID;
    public byte FurtherAction;
    public byte SyncStatus;
    public uint IPAddr;
}

DOIP_VEHICLE_INFO vehicleInfo;
int ret = J2534.PassThruIoctl(channelId, ISO13400_GET_VEHICLE_INFO, IntPtr.Zero, out vehicleInfo);
if (ret == 0)
{
    Console.WriteLine($"VIN: {Encoding.ASCII.GetString(vehicleInfo.VIN).TrimEnd('\0')}");
    Console.WriteLine($"Logische Adresse: 0x{vehicleInfo.LogicalAddr:X4}");
    var ip = vehicleInfo.IPAddr;
    Console.WriteLine($"IP: {(ip >> 24) & 0xFF}.{(ip >> 16) & 0xFF}.{(ip >> 8) & 0xFF}.{ip & 0xFF}");
}

ISO13400_CONNECT_TCP — TCP-Verbindung

Baut eine TCP-Verbindung zum Fahrzeug-Gateway auf. IP-Adresse und Port müssen zuvor über SET_CONFIG konfiguriert oder über ISO13400_GET_VEHICLE_INFO ermittelt worden sein.

IoctlID 0x8112
pInput NULL (verwendet die Parameter aus SET_CONFIG) oder DOIP_CONNECT_PARAMS*
pOutput NULL

Beispiel in C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Von PassThruConnect für ISO13400 erhalten
long ret;

// Parameter sind bereits über SET_CONFIG gesetzt
ret = PassThruIoctl(ChannelID, ISO13400_CONNECT_TCP, NULL, NULL);
if (ret == STATUS_NOERROR)
{
    printf("TCP-Verbindung hergestellt\n");
}
else
{
    char error[256];
    PassThruGetLastError(error);
    printf("Verbindungsfehler: %s\n", error);
}

Beispiel in Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_CONNECT_TCP, 0, null)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "TCP-Verbindung hergestellt")
} else {
    Log.e("DoIP", "Fehler bei der TCP-Verbindung: ${result.status}")
}

Beispiel in Python

ret = j2534.PassThruIoctl(channel_id, ISO13400_CONNECT_TCP, None, None)
if ret == 0:
    print("TCP-Verbindung hergestellt")
else:
    print(f"Fehler bei der TCP-Verbindung: {ret}")

Beispiel in C#

int ret = J2534.PassThruIoctl(channelId, ISO13400_CONNECT_TCP, IntPtr.Zero, IntPtr.Zero);
if (ret == 0)
    Console.WriteLine("TCP-Verbindung hergestellt");
else
    Console.WriteLine($"Fehler bei der TCP-Verbindung: {ret}");

ISO13400_ACTIVATE_ROUTING — Routing-Aktivierung

Sendet eine Routing-Activation-Anfrage, um Zugriff auf die Diagnose zu erhalten. Der Aktivierungstyp wird über den Parameter ISO13400_ACTIVATION_TYPE festgelegt.

IoctlID 0x8113
pInput NULL oder unsigned long* — Aktivierungstyp (0 — Default, 1 — WWH-OBD)
pOutput unsigned long* — Antwortcode vom Gateway

Routing-Activation-Antwortcodes (ISO 13400-2, Table 25)

0x00 Routing activation denied — Unknown source address
0x01 Routing activation denied — All TCP_DATA sockets registered and active
0x02 Routing activation denied — Different SA on already activated socket
0x03 Routing activation denied — SA already registered on different socket
0x04 Routing activation denied — Missing authentication
0x05 Routing activation denied — Rejected confirmation
0x06 Routing activation denied — Unsupported routing activation type
0x07 Routing activation denied — Requires TLS socket
0x10 Routing successfully activated
0x11 Routing will be activated — confirmation required

Beispiel in C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;
unsigned long activationType = 0;  // Default
unsigned long responseCode = 0;
long ret;

ret = PassThruIoctl(ChannelID, ISO13400_ACTIVATE_ROUTING, &activationType, &responseCode);
if (ret == STATUS_NOERROR)
{
    if (responseCode == 0x10)
        printf("Routing erfolgreich aktiviert\n");
    else
        printf("Antwortcode: 0x%02X\n", responseCode);
}

Beispiel in Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_ACTIVATE_ROUTING, 0, null)
if (result.status == STATUS_NOERROR) {
    if (result.outputValue == 0x10) {
        Log.i("DoIP", "Routing erfolgreich aktiviert")
    } else {
        Log.w("DoIP", "Antwortcode: 0x${result.outputValue.toString(16)}")
    }
}

Beispiel in Python

from ctypes import *

activation_type = c_ulong(0)  # Default
response_code = c_ulong(0)

ret = j2534.PassThruIoctl(channel_id, ISO13400_ACTIVATE_ROUTING, byref(activation_type), byref(response_code))
if ret == 0:
    if response_code.value == 0x10:
        print("Routing erfolgreich aktiviert")
    else:
        print(f"Antwortcode: 0x{response_code.value:02X}")

Beispiel in C#

uint activationType = 0;  // Default
uint responseCode;
int ret = J2534.PassThruIoctl(channelId, ISO13400_ACTIVATE_ROUTING, ref activationType, out responseCode);
if (ret == 0)
{
    if (responseCode == 0x10)
        Console.WriteLine("Routing erfolgreich aktiviert");
    else
        Console.WriteLine($"Antwortcode: 0x{responseCode:X2}");
}

Rückgabe-Fehlercodes

Code Beschreibung Mögliche Ursachen und Lösungen
STATUS_NOERROR Funktion erfolgreich ausgeführt —
ERR_DEVICE_NOT_CONNECTED Keine Verbindung zum Adapter
  • Der Adapter ist ausgeschaltet oder außerhalb der Reichweite
  • Lösung: Prüfen Sie Stromversorgung und Verbindung
ERR_NOT_SUPPORTED DoIP wird nicht unterstützt
  • Der Adapter hat keine Ethernet-Schnittstelle
  • Lösung: Prüfen Sie ETHERNET_NDIS_SUPPORTED über GET_DEVICE_INFO
ERR_TIMEOUT Timeout der Operation
  • Das Fahrzeug antwortet nicht auf DoIP-Anfragen
  • Falsche IP-Adresse oder falscher Port
  • Lösung: Prüfen Sie Netzwerkverbindung und Parameter
ERR_INVALID_CHANNEL_ID Ungültige Kanal-ID
  • ChannelID wurde nicht über PassThruConnect für ISO13400 erhalten
  • Lösung: Führen Sie PassThruConnect mit dem Protokoll ISO13400_PS aus
ERR_FAILED Nicht näher bestimmter Fehler
  • Netzwerkfehler oder Ablehnung durch das Gateway
  • Lösung: Rufen Sie PassThruGetLastError() auf

Vollständiges Beispiel einer DoIP-Sitzung

Beispiel in C/C++

#include "j2534_dll.hpp"
#include <stdio.h>

int DoIPDiagnosticSession(void)
{
    unsigned long DeviceID, ChannelID;
    long ret;

    // 1. Gerät öffnen
    ret = PassThruOpen(NULL, &DeviceID);
    if (ret != STATUS_NOERROR) return ret;

    // 2. Ethernet-Unterstützung prüfen
    SCONFIG cfg[1];
    SCONFIG_LIST cfgList = {1, cfg};
    cfg[0].Parameter = ETHERNET_NDIS_SUPPORTED;
    ret = PassThruIoctl(DeviceID, GET_DEVICE_INFO, &cfgList, NULL);
    if (ret != STATUS_NOERROR || cfg[0].Value == 0)
    {
        printf("DoIP wird nicht unterstützt\n");
        PassThruClose(DeviceID);
        return -1;
    }

    // 3. ISO 13400-Kanal öffnen
    ret = PassThruConnect(DeviceID, ISO13400_PS, 0, 0, &ChannelID);
    if (ret != STATUS_NOERROR)
    {
        PassThruClose(DeviceID);
        return ret;
    }

    // 4. Fahrzeuge im Netzwerk suchen
    ret = PassThruIoctl(ChannelID, ISO13400_DISCOVER_VEHICLES, NULL, NULL);
    if (ret != STATUS_NOERROR)
    {
        printf("Fehler bei der Fahrzeugsuche\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 5. Informationen zum gefundenen Fahrzeug abrufen
    DOIP_VEHICLE_INFO vehicleInfo;
    ret = PassThruIoctl(ChannelID, ISO13400_GET_VEHICLE_INFO, NULL, &vehicleInfo);
    if (ret != STATUS_NOERROR)
    {
        printf("Keine Fahrzeuge gefunden\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }
    printf("VIN: %s\n", vehicleInfo.VIN);

    // 6. DoIP-Parameter konfigurieren
    SCONFIG doipCfg[3];
    SCONFIG_LIST doipCfgList = {3, doipCfg};
    doipCfg[0].Parameter = ISO13400_SOURCE_ADDR;
    doipCfg[0].Value = 0x0E00;
    doipCfg[1].Parameter = ISO13400_TARGET_ADDR;
    doipCfg[1].Value = vehicleInfo.LogicalAddr;
    doipCfg[2].Parameter = ISO13400_ECU_IP_ADDR;
    doipCfg[2].Value = vehicleInfo.IPAddr;

    ret = PassThruIoctl(ChannelID, SET_CONFIG, &doipCfgList, NULL);
    if (ret != STATUS_NOERROR)
    {
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 7. TCP-Verbindung aufbauen
    ret = PassThruIoctl(ChannelID, ISO13400_CONNECT_TCP, NULL, NULL);
    if (ret != STATUS_NOERROR)
    {
        printf("Fehler bei der TCP-Verbindung\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 8. Routing aktivieren
    unsigned long activationType = 0;
    unsigned long responseCode = 0;
    ret = PassThruIoctl(ChannelID, ISO13400_ACTIVATE_ROUTING, &activationType, &responseCode);
    if (ret != STATUS_NOERROR || responseCode != 0x10)
    {
        printf("Fehler bei der Routing-Aktivierung: 0x%02X\n", responseCode);
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    printf("DoIP-Verbindung hergestellt!\n");

    // 9. Jetzt können Diagnose-Anfragen gesendet werden
    // über PassThruWriteMsgs / PassThruReadMsgs

    // Verbindung schließen
    PassThruDisconnect(ChannelID);
    PassThruClose(DeviceID);
    return 0;
}

Beispiel in Kotlin (Android)

suspend fun connectDoIP(): Boolean {
    // 1. Gerät öffnen
    val openResult = j2534.ptOpen(null)
    if (openResult.status != STATUS_NOERROR) return false
    val deviceID = openResult.deviceId

    // 2. ISO 13400-Kanal öffnen
    val connectResult = j2534.ptConnect(deviceID, ISO13400_PS, 0u, 0u)
    if (connectResult.status != STATUS_NOERROR) {
        j2534.ptClose(deviceID)
        return false
    }
    val channelID = connectResult.channelId

    // 3. Fahrzeugsuche
    val discoverResult = j2534.ptIoctl(channelID, ISO13400_DISCOVER_VEHICLES, 0, null)
    if (discoverResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Fehler bei der Fahrzeugsuche")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    // 4. Informationen zum gefundenen Fahrzeug abrufen
    val infoResult = j2534.ptGetVehicleInfo(channelID)
    if (infoResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Keine Fahrzeuge gefunden")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }
    Log.i("DoIP", "VIN: ${infoResult.vin}")

    // 5. Parameter konfigurieren und verbinden
    val params = listOf(
        PtConfig(ISO13400_SOURCE_ADDR, 0x0E00u),
        PtConfig(ISO13400_TARGET_ADDR, infoResult.logicalAddr.toUInt()),
        PtConfig(ISO13400_ECU_IP_ADDR, infoResult.ipAddr)
    )
    j2534.ptIoctl(channelID, SET_CONFIG, params.size, params.toByteArray())

    // 6. TCP-Verbindung
    val tcpResult = j2534.ptIoctl(channelID, ISO13400_CONNECT_TCP, 0, null)
    if (tcpResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Fehler bei der TCP-Verbindung")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    // 7. Routing-Aktivierung
    val routingResult = j2534.ptIoctl(channelID, ISO13400_ACTIVATE_ROUTING, 0, null)
    if (routingResult.status != STATUS_NOERROR || routingResult.outputValue != 0x10) {
        Log.e("DoIP", "Aktivierungsfehler: 0x${routingResult.outputValue.toString(16)}")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    Log.i("DoIP", "DoIP-Verbindung hergestellt!")
    return true
}

Beispiel in Python

from ctypes import *

def connect_doip():
    # 1. Gerät öffnen
    device_id = c_ulong()
    ret = j2534.PassThruOpen(None, byref(device_id))
    if ret != 0:
        return False

    # 2. ISO 13400-Kanal öffnen
    channel_id = c_ulong()
    ret = j2534.PassThruConnect(device_id, ISO13400_PS, 0, 0, byref(channel_id))
    if ret != 0:
        j2534.PassThruClose(device_id)
        return False

    # 3. Fahrzeugsuche
    ret = j2534.PassThruIoctl(channel_id, ISO13400_DISCOVER_VEHICLES, None, None)
    if ret != 0:
        print("Fehler bei der Fahrzeugsuche")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 4. Informationen zum gefundenen Fahrzeug abrufen
    vehicle_info = DOIP_VEHICLE_INFO()
    ret = j2534.PassThruIoctl(channel_id, ISO13400_GET_VEHICLE_INFO, None, byref(vehicle_info))
    if ret != 0:
        print("Keine Fahrzeuge gefunden")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False
    print(f"VIN: {vehicle_info.VIN.decode()}")

    # 5. DoIP-Parameter konfigurieren
    config = (SCONFIG * 3)()
    config[0].Parameter = ISO13400_SOURCE_ADDR
    config[0].Value = 0x0E00
    config[1].Parameter = ISO13400_TARGET_ADDR
    config[1].Value = vehicle_info.LogicalAddr
    config[2].Parameter = ISO13400_ECU_IP_ADDR
    config[2].Value = vehicle_info.IPAddr

    config_list = SCONFIG_LIST()
    config_list.NumOfParams = 3
    config_list.ConfigPtr = config

    ret = j2534.PassThruIoctl(channel_id, SET_CONFIG, byref(config_list), None)
    if ret != 0:
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 6. TCP-Verbindung
    ret = j2534.PassThruIoctl(channel_id, ISO13400_CONNECT_TCP, None, None)
    if ret != 0:
        print("Fehler bei der TCP-Verbindung")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 7. Routing-Aktivierung
    activation_type = c_ulong(0)
    response_code = c_ulong(0)
    ret = j2534.PassThruIoctl(channel_id, ISO13400_ACTIVATE_ROUTING, byref(activation_type), byref(response_code))
    if ret != 0 or response_code.value != 0x10:
        print(f"Aktivierungsfehler: 0x{response_code.value:02X}")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    print("DoIP-Verbindung hergestellt!")
    return True

Beispiel in C#

public bool ConnectDoIP()
{
    // 1. Gerät öffnen
    uint deviceId;
    int ret = J2534.PassThruOpen(null, out deviceId);
    if (ret != 0) return false;

    // 2. ISO 13400-Kanal öffnen
    uint channelId;
    ret = J2534.PassThruConnect(deviceId, ISO13400_PS, 0, 0, out channelId);
    if (ret != 0)
    {
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 3. Fahrzeugsuche
    ret = J2534.PassThruIoctl(channelId, ISO13400_DISCOVER_VEHICLES, IntPtr.Zero, IntPtr.Zero);
    if (ret != 0)
    {
        Console.WriteLine("Fehler bei der Fahrzeugsuche");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 4. Informationen zum gefundenen Fahrzeug abrufen
    DOIP_VEHICLE_INFO vehicleInfo;
    ret = J2534.PassThruIoctl(channelId, ISO13400_GET_VEHICLE_INFO, IntPtr.Zero, out vehicleInfo);
    if (ret != 0)
    {
        Console.WriteLine("Keine Fahrzeuge gefunden");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }
    Console.WriteLine($"VIN: {Encoding.ASCII.GetString(vehicleInfo.VIN).TrimEnd('\0')}");

    // 5. DoIP-Parameter konfigurieren
    var configs = new SCONFIG[3];
    configs[0] = new SCONFIG { Parameter = ISO13400_SOURCE_ADDR, Value = 0x0E00 };
    configs[1] = new SCONFIG { Parameter = ISO13400_TARGET_ADDR, Value = vehicleInfo.LogicalAddr };
    configs[2] = new SCONFIG { Parameter = ISO13400_ECU_IP_ADDR, Value = vehicleInfo.IPAddr };

    var configList = new SCONFIG_LIST { NumOfParams = 3, ConfigPtr = configs };
    ret = J2534.PassThruIoctl(channelId, SET_CONFIG, ref configList, IntPtr.Zero);
    if (ret != 0)
    {
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 6. TCP-Verbindung
    ret = J2534.PassThruIoctl(channelId, ISO13400_CONNECT_TCP, IntPtr.Zero, IntPtr.Zero);
    if (ret != 0)
    {
        Console.WriteLine("Fehler bei der TCP-Verbindung");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 7. Routing-Aktivierung
    uint activationType = 0;
    uint responseCode;
    ret = J2534.PassThruIoctl(channelId, ISO13400_ACTIVATE_ROUTING, ref activationType, out responseCode);
    if (ret != 0 || responseCode != 0x10)
    {
        Console.WriteLine($"Aktivierungsfehler: 0x{responseCode:X2}");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    Console.WriteLine("DoIP-Verbindung hergestellt!");
    return true;
}
  1. nach oben