Quantex GmbH
Twój region: Europa
  1. Strona główna
  2. ScanDoc Development
  3. Przewodnik po J2534
  4. Opis funkcji PassThru
  5. PassThruIoctl

DoIP (ISO 13400) Quantex

Diagnostyka przez IP

Ostatnia zmiana:

Opis

ISO 13400 (DoIP — Diagnostics over IP) — standard diagnostyki samochodów przez Ethernet. Stosowany w nowoczesnych samochodach do szybkiej diagnostyki i aktualizacji oprogramowania. ScanDoc obsługuje DoIP poprzez wbudowany adapter Ethernet.

Do pracy z DoIP wymagany jest adapter ScanDoc z obsługą Ethernet (sprawdź za pomocą parametru ETHERNET_NDIS_SUPPORTED w GET_DEVICE_INFO).

Proces nawiązywania połączenia DoIP

  1. Otwórz kanał ISO 13400 przez PassThruConnect(ISO13400_PS)
  2. Wyszukaj pojazdy w sieci (ISO13400_DISCOVER_VEHICLES) lub podaj adres IP ręcznie
  3. Pobierz informacje o znalezionym pojeździe (ISO13400_GET_VEHICLE_INFO)
  4. Skonfiguruj parametry DoIP przez SET_CONFIG (adresy SA/TA, adres IP ECU)
  5. Nawiąż połączenie TCP (ISO13400_CONNECT_TCP)
  6. Aktywuj routing (ISO13400_ACTIVATE_ROUTING)
  7. Użyj PassThruReadMsgs/PassThruWriteMsgs do diagnostyki

Parametry DoIP (SET_CONFIG)

Przed użyciem poleceń DoIP należy skonfigurować parametry przez SET_CONFIG.

Parametr Wartość Opis Domyślnie
ISO13400_SOURCE_ADDR 0x8100 Adres logiczny testera (SA). Zwykle 0x0E00-0x0EFF. 0x0E00
ISO13400_TARGET_ADDR 0x8101 Adres logiczny ECU (TA). Zależy od pojazdu. —
ISO13400_ECU_IP_ADDR 0x8102 Adres IP bramy/ECU (4 bajty, big-endian) —
ISO13400_ECU_TCP_PORT 0x8103 Port TCP do połączenia 13400
ISO13400_T_TCP_INITIAL 0x8104 Limit czasu bezczynności do routing activation (ms) 2000
ISO13400_T_TCP_GENERAL 0x8105 Ogólny limit czasu bezczynności TCP (ms) 300000
ISO13400_T_DIAG_MSG 0x8106 Limit czasu oczekiwania na odpowiedź diagnostyczną (ms) 2000
ISO13400_ACTIVATION_TYPE 0x8107 Typ aktywacji routingu (0x00 — default, 0x01 — WWH-OBD, 0xE0 — Central Security) 0

Polecenia DoIP

ISO13400_DISCOVER_VEHICLES — Wyszukiwanie pojazdów

Wysyła rozgłoszeniowe zapytanie UDP w celu wykrycia pojazdów z DoIP w sieci lokalnej. Wyniki są zapisywane w wewnętrznym buforze i dostępne przez ISO13400_GET_VEHICLE_INFO.

IoctlID 0x8110
pInput NULL
pOutput NULL

Przykład w C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Uzyskany z PassThruConnect dla ISO13400_PS
long ret;

ret = PassThruIoctl(ChannelID, ISO13400_DISCOVER_VEHICLES, NULL, NULL);
if (ret == STATUS_NOERROR)
{
    printf("Wyszukiwanie zakończone\n");
}

Przykład w Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_DISCOVER_VEHICLES, 0, null)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "Wyszukiwanie zakończone")
}

Przykład w Python

ret = j2534.PassThruIoctl(channel_id, ISO13400_DISCOVER_VEHICLES, None, None)
if ret == 0:
    print("Wyszukiwanie zakończone")

Przykład w C#

int ret = J2534.PassThruIoctl(channelId, ISO13400_DISCOVER_VEHICLES, IntPtr.Zero, IntPtr.Zero);
if (ret == 0)
    Console.WriteLine("Wyszukiwanie zakończone");

ISO13400_GET_VEHICLE_INFO — Informacje o pojeździe

Zwraca informacje o znalezionym pojeździe: VIN, adres logiczny, adres IP bramy. Wywoływane po ISO13400_DISCOVER_VEHICLES.

IoctlID 0x8111
pInput NULL
pOutput DOIP_VEHICLE_INFO* — struktura z informacjami o pierwszym znalezionym pojeździe 
typedef struct {
    char VIN[18];               // Kod VIN (17 znaków + '\0')
    unsigned short LogicalAddr; // Adres logiczny bramy DoIP
    unsigned char EID[6];       // Entity Identification (adres MAC)
    unsigned char GID[6];       // Group Identification
    unsigned char FurtherAction;// Kod dalszego działania (0x00 — brak, 0x10 — wymagana routing activation)
    unsigned char SyncStatus;   // Status synchronizacji VIN/GID (0x00 — zsynchronizowano, 0x10 — niezakończono)
    unsigned long IPAddr;       // Adres IPv4 (big-endian)
} DOIP_VEHICLE_INFO;

Przykład w C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Uzyskany z PassThruConnect dla ISO13400_PS
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("Adres logiczny: 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);
}

Przykład w Kotlin (Android)

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

Przykład w 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"Adres logiczny: 0x{vehicle_info.LogicalAddr:04X}")
    print(f"IP: {(ip >> 24) & 0xFF}.{(ip >> 16) & 0xFF}.{(ip >> 8) & 0xFF}.{ip & 0xFF}")

Przykład w 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($"Adres logiczny: 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 — Połączenie TCP

Nawiązuje połączenie TCP z bramą pojazdu. Adres IP i port muszą być wcześniej skonfigurowane przez SET_CONFIG lub uzyskane z ISO13400_GET_VEHICLE_INFO.

IoctlID 0x8112
pInput NULL (używa parametrów z SET_CONFIG) lub DOIP_CONNECT_PARAMS*
pOutput NULL

Przykład w C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Uzyskany z PassThruConnect dla ISO13400
long ret;

// Parametry już skonfigurowane przez SET_CONFIG
ret = PassThruIoctl(ChannelID, ISO13400_CONNECT_TCP, NULL, NULL);
if (ret == STATUS_NOERROR)
{
    printf("Połączenie TCP nawiązane\n");
}
else
{
    char error[256];
    PassThruGetLastError(error);
    printf("Błąd połączenia: %s\n", error);
}

Przykład w Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_CONNECT_TCP, 0, null)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "Połączenie TCP nawiązane")
} else {
    Log.e("DoIP", "Błąd połączenia TCP: ${result.status}")
}

Przykład w Python

ret = j2534.PassThruIoctl(channel_id, ISO13400_CONNECT_TCP, None, None)
if ret == 0:
    print("Połączenie TCP nawiązane")
else:
    print(f"Błąd połączenia TCP: {ret}")

Przykład w C#

int ret = J2534.PassThruIoctl(channelId, ISO13400_CONNECT_TCP, IntPtr.Zero, IntPtr.Zero);
if (ret == 0)
    Console.WriteLine("Połączenie TCP nawiązane");
else
    Console.WriteLine($"Błąd połączenia TCP: {ret}");

ISO13400_ACTIVATE_ROUTING — Aktywacja routingu

Wysyła żądanie Routing Activation w celu uzyskania dostępu do diagnostyki. Typ aktywacji jest określany parametrem ISO13400_ACTIVATION_TYPE.

IoctlID 0x8113
pInput NULL lub unsigned long* — typ aktywacji (0 — default, 1 — WWH-OBD)
pOutput unsigned long* — kod odpowiedzi od bramy

Kody odpowiedzi Routing Activation (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

Przykład w 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 aktywowany pomyślnie\n");
    else
        printf("Kod odpowiedzi: 0x%02X\n", responseCode);
}

Przykład w 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 aktywowany pomyślnie")
    } else {
        Log.w("DoIP", "Kod odpowiedzi: 0x${result.outputValue.toString(16)}")
    }
}

Przykład w 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 aktywowany pomyślnie")
    else:
        print(f"Kod odpowiedzi: 0x{response_code.value:02X}")

Przykład w 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 aktywowany pomyślnie");
    else
        Console.WriteLine($"Kod odpowiedzi: 0x{responseCode:X2}");
}

Zwracane kody błędów

Kod Opis Możliwe przyczyny i rozwiązania
STATUS_NOERROR Funkcja wykonana pomyślnie —
ERR_DEVICE_NOT_CONNECTED Brak połączenia z adapterem
  • Adapter wyłączony lub poza zasięgiem
  • Rozwiązanie: sprawdź zasilanie i połączenie
ERR_NOT_SUPPORTED DoIP nie jest obsługiwane
  • Adapter nie ma interfejsu Ethernet
  • Rozwiązanie: sprawdź ETHERNET_NDIS_SUPPORTED przez GET_DEVICE_INFO
ERR_TIMEOUT Limit czasu operacji
  • Pojazd nie odpowiada na żądania DoIP
  • Nieprawidłowy adres IP lub port
  • Rozwiązanie: sprawdź połączenie sieciowe i parametry
ERR_INVALID_CHANNEL_ID Nieprawidłowy identyfikator kanału
  • ChannelID nie został uzyskany przez PassThruConnect dla ISO13400
  • Rozwiązanie: wykonaj PassThruConnect z protokołem ISO13400_PS
ERR_FAILED Nieokreślony błąd
  • Błąd sieci lub odmowa bramy
  • Rozwiązanie: wywołaj PassThruGetLastError()

Pełny przykład pracy z DoIP

Przykład w C/C++

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

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

    // 1. Otwieramy urządzenie
    ret = PassThruOpen(NULL, &DeviceID);
    if (ret != STATUS_NOERROR) return ret;

    // 2. Sprawdzamy obsługę Ethernet
    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 nie jest obsługiwane\n");
        PassThruClose(DeviceID);
        return -1;
    }

    // 3. Otwieramy kanał ISO 13400
    ret = PassThruConnect(DeviceID, ISO13400_PS, 0, 0, &ChannelID);
    if (ret != STATUS_NOERROR)
    {
        PassThruClose(DeviceID);
        return ret;
    }

    // 4. Wyszukiwanie pojazdów w sieci
    ret = PassThruIoctl(ChannelID, ISO13400_DISCOVER_VEHICLES, NULL, NULL);
    if (ret != STATUS_NOERROR)
    {
        printf("Błąd wyszukiwania pojazdów\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 5. Pobieramy informacje o znalezionym pojeździe
    DOIP_VEHICLE_INFO vehicleInfo;
    ret = PassThruIoctl(ChannelID, ISO13400_GET_VEHICLE_INFO, NULL, &vehicleInfo);
    if (ret != STATUS_NOERROR)
    {
        printf("Nie znaleziono pojazdów\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }
    printf("VIN: %s\n", vehicleInfo.VIN);

    // 6. Konfigurujemy parametry DoIP
    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. Nawiązujemy połączenie TCP
    ret = PassThruIoctl(ChannelID, ISO13400_CONNECT_TCP, NULL, NULL);
    if (ret != STATUS_NOERROR)
    {
        printf("Błąd połączenia TCP\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 8. Aktywujemy routing
    unsigned long activationType = 0;
    unsigned long responseCode = 0;
    ret = PassThruIoctl(ChannelID, ISO13400_ACTIVATE_ROUTING, &activationType, &responseCode);
    if (ret != STATUS_NOERROR || responseCode != 0x10)
    {
        printf("Błąd aktywacji routingu: 0x%02X\n", responseCode);
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    printf("Połączenie DoIP nawiązane!\n");

    // 9. Teraz można wysyłać żądania diagnostyczne
    // przez PassThruWriteMsgs / PassThruReadMsgs

    // Zamykamy połączenie
    PassThruDisconnect(ChannelID);
    PassThruClose(DeviceID);
    return 0;
}

Przykład w Kotlin (Android)

suspend fun connectDoIP(): Boolean {
    // 1. Otwieramy urządzenie
    val openResult = j2534.ptOpen(null)
    if (openResult.status != STATUS_NOERROR) return false
    val deviceID = openResult.deviceId

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

    // 3. Wyszukiwanie pojazdów
    val discoverResult = j2534.ptIoctl(channelID, ISO13400_DISCOVER_VEHICLES, 0, null)
    if (discoverResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Błąd wyszukiwania pojazdów")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    // 4. Pobieramy informacje o znalezionym pojeździe
    val infoResult = j2534.ptGetVehicleInfo(channelID)
    if (infoResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Nie znaleziono pojazdów")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }
    Log.i("DoIP", "VIN: ${infoResult.vin}")

    // 5. Konfigurujemy parametry i łączymy się
    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. Połączenie TCP
    val tcpResult = j2534.ptIoctl(channelID, ISO13400_CONNECT_TCP, 0, null)
    if (tcpResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Błąd połączenia TCP")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    // 7. Aktywacja routingu
    val routingResult = j2534.ptIoctl(channelID, ISO13400_ACTIVATE_ROUTING, 0, null)
    if (routingResult.status != STATUS_NOERROR || routingResult.outputValue != 0x10) {
        Log.e("DoIP", "Błąd aktywacji: 0x${routingResult.outputValue.toString(16)}")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    Log.i("DoIP", "Połączenie DoIP nawiązane!")
    return true
}

Przykład w Python

from ctypes import *

def connect_doip():
    # 1. Otwieramy urządzenie
    device_id = c_ulong()
    ret = j2534.PassThruOpen(None, byref(device_id))
    if ret != 0:
        return False

    # 2. Otwieramy kanał ISO 13400
    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. Wyszukiwanie pojazdów
    ret = j2534.PassThruIoctl(channel_id, ISO13400_DISCOVER_VEHICLES, None, None)
    if ret != 0:
        print("Błąd wyszukiwania pojazdów")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 4. Pobieramy informacje o znalezionym pojeździe
    vehicle_info = DOIP_VEHICLE_INFO()
    ret = j2534.PassThruIoctl(channel_id, ISO13400_GET_VEHICLE_INFO, None, byref(vehicle_info))
    if ret != 0:
        print("Nie znaleziono pojazdów")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False
    print(f"VIN: {vehicle_info.VIN.decode()}")

    # 5. Konfigurujemy parametry DoIP
    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. Połączenie TCP
    ret = j2534.PassThruIoctl(channel_id, ISO13400_CONNECT_TCP, None, None)
    if ret != 0:
        print("Błąd połączenia TCP")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 7. Aktywacja routingu
    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"Błąd aktywacji: 0x{response_code.value:02X}")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    print("Połączenie DoIP nawiązane!")
    return True

Przykład w C#

public bool ConnectDoIP()
{
    // 1. Otwieramy urządzenie
    uint deviceId;
    int ret = J2534.PassThruOpen(null, out deviceId);
    if (ret != 0) return false;

    // 2. Otwieramy kanał ISO 13400
    uint channelId;
    ret = J2534.PassThruConnect(deviceId, ISO13400_PS, 0, 0, out channelId);
    if (ret != 0)
    {
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 3. Wyszukiwanie pojazdów
    ret = J2534.PassThruIoctl(channelId, ISO13400_DISCOVER_VEHICLES, IntPtr.Zero, IntPtr.Zero);
    if (ret != 0)
    {
        Console.WriteLine("Błąd wyszukiwania pojazdów");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 4. Pobieramy informacje o znalezionym pojeździe
    DOIP_VEHICLE_INFO vehicleInfo;
    ret = J2534.PassThruIoctl(channelId, ISO13400_GET_VEHICLE_INFO, IntPtr.Zero, out vehicleInfo);
    if (ret != 0)
    {
        Console.WriteLine("Nie znaleziono pojazdów");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }
    Console.WriteLine($"VIN: {Encoding.ASCII.GetString(vehicleInfo.VIN).TrimEnd('\0')}");

    // 5. Konfigurujemy parametry DoIP
    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. Połączenie TCP
    ret = J2534.PassThruIoctl(channelId, ISO13400_CONNECT_TCP, IntPtr.Zero, IntPtr.Zero);
    if (ret != 0)
    {
        Console.WriteLine("Błąd połączenia TCP");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 7. Aktywacja routingu
    uint activationType = 0;
    uint responseCode;
    ret = J2534.PassThruIoctl(channelId, ISO13400_ACTIVATE_ROUTING, ref activationType, out responseCode);
    if (ret != 0 || responseCode != 0x10)
    {
        Console.WriteLine($"Błąd aktywacji: 0x{responseCode:X2}");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    Console.WriteLine("Połączenie DoIP nawiązane!");
    return true;
}
  1. do góry