PassThruGetNextDevice v5.0

Pobranie informacji o urządzeniu

Ostatnia zmiana: 13 stycznia 2026 r.

Opis

Funkcja kolejno zwraca informacje o urządzeniach znalezionych podczas ostatniego wywołania PassThruScanForDevices(). Przy każdym wywołaniu zwracane są informacje o następnym urządzeniu z listy. Kolejność urządzeń może się różnić przy każdym nowym skanowaniu.

long PassThruGetNextDevice(SDEVICE* psDevice)

Uwaga: Przed użyciem tej funkcji nie jest wymagane wywołanie PassThruOpen(). Wystarczy wcześniej wywołać PassThruScanForDevices().

Parametry

psDevice - Wskaźnik na strukturę SDEVICE przydzieloną przez aplikację. Po pomyślnym wykonaniu funkcji struktura zostanie wypełniona informacjami o urządzeniu.

Struktura SDEVICE

typedef struct {
    char          DeviceName[80];       // Nazwa urządzenia (ASCII, zakończona znakiem null)
    unsigned long DeviceAvailable;      // Stan dostępności urządzenia
    unsigned long DeviceDLLFWStatus;    // Zgodność DLL i firmware
    unsigned long DeviceConnectMedia;   // Typ połączenia (przewodowe/bezprzewodowe)
    unsigned long DeviceConnectSpeed;   // Prędkość połączenia (bit/s)
    unsigned long DeviceSignalQuality;  // Jakość sygnału (0-100%, 0xFFFFFFFF jeśli nieznana)
    unsigned long DeviceSignalStrength; // Poziom sygnału (0-100%, 0xFFFFFFFF jeśli nieznany)
} SDEVICE;

Opis pól struktury

Pole	Opis
DeviceName	Łańcuch ASCII z nazwą urządzenia (do 80 znaków włącznie ze znakiem NULL kończącym). Nazwa jest przeznaczona do wyświetlenia użytkownikowi i powinna jednoznacznie identyfikować urządzenie. Przykłady: `"ScanDoc FD #N4999"`, `"ScanDoc PRO (WLAN)"`
DeviceAvailable	Stan dostępności urządzenia. Zobacz tabelę wartości
DeviceDLLFWStatus	Status zgodności DLL i firmware urządzenia. Zobacz tabelę wartości
DeviceConnectMedia	Typ połączenia z urządzeniem. Zobacz tabelę wartości
DeviceConnectSpeed	Prędkość połączenia z urządzeniem w bitach na sekundę
DeviceSignalQuality	Jakość sygnału od 0 do 100%. Wartość `0xFFFFFFFF` jeśli nie została określona
DeviceSignalStrength	Poziom sygnału od 0 do 100%. Wartość `0xFFFFFFFF` jeśli nie został określony

Wartości DeviceAvailable

Stała	Wartość	Opis
DEVICE_STATE_UNKNOWN	0	Nie udało się określić stanu urządzenia
DEVICE_AVAILABLE	1	Urządzenie jest wolne i gotowe do połączenia
DEVICE_IN_USE	2	Urządzenie jest już używane (otwarte przez inną aplikację)

Wartości DeviceDLLFWStatus

Stała	Wartość	Opis
DEVICE_DLL_FW_COMPATIBILTY_UNKNOWN	0	Nie udało się określić zgodności DLL i firmware
DEVICE_DLL_FW_COMPATIBLE	1	DLL i firmware są zgodne
DEVICE_DLL_OR_FW_NOT_COMPATIBLE	2	DLL lub firmware są przestarzałe albo niezgodne
DEVICE_DLL_NOT_COMPATIBLE	3	DLL jest przestarzała lub niezgodna z urządzeniem
DEVICE_FW_NOT_COMPATIBLE	4	Firmware urządzenia jest przestarzałe lub niezgodne z DLL

Wartości DeviceConnectMedia

Stała	Wartość	Opis
DEVICE_CONN_UNKNOWN	0	Nie udało się określić typu połączenia
DEVICE_CONN_WIRELESS	1	Połączenie bezprzewodowe (WLAN, BLE)
DEVICE_CONN_WIRED	2	Połączenie przewodowe (USB, Ethernet)

Kolejność wywoływania funkcji

PassThruScanForDevices(&count)  → Pobierz liczbę urządzeń
    ↓
for (i = 0; i < count; i++) {
    PassThruGetNextDevice(&device) → Pobierz informacje o urządzeniu
}
    ↓
PassThruOpen(deviceName)        → Otwórz wybrane urządzenie

Ważne: Aplikacja nie musi wywoływać PassThruGetNextDevice() dla wszystkich urządzeń. Przeglądanie można przerwać w dowolnym momencie. Jednak kolejne wywołania będą nadal zwracać pozostałe urządzenia aż do końca listy, wyładowania DLL lub nowego wywołania PassThruScanForDevices().

Zwracane kody błędów

Kod	Opis	Możliwe przyczyny i rozwiązania
STATUS_NOERROR	Funkcja wykonana pomyślnie	Struktura `psDevice` została wypełniona informacjami o urządzeniu
ERR_NULL_PARAMETER	Nie podano wskaźnika psDevice	Przekaż prawidłowy wskaźnik na strukturę `SDEVICE`
ERR_EXCEEDED_LIMIT	Wszystkie urządzenia zostały już wyliczone	Informacje o wszystkich znalezionych urządzeniach zostały już zwrócone Rozwiązanie: wywołaj `PassThruScanForDevices()` aby przeprowadzić nowe skanowanie
ERR_BUFFER_EMPTY	Lista urządzeń jest pusta	`PassThruScanForDevices()` nie znalazła żadnych urządzeń `PassThruScanForDevices()` nie została wywołana Rozwiązanie: wywołaj `PassThruScanForDevices()` i sprawdź `pDeviceCount`
ERR_CONCURRENT_API_CALL	Funkcja J2534 API jest już wykonywana	Inna funkcja J2534 jeszcze nie zakończyła wykonywania Rozwiązanie: poczekaj na zakończenie poprzedniego wywołania
ERR_NOT_SUPPORTED	Funkcja nie jest obsługiwana	DLL nie obsługuje dynamicznego wyliczania urządzeń Rozwiązanie: użyj `PassThruOpen()` bezpośrednio
ERR_FAILED	Błąd wewnętrzny	Użyj `PassThruGetLastError()` aby uzyskać szczegóły

Przykłady

Przykład w C/C++

#include "j2534_dll.hpp"

unsigned long deviceCount = 0;

// Skanujemy urządzenia
long ret = PassThruScanForDevices(&deviceCount);
if (ret != STATUS_NOERROR || deviceCount == 0)
{
    printf("Nie znaleziono urządzeń\n");
    return;
}

printf("Znaleziono urządzeń: %lu\n", deviceCount);

// Przeglądamy wszystkie znalezione urządzenia
SDEVICE device;
for (unsigned long i = 0; i < deviceCount; i++)
{
    ret = PassThruGetNextDevice(&device);
    if (ret != STATUS_NOERROR)
    {
        break;
    }

    printf("\nUrządzenie %lu:\n", i + 1);
    printf("  Nazwa: %s\n", device.DeviceName);
    printf("  Dostępne: %s\n",
        device.DeviceAvailable == DEVICE_AVAILABLE ? "Tak" :
        device.DeviceAvailable == DEVICE_IN_USE ? "Zajęte" : "Nieznane");
    printf("  Zgodność: %s\n",
        device.DeviceDLLFWStatus == DEVICE_DLL_FW_COMPATIBLE ? "OK" : "Wymagana aktualizacja");
    printf("  Połączenie: %s\n",
        device.DeviceConnectMedia == DEVICE_CONN_WIRELESS ? "Bezprzewodowe" :
        device.DeviceConnectMedia == DEVICE_CONN_WIRED ? "Przewodowe" : "Nieznane");

    if (device.DeviceSignalStrength != 0xFFFFFFFF)
    {
        printf("  Poziom sygnału: %lu%%\n", device.DeviceSignalStrength);
    }
}

// Łączymy się z pierwszym dostępnym urządzeniem
// (w rzeczywistej aplikacji należy dać użytkownikowi możliwość wyboru)
unsigned long deviceID;
ret = PassThruOpen(device.DeviceName, &deviceID);
if (ret == STATUS_NOERROR)
{
    printf("\nPołączono z: %s\n", device.DeviceName);
    // ... praca z urządzeniem ...
    PassThruClose(deviceID);
}

Przykład w Kotlin (Android)

val j2534 = J2534JNI(context)

// Skanujemy urządzenia
val scanResult = j2534.ptScanForDevices()
if (scanResult.status != STATUS_NOERROR || scanResult.deviceCount == 0) {
    Log.w("J2534", "Nie znaleziono urządzeń")
    return
}

// Zbieramy informacje o wszystkich urządzeniach
val devices = mutableListOf<DeviceInfo>()

for (i in 0 until scanResult.deviceCount) {
    val result = j2534.ptGetNextDevice()
    if (result.status == STATUS_NOERROR) {
        devices.add(result.device)
        Log.i("J2534", """
            Urządzenie ${i + 1}:
              Nazwa: ${result.device.name}
              Dostępne: ${result.device.available}
              Sygnał: ${result.device.signalStrength}%
        """.trimIndent())
    }
}

// Wyświetlamy okno dialogowe wyboru urządzenia
showDeviceSelectionDialog(devices) { selectedDevice ->
    val openResult = j2534.ptOpen(selectedDevice.name)
    if (openResult.status == STATUS_NOERROR) {
        // Praca z urządzeniem...
    }
}

Przykład w Python (ctypes)

from ctypes import *
import platform

# Załadowanie biblioteki
if platform.system() == "Windows":
    j2534 = windll.LoadLibrary("j2534sd_v05_00_x64.dll")
elif platform.system() == "Darwin":
    j2534 = cdll.LoadLibrary("libj2534_v05_00.dylib")
else:
    j2534 = cdll.LoadLibrary("libj2534_v05_00.so")

# Definicja struktury SDEVICE
class SDEVICE(Structure):
    _fields_ = [
        ("DeviceName", c_char * 80),
        ("DeviceAvailable", c_ulong),
        ("DeviceDLLFWStatus", c_ulong),
        ("DeviceConnectMedia", c_ulong),
        ("DeviceConnectSpeed", c_ulong),
        ("DeviceSignalQuality", c_ulong),
        ("DeviceSignalStrength", c_ulong)
    ]

# Stałe
DEVICE_AVAILABLE = 1
DEVICE_IN_USE = 2
DEVICE_DLL_FW_COMPATIBLE = 1
DEVICE_CONN_WIRELESS = 1
DEVICE_CONN_WIRED = 2

# Skanujemy urządzenia
device_count = c_ulong()
ret = j2534.PassThruScanForDevices(byref(device_count))

if ret != 0 or device_count.value == 0:
    print("Nie znaleziono urządzeń")
    exit()

print(f"Znaleziono urządzeń: {device_count.value}\n")

# Pobieramy informacje o każdym urządzeniu
devices = []
for i in range(device_count.value):
    device = SDEVICE()
    ret = j2534.PassThruGetNextDevice(byref(device))

    if ret == 0:
        devices.append(device)
        name = device.DeviceName.decode('utf-8')
        available = "Tak" if device.DeviceAvailable == DEVICE_AVAILABLE else \
                    "Zajęte" if device.DeviceAvailable == DEVICE_IN_USE else "?"
        media = "WLAN/BLE" if device.DeviceConnectMedia == DEVICE_CONN_WIRELESS else \
                "USB/LAN" if device.DeviceConnectMedia == DEVICE_CONN_WIRED else "?"

        print(f"Urządzenie {i + 1}:")
        print(f"  Nazwa: {name}")
        print(f"  Dostępne: {available}")
        print(f"  Połączenie: {media}")

        if device.DeviceSignalStrength != 0xFFFFFFFF:
            print(f"  Sygnał: {device.DeviceSignalStrength}%")
        print()

# Łączymy się z pierwszym dostępnym urządzeniem
if devices:
    device_id = c_ulong()
    ret = j2534.PassThruOpen(devices[0].DeviceName, byref(device_id))
    if ret == 0:
        print(f"Połączono z: {devices[0].DeviceName.decode()}")
        # ... praca z urządzeniem ...
        j2534.PassThruClose(device_id)

Przykład w C# (P/Invoke)

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct SDEVICE
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
    public string DeviceName;
    public uint DeviceAvailable;
    public uint DeviceDLLFWStatus;
    public uint DeviceConnectMedia;
    public uint DeviceConnectSpeed;
    public uint DeviceSignalQuality;
    public uint DeviceSignalStrength;
}

public enum DeviceAvailable : uint
{
    Unknown = 0,
    Available = 1,
    InUse = 2
}

public enum DeviceConnectMedia : uint
{
    Unknown = 0,
    Wireless = 1,
    Wired = 2
}

class J2534
{
    [DllImport("j2534sd_v05_00_x64.dll")]
    public static extern int PassThruScanForDevices(out uint pDeviceCount);

    [DllImport("j2534sd_v05_00_x64.dll")]
    public static extern int PassThruGetNextDevice(out SDEVICE psDevice);

    [DllImport("j2534sd_v05_00_x64.dll")]
    public static extern int PassThruOpen(string pName, out uint pDeviceID);

    [DllImport("j2534sd_v05_00_x64.dll")]
    public static extern int PassThruClose(uint DeviceID);
}

// Użycie:
uint deviceCount;
int ret = J2534.PassThruScanForDevices(out deviceCount);

if (ret != 0 || deviceCount == 0)
{
    Console.WriteLine("Nie znaleziono urządzeń");
    return;
}

Console.WriteLine($"Znaleziono urządzeń: {deviceCount}\n");

var devices = new List<SDEVICE>();

for (uint i = 0; i < deviceCount; i++)
{
    SDEVICE device;
    ret = J2534.PassThruGetNextDevice(out device);

    if (ret == 0)
    {
        devices.Add(device);
        Console.WriteLine($"Urządzenie {i + 1}:");
        Console.WriteLine($"  Nazwa: {device.DeviceName}");
        Console.WriteLine($"  Dostępne: {(DeviceAvailable)device.DeviceAvailable}");
        Console.WriteLine($"  Połączenie: {(DeviceConnectMedia)device.DeviceConnectMedia}");

        if (device.DeviceSignalStrength != 0xFFFFFFFF)
            Console.WriteLine($"  Sygnał: {device.DeviceSignalStrength}%");

        Console.WriteLine();
    }
}

// Łączymy się z pierwszym urządzeniem
if (devices.Count > 0)
{
    uint deviceId;
    ret = J2534.PassThruOpen(devices[0].DeviceName, out deviceId);
    if (ret == 0)
    {
        Console.WriteLine($"Połączono z: {devices[0].DeviceName}");
        // ... praca z urządzeniem ...
        J2534.PassThruClose(deviceId);
    }
}

Funkcje powiązane

PassThruScanForDevices() - Skanowanie dostępnych urządzeń
PassThruOpen() - Nawiązanie połączenia z adapterem