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

GET_DEVICE_INFO / GET_PROTOCOL_INFO J2534-2

Informacje o urządzeniu

Ostatnia zmiana:

GET_DEVICE_INFO — Informacje o urządzeniu

Zwraca informacje o możliwościach urządzenia: obsługiwane protokoły, liczbę jednoczesnych kanałów, numer seryjny i inne właściwości. Wywoływana z DeviceID uzyskanym od PassThruOpen.

IoctlID 0x800C
pInput SCONFIG_LIST* — lista żądanych parametrów
pOutput NULL (wynik zapisywany jest w pInput)
W odróżnieniu od GET_CONFIG, funkcja GET_DEVICE_INFO wywoływana jest z DeviceID, a nie z ChannelID.

GET_PROTOCOL_INFO — Informacje o protokole

Zwraca informacje o możliwościach konkretnego protokołu: maksymalne rozmiary buforów, liczbę filtrów, obsługiwane parametry. Wywoływana z ChannelID uzyskanym od PassThruConnect.

IoctlID 0x800D
pInput SCONFIG_LIST* — lista żądanych parametrów
pOutput NULL (wynik zapisywany jest w pInput)

Struktury danych

typedef struct {
    unsigned long Parameter;  // Identyfikator parametru
    unsigned long Value;      // Zwracana wartość
} SCONFIG;

typedef struct {
    unsigned long NumOfParams;  // Liczba parametrów na liście
    SCONFIG *ConfigPtr;         // Wskaźnik na tablicę SCONFIG
} SCONFIG_LIST;

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_INVALID_DEVICE_ID Nieprawidłowy identyfikator urządzenia
  • DeviceID nie został uzyskany przez PassThruOpen
  • Rozwiązanie: wykonaj PassThruOpen
ERR_INVALID_CHANNEL_ID Nieprawidłowy identyfikator kanału
  • ChannelID nie został uzyskany przez PassThruConnect (dla GET_PROTOCOL_INFO)
  • Rozwiązanie: wykonaj PassThruConnect
ERR_NULL_PARAMETER Przekazano NULL zamiast wskaźnika
  • pInput jest równy NULL
  • Rozwiązanie: przekaż wskaźnik na SCONFIG_LIST
ERR_NOT_SUPPORTED Parametr nieobsługiwany
  • Żądany parametr jest niedostępny
  • Rozwiązanie: sprawdź listę obsługiwanych parametrów
ERR_FAILED Nieokreślony błąd
  • Błąd wewnętrzny
  • Rozwiązanie: wywołaj PassThruGetLastError()

Parametry GET_DEVICE_INFO

Identyfikacja urządzenia

Parametr Wartość Opis
SERIAL_NUMBER 0x01 Numer seryjny urządzenia (ciąg znaków)
PART_NUMBER 0x49 Numer katalogowy urządzenia

Obsługa protokołów

Zwracają SUPPORTED (1) lub NOT_SUPPORTED (0).

Parametr Wartość Protokół
J1850PWM_SUPPORTED 0x02 J1850 PWM (Ford)
J1850VPW_SUPPORTED 0x03 J1850 VPW (GM)
ISO9141_SUPPORTED 0x04 ISO 9141-2
ISO14230_SUPPORTED 0x05 ISO 14230 (KWP2000)
CAN_SUPPORTED 0x06 CAN (raw)
ISO15765_SUPPORTED 0x07 ISO 15765 (CAN UDS)
SCI_A_ENGINE_SUPPORTED 0x08 SCI-A Engine (Chrysler)
SCI_A_TRANS_SUPPORTED 0x09 SCI-A Transmission (Chrysler)
SCI_B_ENGINE_SUPPORTED 0x0A SCI-B Engine (Chrysler)
SCI_B_TRANS_SUPPORTED 0x0B SCI-B Transmission (Chrysler)
SW_ISO15765_SUPPORTED 0x0C Single-Wire ISO 15765
SW_CAN_SUPPORTED 0x0D Single-Wire CAN (GM)
GM_UART_SUPPORTED 0x0E GM UART
UART_ECHO_BYTE_SUPPORTED 0x0F UART Echo Byte
HONDA_DIAGH_SUPPORTED 0x10 Honda DIAG-H
J1939_SUPPORTED 0x11 J1939 (pojazdy ciężarowe)
J1708_SUPPORTED 0x12 J1708 (pojazdy ciężarowe)
TP2_0_SUPPORTED 0x13 TP 2.0 (VAG)
J2610_SUPPORTED 0x14 J2610 (Chrysler DRB-III)
ANALOG_IN_SUPPORTED 0x15 Wejścia analogowe
FT_CAN_SUPPORTED 0x31 Fault-Tolerant CAN
FT_ISO15765_SUPPORTED 0x32 FT ISO 15765
FD_CAN_SUPPORTED 0x4C CAN FD
FD_ISO15765_SUPPORTED 0x4D ISO 15765 przez CAN FD
ETHERNET_NDIS_SUPPORTED 0x54 Ethernet NDIS (DoIP)

Jednoczesne kanały

Liczba kanałów, które mogą być otwarte jednocześnie dla każdego protokołu.

Parametr Wartość Protokół
J1850PWM_SIMULTANEOUS 0x35 J1850 PWM
J1850VPW_SIMULTANEOUS 0x36 J1850 VPW
ISO9141_SIMULTANEOUS 0x37 ISO 9141
ISO14230_SIMULTANEOUS 0x38 ISO 14230
CAN_SIMULTANEOUS 0x39 CAN
ISO15765_SIMULTANEOUS 0x3A ISO 15765
SW_CAN_SIMULTANEOUS 0x40 SW-CAN
J1939_SIMULTANEOUS 0x44 J1939
TP2_0_SIMULTANEOUS 0x46 TP 2.0
FD_CAN_SIMULTANEOUS 0x4E CAN FD
FD_ISO15765_SIMULTANEOUS 0x4F ISO 15765 FD

Przypisanie styków J1962

Zwracają maskę styków OBD-II używanych dla protokołu.

Parametr Wartość Protokół
CAN_PS_J1962 0x1F CAN (Pin 6, 14)
ISO15765_PS_J1962 0x20 ISO 15765 (Pin 6, 14)
ISO9141_PS_K_LINE_J1962 0x1B ISO 9141 K-Line (Pin 7)
ISO9141_PS_L_LINE_J1962 0x1C ISO 9141 L-Line (Pin 15)
ISO14230_PS_K_LINE_J1962 0x1D ISO 14230 K-Line (Pin 7)
ISO14230_PS_L_LINE_J1962 0x1E ISO 14230 L-Line (Pin 15)
SW_CAN_PS_J1962 0x21 SW-CAN (Pin 1)
J1850PWM_PS_J1962 0x19 J1850 PWM (Pin 2, 10)
J1850VPW_PS_J1962 0x1A J1850 VPW (Pin 2)
FD_CAN_PS_J1962 0x50 CAN FD (Pin 6, 14)
FD_ISO15765_PS_J1962 0x51 ISO 15765 FD (Pin 6, 14)

Dodatkowe możliwości

Parametr Wartość Opis
MAX_NON_VOLATILE_STORAGE 0x16 Rozmiar pamięci nieulotnej (bajty)
SHORT_TO_GND_J1962 0x17 Obsługa wykrywania zwarcia do masy
PGM_VOLTAGE_J1962 0x18 Obsługa napięcia programowania
READ_J1962PIN_VOLTAGE_SUPPORTED 0x52 Obsługa odczytu napięcia na stykach
READ_J1962PIN_VOLTAGE_MAX 0x53 Maksymalne napięcie do odczytu (mV)

Parametry GET_PROTOCOL_INFO

Parametr Wartość Opis
MAX_RX_BUFFER_SIZE 0x01 Maksymalny rozmiar bufora odbiorczego (bajty)
MAX_PASS_FILTER 0x02 Maksymalna liczba PASS_FILTER
MAX_BLOCK_FILTER 0x03 Maksymalna liczba BLOCK_FILTER
MAX_FILTER_MSG_LENGTH 0x04 Maksymalna długość komunikatu filtra (bajty)
MAX_PERIODIC_MSGS 0x05 Maksymalna liczba komunikatów okresowych
MAX_PERIODIC_MSG_LENGTH 0x06 Maksymalna długość komunikatu okresowego (bajty)
DESIRED_DATA_RATE 0x07 Zalecana szybkość transmisji (bit/s)
MAX_FLOW_CONTROL_FILTER 0x12 Maksymalna liczba FLOW_CONTROL_FILTER
MAX_ISO15765_WFT_MAX 0x13 Maksymalna wartość ISO15765_WFT_MAX
NETWORK_LINE_SUPPORTED 0x0A Obsługa wyboru linii sieciowej
MAX_FUNCT_MSG_LOOKUP 0x0B Maksymalny rozmiar tablicy adresów funkcjonalnych
PARITY_SUPPORTED 0x0C Obsługa konfiguracji parzystości
DATA_BITS_SUPPORTED 0x0D Obsługa konfiguracji bitów danych (7/8)
FIVE_BAUD_MOD_SUPPORTED 0x0E Obsługa trybów inicjalizacji 5-bodowej
L_LINE_SUPPORTED 0x0F Obsługa linii L
CAN_11_29_IDS_SUPPORTED 0x10 Obsługa 11-bitowych i 29-bitowych CAN ID
CAN_MIXED_FORMAT_SUPPORTED 0x11 Obsługa mieszanego formatu CAN
TIMESTAMP_RESOLUTION 0x1B Rozdzielczość znaczników czasu (μs)
FD_CAN_DATA_PHASE_DATA_RATE_SUPPORTED 0x6C Obsługiwane szybkości CAN FD

Przykłady

GET_DEVICE_INFO — uzyskanie możliwości urządzenia

Przykład w C/C++

#include "j2534_dll.hpp"

unsigned long DeviceID;  // Uzyskany od PassThruOpen
SCONFIG Config[5];
SCONFIG_LIST ConfigList;
long ret;

// Żądamy informacji o obsłudze protokołów
Config[0].Parameter = CAN_SUPPORTED;
Config[1].Parameter = ISO15765_SUPPORTED;
Config[2].Parameter = ISO14230_SUPPORTED;
Config[3].Parameter = FD_CAN_SUPPORTED;
Config[4].Parameter = TP2_0_SUPPORTED;

ConfigList.NumOfParams = 5;
ConfigList.ConfigPtr = Config;

ret = PassThruIoctl(DeviceID, GET_DEVICE_INFO, &ConfigList, NULL);
if (ret == STATUS_NOERROR)
{
    printf("CAN: %s\n", Config[0].Value ? "obsługiwany" : "nie");
    printf("ISO 15765: %s\n", Config[1].Value ? "obsługiwany" : "nie");
    printf("ISO 14230: %s\n", Config[2].Value ? "obsługiwany" : "nie");
    printf("CAN FD: %s\n", Config[3].Value ? "obsługiwany" : "nie");
    printf("TP 2.0: %s\n", Config[4].Value ? "obsługiwany" : "nie");
}

Przykład w Kotlin (Android)

// deviceID uzyskany od ptOpen
val params = listOf(
    PtConfig(parameter = CAN_SUPPORTED, value = 0u),
    PtConfig(parameter = ISO15765_SUPPORTED, value = 0u),
    PtConfig(parameter = FD_CAN_SUPPORTED, value = 0u)
)

val result = j2534.ptIoctl(deviceID, GET_DEVICE_INFO, params.size, params.toByteArray())
if (result.status == STATUS_NOERROR) {
    val resultParams = result.toConfigList()
    Log.i("J2534", "CAN: ${if (resultParams[0].value > 0u) "tak" else "nie"}")
    Log.i("J2534", "ISO 15765: ${if (resultParams[1].value > 0u) "tak" else "nie"}")
    Log.i("J2534", "CAN FD: ${if (resultParams[2].value > 0u) "tak" else "nie"}")
}

Przykład w Python

from ctypes import *

config = (SCONFIG * 3)()
config[0].Parameter = CAN_SUPPORTED
config[1].Parameter = ISO15765_SUPPORTED
config[2].Parameter = FD_CAN_SUPPORTED

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

ret = j2534.PassThruIoctl(device_id, GET_DEVICE_INFO, byref(config_list), None)
if ret == 0:
    print(f"CAN: {'tak' if config[0].Value else 'nie'}")
    print(f"ISO 15765: {'tak' if config[1].Value else 'nie'}")
    print(f"CAN FD: {'tak' if config[2].Value else 'nie'}")

Przykład w C#

var configs = new SCONFIG[3];
configs[0].Parameter = CAN_SUPPORTED;
configs[1].Parameter = ISO15765_SUPPORTED;
configs[2].Parameter = FD_CAN_SUPPORTED;

var configList = new SCONFIG_LIST {
    NumOfParams = 3,
    ConfigPtr = configs
};

int ret = J2534.PassThruIoctl(deviceId, GET_DEVICE_INFO, ref configList, IntPtr.Zero);
if (ret == 0)
{
    Console.WriteLine($"CAN: {(configs[0].Value > 0 ? "tak" : "nie")}");
    Console.WriteLine($"ISO 15765: {(configs[1].Value > 0 ? "tak" : "nie")}");
    Console.WriteLine($"CAN FD: {(configs[2].Value > 0 ? "tak" : "nie")}");
}

GET_PROTOCOL_INFO — uzyskanie informacji o protokole

Przykład w C/C++

#include "j2534_dll.hpp"

unsigned long ChannelID;  // Uzyskany od PassThruConnect dla ISO15765
SCONFIG Config[4];
SCONFIG_LIST ConfigList;
long ret;

// Żądamy limitów protokołu
Config[0].Parameter = MAX_RX_BUFFER_SIZE;
Config[1].Parameter = MAX_FLOW_CONTROL_FILTER;
Config[2].Parameter = MAX_PERIODIC_MSGS;
Config[3].Parameter = TIMESTAMP_RESOLUTION;

ConfigList.NumOfParams = 4;
ConfigList.ConfigPtr = Config;

ret = PassThruIoctl(ChannelID, GET_PROTOCOL_INFO, &ConfigList, NULL);
if (ret == STATUS_NOERROR)
{
    printf("Maks. rozmiar bufora RX: %lu bajtów\n", Config[0].Value);
    printf("Maks. filtrów FLOW_CONTROL: %lu\n", Config[1].Value);
    printf("Maks. komunikatów okresowych: %lu\n", Config[2].Value);
    printf("Rozdzielczość timestamp: %lu μs\n", Config[3].Value);
}

Przykład w Kotlin (Android)

// channelID uzyskany od ptConnect
val params = listOf(
    PtConfig(parameter = MAX_RX_BUFFER_SIZE, value = 0u),
    PtConfig(parameter = MAX_FLOW_CONTROL_FILTER, value = 0u),
    PtConfig(parameter = MAX_PERIODIC_MSGS, value = 0u)
)

val result = j2534.ptIoctl(channelID, GET_PROTOCOL_INFO, params.size, params.toByteArray())
if (result.status == STATUS_NOERROR) {
    val resultParams = result.toConfigList()
    Log.i("J2534", "Maks. bufor RX: ${resultParams[0].value} bajtów")
    Log.i("J2534", "Maks. filtrów FC: ${resultParams[1].value}")
    Log.i("J2534", "Maks. okresowych: ${resultParams[2].value}")
}

Przykład w Python

from ctypes import *

config = (SCONFIG * 3)()
config[0].Parameter = MAX_RX_BUFFER_SIZE
config[1].Parameter = MAX_FLOW_CONTROL_FILTER
config[2].Parameter = MAX_PERIODIC_MSGS

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

ret = j2534.PassThruIoctl(channel_id, GET_PROTOCOL_INFO, byref(config_list), None)
if ret == 0:
    print(f"Maks. bufor RX: {config[0].Value} bajtów")
    print(f"Maks. filtrów FC: {config[1].Value}")
    print(f"Maks. okresowych: {config[2].Value}")

Pełne sprawdzenie możliwości urządzenia

Przykład w C/C++

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

void PrintDeviceCapabilities(unsigned long DeviceID)
{
    // Lista wszystkich protokołów do sprawdzenia
    struct {
        unsigned long param;
        const char* name;
    } protocols[] = {
        {CAN_SUPPORTED, "CAN"},
        {ISO15765_SUPPORTED, "ISO 15765"},
        {ISO14230_SUPPORTED, "ISO 14230 (KWP2000)"},
        {ISO9141_SUPPORTED, "ISO 9141"},
        {J1850PWM_SUPPORTED, "J1850 PWM"},
        {J1850VPW_SUPPORTED, "J1850 VPW"},
        {FD_CAN_SUPPORTED, "CAN FD"},
        {FD_ISO15765_SUPPORTED, "ISO 15765 FD"},
        {TP2_0_SUPPORTED, "TP 2.0 (VAG)"},
        {J1939_SUPPORTED, "J1939"},
        {SW_CAN_SUPPORTED, "Single-Wire CAN"}
    };

    const int count = sizeof(protocols) / sizeof(protocols[0]);
    SCONFIG* config = new SCONFIG[count];
    SCONFIG_LIST configList;

    for (int i = 0; i < count; i++) {
        config[i].Parameter = protocols[i].param;
        config[i].Value = 0;
    }

    configList.NumOfParams = count;
    configList.ConfigPtr = config;

    long ret = PassThruIoctl(DeviceID, GET_DEVICE_INFO, &configList, NULL);
    if (ret == STATUS_NOERROR) {
        printf("=== Obsługiwane protokoły ===\n");
        for (int i = 0; i < count; i++) {
            printf("%-20s: %s\n", protocols[i].name,
                   config[i].Value ? "Tak" : "Nie");
        }
    }

    delete[] config;
}
  1. do góry