Quantex GmbH
Su región: Europa
  1. Inicio
  2. ScanDoc Development
  3. Guía de J2534
  4. Descripción de las funciones PassThru
  5. PassThruIoctl

DoIP (ISO 13400) Quantex

Diagnóstico por IP

Última modificación:

Descripción

ISO 13400 (DoIP — Diagnostics over IP) — estándar de diagnóstico de automóviles a través de Ethernet. Se utiliza en automóviles modernos para diagnóstico de alta velocidad y actualización de software. ScanDoc admite DoIP mediante un adaptador Ethernet integrado.

Para trabajar con DoIP se requiere un adaptador ScanDoc con soporte de Ethernet (compruébelo con el parámetro ETHERNET_NDIS_SUPPORTED en GET_DEVICE_INFO).

Proceso de conexión DoIP

  1. Abra el canal ISO 13400 mediante PassThruConnect(ISO13400_PS)
  2. Busque vehículos en la red (ISO13400_DISCOVER_VEHICLES) o indique la dirección IP manualmente
  3. Obtenga la información del vehículo encontrado (ISO13400_GET_VEHICLE_INFO)
  4. Configure los parámetros DoIP mediante SET_CONFIG (direcciones SA/TA, dirección IP de la ECU)
  5. Establezca la conexión TCP (ISO13400_CONNECT_TCP)
  6. Active el enrutamiento (ISO13400_ACTIVATE_ROUTING)
  7. Use PassThruReadMsgs/PassThruWriteMsgs para el diagnóstico

Parámetros DoIP (SET_CONFIG)

Antes de usar los comandos DoIP es necesario configurar los parámetros mediante SET_CONFIG.

Parámetro Valor Descripción Por defecto
ISO13400_SOURCE_ADDR 0x8100 Dirección lógica del tester (SA). Normalmente 0x0E00-0x0EFF. 0x0E00
ISO13400_TARGET_ADDR 0x8101 Dirección lógica de la ECU (TA). Depende del vehículo. —
ISO13400_ECU_IP_ADDR 0x8102 Dirección IP de la pasarela/ECU (4 bytes, big-endian) —
ISO13400_ECU_TCP_PORT 0x8103 Puerto TCP para la conexión 13400
ISO13400_T_TCP_INITIAL 0x8104 Tiempo de espera de inactividad hasta routing activation (ms) 2000
ISO13400_T_TCP_GENERAL 0x8105 Tiempo de espera de inactividad TCP general (ms) 300000
ISO13400_T_DIAG_MSG 0x8106 Tiempo de espera de la respuesta de diagnóstico (ms) 2000
ISO13400_ACTIVATION_TYPE 0x8107 Tipo de activación del enrutamiento (0x00 — default, 0x01 — WWH-OBD, 0xE0 — Central Security) 0

Comandos DoIP

ISO13400_DISCOVER_VEHICLES — Búsqueda de vehículos

Envía una solicitud UDP de difusión para detectar vehículos con DoIP en la red local. Los resultados se guardan en un búfer interno y están disponibles mediante ISO13400_GET_VEHICLE_INFO.

IoctlID 0x8110
pInput NULL
pOutput NULL

Ejemplo en C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Obtenido de PassThruConnect para ISO13400_PS
long ret;

ret = PassThruIoctl(ChannelID, ISO13400_DISCOVER_VEHICLES, NULL, NULL);
if (ret == STATUS_NOERROR)
{
    printf("Búsqueda finalizada\n");
}

Ejemplo en Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_DISCOVER_VEHICLES, 0, null)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "Búsqueda finalizada")
}

Ejemplo en Python

ret = j2534.PassThruIoctl(channel_id, ISO13400_DISCOVER_VEHICLES, None, None)
if ret == 0:
    print("Búsqueda finalizada")

Ejemplo en C#

int ret = J2534.PassThruIoctl(channelId, ISO13400_DISCOVER_VEHICLES, IntPtr.Zero, IntPtr.Zero);
if (ret == 0)
    Console.WriteLine("Búsqueda finalizada");

ISO13400_GET_VEHICLE_INFO — Información del vehículo

Devuelve información del vehículo encontrado: VIN, dirección lógica, dirección IP de la pasarela. Se invoca después de ISO13400_DISCOVER_VEHICLES.

IoctlID 0x8111
pInput NULL
pOutput DOIP_VEHICLE_INFO* — estructura con la información del primer vehículo encontrado 
typedef struct {
    char VIN[18];               // Código VIN (17 caracteres + '\0')
    unsigned short LogicalAddr; // Dirección lógica de la pasarela DoIP
    unsigned char EID[6];       // Entity Identification (dirección MAC)
    unsigned char GID[6];       // Group Identification
    unsigned char FurtherAction;// Código de acción adicional (0x00 — ninguna, 0x10 — requiere routing activation)
    unsigned char SyncStatus;   // Estado de sincronización VIN/GID (0x00 — sincronizado, 0x10 — no finalizado)
    unsigned long IPAddr;       // Dirección IPv4 (big-endian)
} DOIP_VEHICLE_INFO;

Ejemplo en C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Obtenido de PassThruConnect para 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("Dirección lógica: 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);
}

Ejemplo en Kotlin (Android)

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

Ejemplo en 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"Dirección lógica: 0x{vehicle_info.LogicalAddr:04X}")
    print(f"IP: {(ip >> 24) & 0xFF}.{(ip >> 16) & 0xFF}.{(ip >> 8) & 0xFF}.{ip & 0xFF}")

Ejemplo en 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($"Dirección lógica: 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 — Conexión TCP

Establece la conexión TCP con la pasarela del vehículo. La dirección IP y el puerto deben estar previamente configurados mediante SET_CONFIG u obtenidos de ISO13400_GET_VEHICLE_INFO.

IoctlID 0x8112
pInput NULL (usa los parámetros de SET_CONFIG) o DOIP_CONNECT_PARAMS*
pOutput NULL

Ejemplo en C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Obtenido de PassThruConnect para ISO13400
long ret;

// Los parámetros ya están configurados mediante SET_CONFIG
ret = PassThruIoctl(ChannelID, ISO13400_CONNECT_TCP, NULL, NULL);
if (ret == STATUS_NOERROR)
{
    printf("Conexión TCP establecida\n");
}
else
{
    char error[256];
    PassThruGetLastError(error);
    printf("Error de conexión: %s\n", error);
}

Ejemplo en Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_CONNECT_TCP, 0, null)
if (result.status == STATUS_NOERROR) {
    Log.i("DoIP", "Conexión TCP establecida")
} else {
    Log.e("DoIP", "Error de conexión TCP: ${result.status}")
}

Ejemplo en Python

ret = j2534.PassThruIoctl(channel_id, ISO13400_CONNECT_TCP, None, None)
if ret == 0:
    print("Conexión TCP establecida")
else:
    print(f"Error de conexión TCP: {ret}")

Ejemplo en C#

int ret = J2534.PassThruIoctl(channelId, ISO13400_CONNECT_TCP, IntPtr.Zero, IntPtr.Zero);
if (ret == 0)
    Console.WriteLine("Conexión TCP establecida");
else
    Console.WriteLine($"Error de conexión TCP: {ret}");

ISO13400_ACTIVATE_ROUTING — Activación del enrutamiento

Envía una solicitud Routing Activation para obtener acceso al diagnóstico. El tipo de activación se define mediante el parámetro ISO13400_ACTIVATION_TYPE.

IoctlID 0x8113
pInput NULL o unsigned long* — tipo de activación (0 — default, 1 — WWH-OBD)
pOutput unsigned long* — código de respuesta de la pasarela

Códigos de respuesta de 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

Ejemplo en 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("Enrutamiento activado correctamente\n");
    else
        printf("Código de respuesta: 0x%02X\n", responseCode);
}

Ejemplo en Kotlin (Android)

val result = j2534.ptIoctl(channelID, ISO13400_ACTIVATE_ROUTING, 0, null)
if (result.status == STATUS_NOERROR) {
    if (result.outputValue == 0x10) {
        Log.i("DoIP", "Enrutamiento activado correctamente")
    } else {
        Log.w("DoIP", "Código de respuesta: 0x${result.outputValue.toString(16)}")
    }
}

Ejemplo en 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("Enrutamiento activado correctamente")
    else:
        print(f"Código de respuesta: 0x{response_code.value:02X}")

Ejemplo en 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("Enrutamiento activado correctamente");
    else
        Console.WriteLine($"Código de respuesta: 0x{responseCode:X2}");
}

Códigos de error devueltos

Código Descripción Posibles causas y soluciones
STATUS_NOERROR Función ejecutada correctamente —
ERR_DEVICE_NOT_CONNECTED Sin conexión con el adaptador
  • El adaptador está apagado o fuera de alcance
  • Solución: compruebe la alimentación y la conexión
ERR_NOT_SUPPORTED DoIP no es compatible
  • El adaptador no dispone de interfaz Ethernet
  • Solución: compruebe ETHERNET_NDIS_SUPPORTED mediante GET_DEVICE_INFO
ERR_TIMEOUT Tiempo de espera de la operación agotado
  • El vehículo no responde a las solicitudes DoIP
  • Dirección IP o puerto incorrectos
  • Solución: compruebe la conexión de red y los parámetros
ERR_INVALID_CHANNEL_ID Identificador de canal no válido
  • ChannelID no se obtuvo mediante PassThruConnect para ISO13400
  • Solución: ejecute PassThruConnect con el protocolo ISO13400_PS
ERR_FAILED Error indeterminado
  • Error de red o rechazo de la pasarela
  • Solución: llame a PassThruGetLastError()

Ejemplo completo de trabajo con DoIP

Ejemplo en C/C++

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

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

    // 1. Abrimos el dispositivo
    ret = PassThruOpen(NULL, &DeviceID);
    if (ret != STATUS_NOERROR) return ret;

    // 2. Comprobamos el soporte de 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 no es compatible\n");
        PassThruClose(DeviceID);
        return -1;
    }

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

    // 4. Búsqueda de vehículos en la red
    ret = PassThruIoctl(ChannelID, ISO13400_DISCOVER_VEHICLES, NULL, NULL);
    if (ret != STATUS_NOERROR)
    {
        printf("Error en la búsqueda de vehículos\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 5. Obtenemos la información del vehículo encontrado
    DOIP_VEHICLE_INFO vehicleInfo;
    ret = PassThruIoctl(ChannelID, ISO13400_GET_VEHICLE_INFO, NULL, &vehicleInfo);
    if (ret != STATUS_NOERROR)
    {
        printf("No se encontraron vehículos\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }
    printf("VIN: %s\n", vehicleInfo.VIN);

    // 6. Configuramos los parámetros 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. Establecemos la conexión TCP
    ret = PassThruIoctl(ChannelID, ISO13400_CONNECT_TCP, NULL, NULL);
    if (ret != STATUS_NOERROR)
    {
        printf("Error de conexión TCP\n");
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    // 8. Activamos el enrutamiento
    unsigned long activationType = 0;
    unsigned long responseCode = 0;
    ret = PassThruIoctl(ChannelID, ISO13400_ACTIVATE_ROUTING, &activationType, &responseCode);
    if (ret != STATUS_NOERROR || responseCode != 0x10)
    {
        printf("Error de activación del enrutamiento: 0x%02X\n", responseCode);
        PassThruDisconnect(ChannelID);
        PassThruClose(DeviceID);
        return ret;
    }

    printf("¡Conexión DoIP establecida!\n");

    // 9. Ahora se pueden enviar solicitudes de diagnóstico
    // mediante PassThruWriteMsgs / PassThruReadMsgs

    // Cerramos la conexión
    PassThruDisconnect(ChannelID);
    PassThruClose(DeviceID);
    return 0;
}

Ejemplo en Kotlin (Android)

suspend fun connectDoIP(): Boolean {
    // 1. Abrimos el dispositivo
    val openResult = j2534.ptOpen(null)
    if (openResult.status != STATUS_NOERROR) return false
    val deviceID = openResult.deviceId

    // 2. Abrimos el canal 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. Búsqueda de vehículos
    val discoverResult = j2534.ptIoctl(channelID, ISO13400_DISCOVER_VEHICLES, 0, null)
    if (discoverResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Error en la búsqueda de vehículos")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    // 4. Obtenemos la información del vehículo encontrado
    val infoResult = j2534.ptGetVehicleInfo(channelID)
    if (infoResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "No se encontraron vehículos")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }
    Log.i("DoIP", "VIN: ${infoResult.vin}")

    // 5. Configuramos los parámetros y nos conectamos
    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. Conexión TCP
    val tcpResult = j2534.ptIoctl(channelID, ISO13400_CONNECT_TCP, 0, null)
    if (tcpResult.status != STATUS_NOERROR) {
        Log.e("DoIP", "Error de conexión TCP")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    // 7. Activación del enrutamiento
    val routingResult = j2534.ptIoctl(channelID, ISO13400_ACTIVATE_ROUTING, 0, null)
    if (routingResult.status != STATUS_NOERROR || routingResult.outputValue != 0x10) {
        Log.e("DoIP", "Error de activación: 0x${routingResult.outputValue.toString(16)}")
        j2534.ptDisconnect(channelID)
        j2534.ptClose(deviceID)
        return false
    }

    Log.i("DoIP", "¡Conexión DoIP establecida!")
    return true
}

Ejemplo en Python

from ctypes import *

def connect_doip():
    # 1. Abrimos el dispositivo
    device_id = c_ulong()
    ret = j2534.PassThruOpen(None, byref(device_id))
    if ret != 0:
        return False

    # 2. Abrimos el canal 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. Búsqueda de vehículos
    ret = j2534.PassThruIoctl(channel_id, ISO13400_DISCOVER_VEHICLES, None, None)
    if ret != 0:
        print("Error en la búsqueda de vehículos")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 4. Obtenemos la información del vehículo encontrado
    vehicle_info = DOIP_VEHICLE_INFO()
    ret = j2534.PassThruIoctl(channel_id, ISO13400_GET_VEHICLE_INFO, None, byref(vehicle_info))
    if ret != 0:
        print("No se encontraron vehículos")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False
    print(f"VIN: {vehicle_info.VIN.decode()}")

    # 5. Configuramos los parámetros 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. Conexión TCP
    ret = j2534.PassThruIoctl(channel_id, ISO13400_CONNECT_TCP, None, None)
    if ret != 0:
        print("Error de conexión TCP")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    # 7. Activación del enrutamiento
    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"Error de activación: 0x{response_code.value:02X}")
        j2534.PassThruDisconnect(channel_id)
        j2534.PassThruClose(device_id)
        return False

    print("¡Conexión DoIP establecida!")
    return True

Ejemplo en C#

public bool ConnectDoIP()
{
    // 1. Abrimos el dispositivo
    uint deviceId;
    int ret = J2534.PassThruOpen(null, out deviceId);
    if (ret != 0) return false;

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

    // 3. Búsqueda de vehículos
    ret = J2534.PassThruIoctl(channelId, ISO13400_DISCOVER_VEHICLES, IntPtr.Zero, IntPtr.Zero);
    if (ret != 0)
    {
        Console.WriteLine("Error en la búsqueda de vehículos");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 4. Obtenemos la información del vehículo encontrado
    DOIP_VEHICLE_INFO vehicleInfo;
    ret = J2534.PassThruIoctl(channelId, ISO13400_GET_VEHICLE_INFO, IntPtr.Zero, out vehicleInfo);
    if (ret != 0)
    {
        Console.WriteLine("No se encontraron vehículos");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }
    Console.WriteLine($"VIN: {Encoding.ASCII.GetString(vehicleInfo.VIN).TrimEnd('\0')}");

    // 5. Configuramos los parámetros 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. Conexión TCP
    ret = J2534.PassThruIoctl(channelId, ISO13400_CONNECT_TCP, IntPtr.Zero, IntPtr.Zero);
    if (ret != 0)
    {
        Console.WriteLine("Error de conexión TCP");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    // 7. Activación del enrutamiento
    uint activationType = 0;
    uint responseCode;
    ret = J2534.PassThruIoctl(channelId, ISO13400_ACTIVATE_ROUTING, ref activationType, out responseCode);
    if (ret != 0 || responseCode != 0x10)
    {
        Console.WriteLine($"Error de activación: 0x{responseCode:X2}");
        J2534.PassThruDisconnect(channelId);
        J2534.PassThruClose(deviceId);
        return false;
    }

    Console.WriteLine("¡Conexión DoIP establecida!");
    return true;
}
  1. arriba