PassThruGetNextDevice v5.0

Abrufen der Geräteinformationen

Letzte Änderung: 13. Januar 2026

Beschreibung

Die Funktion gibt nacheinander die Informationen zu den Geräten zurück, die beim letzten Aufruf von PassThruScanForDevices() gefunden wurden. Bei jedem Aufruf werden die Informationen des nächsten Geräts aus der Liste geliefert. Die Reihenfolge der Geräte kann bei jedem neuen Scan unterschiedlich sein.

long PassThruGetNextDevice(SDEVICE* psDevice)

Hinweis: Ein Aufruf von PassThruOpen() ist vor der Verwendung dieser Funktion nicht erforderlich. Es genügt, vorab PassThruScanForDevices() aufzurufen.

Parameter

psDevice - Zeiger auf eine von der Anwendung bereitgestellte Struktur SDEVICE. Nach erfolgreicher Ausführung der Funktion wird die Struktur mit den Geräteinformationen befüllt.

Struktur SDEVICE

typedef struct {
    char          DeviceName[80];       // Gerätename (ASCII, null-terminiert)
    unsigned long DeviceAvailable;      // Verfügbarkeitsstatus des Geräts
    unsigned long DeviceDLLFWStatus;    // Kompatibilität von DLL und Firmware
    unsigned long DeviceConnectMedia;   // Verbindungsart (kabelgebunden/drahtlos)
    unsigned long DeviceConnectSpeed;   // Verbindungsgeschwindigkeit (Bit/s)
    unsigned long DeviceSignalQuality;  // Signalqualität (0-100%, 0xFFFFFFFF wenn unbekannt)
    unsigned long DeviceSignalStrength; // Signalstärke (0-100%, 0xFFFFFFFF wenn unbekannt)
} SDEVICE;

Beschreibung der Strukturfelder

Feld	Beschreibung
DeviceName	ASCII-Zeichenkette mit dem Gerätenamen (bis zu 80 Zeichen einschließlich Null-Terminator). Der Name ist zur Anzeige für den Benutzer bestimmt und muss das Gerät eindeutig identifizieren. Beispiele: `"ScanDoc FD #N4999"`, `"ScanDoc PRO (WiFi)"`
DeviceAvailable	Verfügbarkeitsstatus des Geräts. Siehe Wertetabelle
DeviceDLLFWStatus	Kompatibilitätsstatus von DLL und Geräte-Firmware. Siehe Wertetabelle
DeviceConnectMedia	Verbindungsart zum Gerät. Siehe Wertetabelle
DeviceConnectSpeed	Verbindungsgeschwindigkeit zum Gerät in Bit pro Sekunde
DeviceSignalQuality	Signalqualität von 0 bis 100%. Wert `0xFFFFFFFF`, wenn unbekannt
DeviceSignalStrength	Signalstärke von 0 bis 100%. Wert `0xFFFFFFFF`, wenn unbekannt

Werte von DeviceAvailable

Konstante	Wert	Beschreibung
DEVICE_STATE_UNKNOWN	0	Der Gerätestatus konnte nicht ermittelt werden
DEVICE_AVAILABLE	1	Das Gerät ist frei und bereit für eine Verbindung
DEVICE_IN_USE	2	Das Gerät wird bereits verwendet (von einer anderen Anwendung geöffnet)

Werte von DeviceDLLFWStatus

Konstante	Wert	Beschreibung
DEVICE_DLL_FW_COMPATIBILTY_UNKNOWN	0	Die Kompatibilität von DLL und Firmware konnte nicht ermittelt werden
DEVICE_DLL_FW_COMPATIBLE	1	DLL und Firmware sind kompatibel
DEVICE_DLL_OR_FW_NOT_COMPATIBLE	2	DLL oder Firmware sind veraltet oder nicht kompatibel
DEVICE_DLL_NOT_COMPATIBLE	3	Die DLL ist veraltet oder nicht mit dem Gerät kompatibel
DEVICE_FW_NOT_COMPATIBLE	4	Die Firmware des Geräts ist veraltet oder nicht mit der DLL kompatibel

Werte von DeviceConnectMedia

Konstante	Wert	Beschreibung
DEVICE_CONN_UNKNOWN	0	Die Verbindungsart konnte nicht ermittelt werden
DEVICE_CONN_WIRELESS	1	Drahtlose Verbindung (WiFi, BLE)
DEVICE_CONN_WIRED	2	Kabelgebundene Verbindung (USB, Ethernet)

Aufrufreihenfolge der Funktionen

PassThruScanForDevices(&count)  → Anzahl der Geräte ermitteln
    ↓
for (i = 0; i < count; i++) {
    PassThruGetNextDevice(&device) → Geräteinformationen abrufen
}
    ↓
PassThruOpen(deviceName)        → Ausgewähltes Gerät öffnen

Wichtig: Die Anwendung muss PassThruGetNextDevice() nicht für alle Geräte aufrufen. Die Aufzählung kann jederzeit abgebrochen werden. Nachfolgende Aufrufe liefern jedoch weiterhin die verbleibenden Geräte, bis das Ende der Liste erreicht wird, die DLL entladen wird oder ein neuer Aufruf von PassThruScanForDevices() erfolgt.

Rückgabe-Fehlercodes

Code	Beschreibung	Mögliche Ursachen und Lösungen
STATUS_NOERROR	Funktion erfolgreich ausgeführt	Die Struktur `psDevice` wurde mit Geräteinformationen befüllt
ERR_NULL_PARAMETER	Der Zeiger psDevice ist nicht gesetzt	Übergeben Sie einen gültigen Zeiger auf eine `SDEVICE`-Struktur
ERR_EXCEEDED_LIMIT	Alle Geräte wurden bereits aufgelistet	Die Informationen zu allen gefundenen Geräten wurden bereits zurückgegeben Lösung: Rufen Sie `PassThruScanForDevices()` für einen neuen Scan auf
ERR_BUFFER_EMPTY	Die Geräteliste ist leer	`PassThruScanForDevices()` hat keine Geräte gefunden `PassThruScanForDevices()` wurde nicht aufgerufen Lösung: Rufen Sie `PassThruScanForDevices()` auf und prüfen Sie `pDeviceCount`
ERR_CONCURRENT_API_CALL	Eine J2534-API-Funktion wird bereits ausgeführt	Eine andere J2534-Funktion ist noch nicht abgeschlossen Lösung: Warten Sie, bis der vorherige Aufruf beendet ist
ERR_NOT_SUPPORTED	Funktion wird nicht unterstützt	Die DLL unterstützt keine dynamische Geräteaufzählung Lösung: Verwenden Sie `PassThruOpen()` direkt
ERR_FAILED	Interner Fehler	Verwenden Sie `PassThruGetLastError()`, um Details zu erhalten

Beispiele

Beispiel in C/C++

#include "j2534_dll.hpp"

unsigned long deviceCount = 0;

// Geräte scannen
long ret = PassThruScanForDevices(&deviceCount);
if (ret != STATUS_NOERROR || deviceCount == 0)
{
    printf("Keine Geräte gefunden\n");
    return;
}

printf("Gefundene Geräte: %lu\n", deviceCount);

// Alle gefundenen Geräte durchlaufen
SDEVICE device;
for (unsigned long i = 0; i < deviceCount; i++)
{
    ret = PassThruGetNextDevice(&device);
    if (ret != STATUS_NOERROR)
    {
        break;
    }

    printf("\nGerät %lu:\n", i + 1);
    printf("  Name: %s\n", device.DeviceName);
    printf("  Verfügbar: %s\n",
        device.DeviceAvailable == DEVICE_AVAILABLE ? "Ja" :
        device.DeviceAvailable == DEVICE_IN_USE ? "Belegt" : "Unbekannt");
    printf("  Kompatibilität: %s\n",
        device.DeviceDLLFWStatus == DEVICE_DLL_FW_COMPATIBLE ? "OK" : "Update erforderlich");
    printf("  Verbindung: %s\n",
        device.DeviceConnectMedia == DEVICE_CONN_WIRELESS ? "Drahtlos" :
        device.DeviceConnectMedia == DEVICE_CONN_WIRED ? "Kabelgebunden" : "Unbekannt");

    if (device.DeviceSignalStrength != 0xFFFFFFFF)
    {
        printf("  Signalstärke: %lu%%\n", device.DeviceSignalStrength);
    }
}

// Mit dem ersten verfügbaren Gerät verbinden
// (in einer echten Anwendung sollte der Benutzer auswählen)
unsigned long deviceID;
ret = PassThruOpen(device.DeviceName, &deviceID);
if (ret == STATUS_NOERROR)
{
    printf("\nVerbunden mit: %s\n", device.DeviceName);
    // ... Arbeit mit dem Gerät ...
    PassThruClose(deviceID);
}

Beispiel in Kotlin (Android)

val j2534 = J2534JNI(context)

// Geräte scannen
val scanResult = j2534.ptScanForDevices()
if (scanResult.status != STATUS_NOERROR || scanResult.deviceCount == 0) {
    Log.w("J2534", "Keine Geräte gefunden")
    return
}

// Informationen zu allen Geräten sammeln
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", """
            Gerät ${i + 1}:
              Name: ${result.device.name}
              Verfügbar: ${result.device.available}
              Signal: ${result.device.signalStrength}%
        """.trimIndent())
    }
}

// Dialog zur Geräteauswahl anzeigen
showDeviceSelectionDialog(devices) { selectedDevice ->
    val openResult = j2534.ptOpen(selectedDevice.name)
    if (openResult.status == STATUS_NOERROR) {
        // Arbeit mit dem Gerät...
    }
}

Beispiel in Python (ctypes)

from ctypes import *
import platform

# Bibliothek laden
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")

# Definition der SDEVICE-Struktur
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)
    ]

# Konstanten
DEVICE_AVAILABLE = 1
DEVICE_IN_USE = 2
DEVICE_DLL_FW_COMPATIBLE = 1
DEVICE_CONN_WIRELESS = 1
DEVICE_CONN_WIRED = 2

# Geräte scannen
device_count = c_ulong()
ret = j2534.PassThruScanForDevices(byref(device_count))

if ret != 0 or device_count.value == 0:
    print("Keine Geräte gefunden")
    exit()

print(f"Gefundene Geräte: {device_count.value}\n")

# Informationen zu jedem Gerät abrufen
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 = "Ja" if device.DeviceAvailable == DEVICE_AVAILABLE else \
                    "Belegt" if device.DeviceAvailable == DEVICE_IN_USE else "?"
        media = "WiFi/BLE" if device.DeviceConnectMedia == DEVICE_CONN_WIRELESS else \
                "USB/LAN" if device.DeviceConnectMedia == DEVICE_CONN_WIRED else "?"

        print(f"Gerät {i + 1}:")
        print(f"  Name: {name}")
        print(f"  Verfügbar: {available}")
        print(f"  Verbindung: {media}")

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

# Mit dem ersten verfügbaren Gerät verbinden
if devices:
    device_id = c_ulong()
    ret = j2534.PassThruOpen(devices[0].DeviceName, byref(device_id))
    if ret == 0:
        print(f"Verbunden mit: {devices[0].DeviceName.decode()}")
        # ... Arbeit mit dem Gerät ...
        j2534.PassThruClose(device_id)

Beispiel in 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);
}

// Использование:
uint deviceCount;
int ret = J2534.PassThruScanForDevices(out deviceCount);

if (ret != 0 || deviceCount == 0)
{
    Console.WriteLine("Keine Geräte gefunden");
    return;
}

Console.WriteLine($"Gefundene Geräte: {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($"Gerät {i + 1}:");
        Console.WriteLine($"  Name: {device.DeviceName}");
        Console.WriteLine($"  Verfügbar: {(DeviceAvailable)device.DeviceAvailable}");
        Console.WriteLine($"  Verbindung: {(DeviceConnectMedia)device.DeviceConnectMedia}");

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

        Console.WriteLine();
    }
}

// Mit dem ersten Gerät verbinden
if (devices.Count > 0)
{
    uint deviceId;
    ret = J2534.PassThruOpen(devices[0].DeviceName, out deviceId);
    if (ret == 0)
    {
        Console.WriteLine($"Verbunden mit: {devices[0].DeviceName}");
        // ... Arbeit mit dem Gerät ...
        J2534.PassThruClose(deviceId);
    }
}