PassThruGetNextDevice v5.0

Récupération des informations sur le dispositif

Dernière modification : 13 janvier 2026

Description

La fonction renvoie séquentiellement les informations sur les dispositifs détectés lors du dernier appel à PassThruScanForDevices(). À chaque appel, les informations sur le dispositif suivant de la liste sont renvoyées. L'ordre des dispositifs peut varier à chaque nouvelle analyse.

long PassThruGetNextDevice(SDEVICE* psDevice)

Remarque : Il n'est pas nécessaire d'appeler PassThruOpen() avant d'utiliser cette fonction. Il suffit d'avoir appelé au préalable PassThruScanForDevices().

Paramètres

psDevice - Pointeur vers une structure SDEVICE allouée par l'application. Après l'exécution réussie de la fonction, la structure sera remplie avec les informations sur le dispositif.

Structure SDEVICE

typedef struct {
    char          DeviceName[80];       // Nom du dispositif (ASCII, terminé par null)
    unsigned long DeviceAvailable;      // État de disponibilité du dispositif
    unsigned long DeviceDLLFWStatus;    // Compatibilité de la DLL et du firmware
    unsigned long DeviceConnectMedia;   // Type de connexion (filaire/sans fil)
    unsigned long DeviceConnectSpeed;   // Vitesse de connexion (bit/s)
    unsigned long DeviceSignalQuality;  // Qualité du signal (0-100%, 0xFFFFFFFF si inconnue)
    unsigned long DeviceSignalStrength; // Niveau du signal (0-100%, 0xFFFFFFFF si inconnu)
} SDEVICE;

Description des champs de la structure

Champ	Description
DeviceName	Chaîne ASCII contenant le nom du dispositif (jusqu'à 80 caractères y compris le terminateur NULL). Le nom est destiné à être affiché à l'utilisateur et doit identifier le dispositif de manière non équivoque. Exemples : `"ScanDoc FD #N4999"`, `"ScanDoc PRO (WLAN)"`
DeviceAvailable	État de disponibilité du dispositif. Voir la table des valeurs
DeviceDLLFWStatus	État de compatibilité de la DLL et du firmware du dispositif. Voir la table des valeurs
DeviceConnectMedia	Type de connexion au dispositif. Voir la table des valeurs
DeviceConnectSpeed	Vitesse de connexion avec le dispositif en bits par seconde
DeviceSignalQuality	Qualité du signal de 0 à 100%. La valeur `0xFFFFFFFF` si elle n'est pas déterminée
DeviceSignalStrength	Niveau du signal de 0 à 100%. La valeur `0xFFFFFFFF` s'il n'est pas déterminé

Valeurs de DeviceAvailable

Constante	Valeur	Description
DEVICE_STATE_UNKNOWN	0	Impossible de déterminer l'état du dispositif
DEVICE_AVAILABLE	1	Le dispositif est libre et prêt à la connexion
DEVICE_IN_USE	2	Le dispositif est déjà utilisé (ouvert par une autre application)

Valeurs de DeviceDLLFWStatus

Constante	Valeur	Description
DEVICE_DLL_FW_COMPATIBILTY_UNKNOWN	0	Impossible de déterminer la compatibilité de la DLL et du firmware
DEVICE_DLL_FW_COMPATIBLE	1	La DLL et le firmware sont compatibles
DEVICE_DLL_OR_FW_NOT_COMPATIBLE	2	La DLL ou le firmware sont obsolètes ou incompatibles
DEVICE_DLL_NOT_COMPATIBLE	3	La DLL est obsolète ou incompatible avec le dispositif
DEVICE_FW_NOT_COMPATIBLE	4	Le firmware du dispositif est obsolète ou incompatible avec la DLL

Valeurs de DeviceConnectMedia

Constante	Valeur	Description
DEVICE_CONN_UNKNOWN	0	Impossible de déterminer le type de connexion
DEVICE_CONN_WIRELESS	1	Connexion sans fil (WLAN, BLE)
DEVICE_CONN_WIRED	2	Connexion filaire (USB, Ethernet)

Ordre d'appel des fonctions

PassThruScanForDevices(&count)  → Obtenir le nombre de dispositifs
    ↓
for (i = 0; i < count; i++) {
    PassThruGetNextDevice(&device) → Obtenir les informations sur le dispositif
}
    ↓
PassThruOpen(deviceName)        → Ouvrir le dispositif sélectionné

Important : L'application n'est pas obligée d'appeler PassThruGetNextDevice() pour tous les dispositifs. Le parcours peut être interrompu à tout moment. Cependant, les appels suivants continueront à renvoyer les dispositifs restants jusqu'à la fin de la liste, au déchargement de la DLL ou à un nouvel appel à PassThruScanForDevices().

Codes d'erreur renvoyés

Code	Description	Causes possibles et solutions
STATUS_NOERROR	La fonction s'est exécutée avec succès	La structure `psDevice` a été remplie avec les informations sur le dispositif
ERR_NULL_PARAMETER	Le pointeur psDevice n'est pas indiqué	Transmettez un pointeur valide vers la structure `SDEVICE`
ERR_EXCEEDED_LIMIT	Tous les dispositifs ont déjà été énumérés	Les informations sur tous les dispositifs détectés ont déjà été renvoyées Solution : appelez `PassThruScanForDevices()` pour effectuer une nouvelle analyse
ERR_BUFFER_EMPTY	La liste des dispositifs est vide	`PassThruScanForDevices()` n'a trouvé aucun dispositif `PassThruScanForDevices()` n'a pas été appelée Solution : appelez `PassThruScanForDevices()` et vérifiez `pDeviceCount`
ERR_CONCURRENT_API_CALL	Une fonction de l'API J2534 est déjà en cours d'exécution	Une autre fonction J2534 n'a pas encore terminé son exécution Solution : attendez la fin de l'appel précédent
ERR_NOT_SUPPORTED	La fonction n'est pas prise en charge	La DLL ne prend pas en charge l'énumération dynamique des dispositifs Solution : utilisez `PassThruOpen()` directement
ERR_FAILED	Erreur interne	Utilisez `PassThruGetLastError()` pour obtenir les détails

Exemples

Exemple en C/C++

#include "j2534_dll.hpp"

unsigned long deviceCount = 0;

// Analyse des dispositifs
long ret = PassThruScanForDevices(&deviceCount);
if (ret != STATUS_NOERROR || deviceCount == 0)
{
    printf("Aucun dispositif trouvé\n");
    return;
}

printf("Dispositifs trouvés : %lu\n", deviceCount);

// Parcours de tous les dispositifs détectés
SDEVICE device;
for (unsigned long i = 0; i < deviceCount; i++)
{
    ret = PassThruGetNextDevice(&device);
    if (ret != STATUS_NOERROR)
    {
        break;
    }

    printf("\nDispositif %lu:\n", i + 1);
    printf("  Nom: %s\n", device.DeviceName);
    printf("  Disponible: %s\n",
        device.DeviceAvailable == DEVICE_AVAILABLE ? "Oui" :
        device.DeviceAvailable == DEVICE_IN_USE ? "Occupé" : "Inconnu");
    printf("  Compatibilité: %s\n",
        device.DeviceDLLFWStatus == DEVICE_DLL_FW_COMPATIBLE ? "OK" : "Mise à jour requise");
    printf("  Connexion: %s\n",
        device.DeviceConnectMedia == DEVICE_CONN_WIRELESS ? "Sans fil" :
        device.DeviceConnectMedia == DEVICE_CONN_WIRED ? "Filaire" : "Inconnue");

    if (device.DeviceSignalStrength != 0xFFFFFFFF)
    {
        printf("  Niveau du signal: %lu%%\n", device.DeviceSignalStrength);
    }
}

// Connexion au premier dispositif disponible
// (dans une application réelle, il faut laisser l'utilisateur choisir)
unsigned long deviceID;
ret = PassThruOpen(device.DeviceName, &deviceID);
if (ret == STATUS_NOERROR)
{
    printf("\nConnecté à : %s\n", device.DeviceName);
    // ... travail avec le dispositif ...
    PassThruClose(deviceID);
}

Exemple en Kotlin (Android)

val j2534 = J2534JNI(context)

// Analyse des dispositifs
val scanResult = j2534.ptScanForDevices()
if (scanResult.status != STATUS_NOERROR || scanResult.deviceCount == 0) {
    Log.w("J2534", "Aucun dispositif trouvé")
    return
}

// Collecte des informations sur tous les dispositifs
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", """
            Dispositif ${i + 1}:
              Nom: ${result.device.name}
              Disponible: ${result.device.available}
              Signal: ${result.device.signalStrength}%
        """.trimIndent())
    }
}

// Affichage de la boîte de dialogue de sélection du dispositif
showDeviceSelectionDialog(devices) { selectedDevice ->
    val openResult = j2534.ptOpen(selectedDevice.name)
    if (openResult.status == STATUS_NOERROR) {
        // Travail avec le dispositif...
    }
}

Exemple en Python (ctypes)

from ctypes import *
import platform

# Chargement de la bibliothèque
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")

# Définition de la structure 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)
    ]

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

# Analyse des dispositifs
device_count = c_ulong()
ret = j2534.PassThruScanForDevices(byref(device_count))

if ret != 0 or device_count.value == 0:
    print("Aucun dispositif trouvé")
    exit()

print(f"Dispositifs trouvés : {device_count.value}\n")

# Récupération des informations sur chaque dispositif
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 = "Oui" if device.DeviceAvailable == DEVICE_AVAILABLE else \
                    "Occupé" 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"Dispositif {i + 1}:")
        print(f"  Nom: {name}")
        print(f"  Disponible: {available}")
        print(f"  Connexion: {media}")

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

# Connexion au premier dispositif disponible
if devices:
    device_id = c_ulong()
    ret = j2534.PassThruOpen(devices[0].DeviceName, byref(device_id))
    if ret == 0:
        print(f"Connecté à : {devices[0].DeviceName.decode()}")
        # ... travail avec le dispositif ...
        j2534.PassThruClose(device_id)

Exemple en 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);
}

// Utilisation :
uint deviceCount;
int ret = J2534.PassThruScanForDevices(out deviceCount);

if (ret != 0 || deviceCount == 0)
{
    Console.WriteLine("Aucun dispositif trouvé");
    return;
}

Console.WriteLine($"Dispositifs trouvés : {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($"Dispositif {i + 1}:");
        Console.WriteLine($"  Nom: {device.DeviceName}");
        Console.WriteLine($"  Disponible: {(DeviceAvailable)device.DeviceAvailable}");
        Console.WriteLine($"  Connexion: {(DeviceConnectMedia)device.DeviceConnectMedia}");

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

        Console.WriteLine();
    }
}

// Connexion au premier dispositif
if (devices.Count > 0)
{
    uint deviceId;
    ret = J2534.PassThruOpen(devices[0].DeviceName, out deviceId);
    if (ret == 0)
    {
        Console.WriteLine($"Connecté à : {devices[0].DeviceName}");
        // ... travail avec le dispositif ...
        J2534.PassThruClose(deviceId);
    }
}

Fonctions associées

PassThruScanForDevices() - Analyse des dispositifs disponibles
PassThruOpen() - Établissement de la connexion avec l'adaptateur