PassThruLogicalConnect v5.0

Création d'un canal de communication logique au-dessus d'une connexion physique

Dernière modification : 13 janvier 2026

Description

La fonction crée un canal de communication logique avec le véhicule sur le dispositif pass-thru indiqué. Le canal logique superpose un schéma de protocole supplémentaire au-dessus du canal de communication physique existant.

En cas d'exécution réussie, la fonction renvoie STATUS_NOERROR, et la valeur pointée par pChannelID est utilisée comme descripteur (handle) du canal créé. Le canal se trouve à l'état initialisé.

Jusqu'à 10 canaux logiques sont admis par canal de communication physique. La création d'un canal logique n'affecte pas le fonctionnement du canal physique ni des autres canaux logiques qui lui sont associés.

long PassThruLogicalConnect(
    unsigned long PhysicalChannelID,
    unsigned long ProtocolID,
    unsigned long Flags,
    void *pChannelDescriptor,
    unsigned long *pChannelID
)

État initialisé du canal

Le canal logique créé a l'état initial suivant :

Aucun message périodique ni leurs identifiants
Les files d'émission et de réception sont vides
Tous les paramètres configurables sont définis à leurs valeurs par défaut

Paramètres

PhysicalChannelID

Paramètre d'entrée. Identifiant du canal physique obtenu lors de l'appel à PassThruConnect().

ProtocolID

Paramètre d'entrée. Identifiant du protocole pour le canal de communication logique. Il détermine comment le canal logique interagira avec le véhicule, ainsi que le type de la structure pChannelDescriptor.

ProtocolID	Description
`ISO15765_LOGICAL`	ISO 15765-2 avec contrôle de flux (flow control)

Flags

Paramètre d'entrée. Flags de configuration du canal logique. Les flags peuvent être combinés par OR.

Flag	Description	Valeurs
`FULL_DUPLEX`	Mode duplex du canal. Uniquement pour ISO 15765.	0 = semi-duplex 1 = duplex intégral
`ISO15765_ON_J1939`	Masquage des bits de priorité (28-26) dans le CAN ID pour les messages ISO 15765 avec identifiant de 29 bits (conformément à ISO 15765-2 Annex A et SAE J1939-21). Uniquement pour ISO 15765.	0 = masquage désactivé (traitement standard ISO 15765) 1 = masquage activé

pChannelDescriptor

Paramètre d'entrée. Pointeur vers la structure décrivant les points d'extrémité de la connexion logique. Si le pointeur est NULL, la fonction renvoie ERR_NULL_PARAMETER.

pChannelID

Paramètre d'entrée. Pointeur vers une variable unsigned long allouée par l'application. En cas d'exécution réussie, la variable contiendra l'identifiant du canal logique pour les appels de fonctions ultérieurs.

Structure ISO15765_CHANNEL_DESCRIPTOR

Pour le protocole ISO15765_LOGICAL, on utilise la structure ISO15765_CHANNEL_DESCRIPTOR, qui définit les points d'extrémité de la connexion logique :

typedef struct {
    unsigned long LocalTxFlags;     // TxFlags pour LocalAddress
    unsigned long RemoteTxFlags;    // TxFlags pour RemoteAddress
    unsigned char LocalAddress[5];  // CAN ID + extended address (côté local)
    unsigned char RemoteAddress[5]; // CAN ID + extended address (côté distant)
} ISO15765_CHANNEL_DESCRIPTOR;

LocalTxFlags et RemoteTxFlags

Flags autorisés pour le descripteur du canal ISO 15765 :

Flag	Application	Description
`CAN_29BIT_ID`	LocalAddress, RemoteAddress	Utiliser un CAN ID de 29 bits (au lieu de 11 bits)
`ISO15765_ADDR_TYPE`	LocalAddress, RemoteAddress	Utiliser l'adressage étendu (extended address)
`ISO15765_FRAME_PAD`	RemoteAddress	Activer le remplissage (padding) des trames de flow control lors de la transmission

Format de LocalAddress et RemoteAddress

Address[0] — CAN ID bits 28-24 (les trois bits de poids fort doivent être à zéro)
Address[1] — CAN ID bits 23-16
Address[2] — CAN ID bits 15-8
Address[3] — CAN ID bits 7-0
Address[4] — adresse étendue (si le flag ISO15765_ADDR_TYPE est indiqué)

Important : Les adresses LocalAddress et RemoteAddress doivent être uniques. Aucune des adresses ne doit coïncider avec les adresses d'autres canaux logiques existants pour le canal physique donné. Le CAN ID avec adresse étendue ne doit pas coïncider avec un CAN ID sans adresse étendue.

Codes d'erreur renvoyés

Code	Description
STATUS_NOERROR	La fonction s'est exécutée correctement
ERR_CONCURRENT_API_CALL	Une fonction de l'API J2534 a été appelée avant la fin de l'appel précédent
ERR_DEVICE_NOT_OPEN	`PassThruOpen()` n'a pas été appelée correctement
ERR_INVALID_CHANNEL_ID	Valeur de `PhysicalChannelID` non valide
ERR_DEVICE_NOT_CONNECTED	Erreur de communication avec le dispositif pass-thru. Le dispositif a été déconnecté.
ERR_NOT_SUPPORTED	La DLL ne prend pas en charge cette fonction
ERR_LOG_CHAN_NOT_ALLOWED	Le canal logique n'est pas autorisé pour la combinaison donnée de canal physique et de `ProtocolID`
ERR_PROTOCOL_ID_NOT_SUPPORTED	La valeur de `ProtocolID` n'est pas prise en charge (non valide ou inconnue)
ERR_FLAG_NOT_SUPPORTED	Les valeurs de `Flags` ne sont pas valides, sont inconnues ou ne sont pas applicables au canal actuel
ERR_INVALID_CHANNEL_DESCRIPTOR	Un ou plusieurs éléments de la structure `pChannelDescriptor` ne sont pas valides ou ne sont pas applicables au canal actuel
ERR_NULL_REQUIRED	Un paramètre qui devrait être NULL n'a pas été défini à NULL
ERR_NULL_PARAMETER	Un pointeur NULL a été passé à la place d'un pointeur obligatoire
ERR_NOT_UNIQUE	Tentative de créer un canal logique avec des adresses qui dupliquent les adresses d'un canal existant
ERR_EXCEEDED_LIMIT	Le nombre maximal de canaux logiques pour le canal physique donné a été dépassé
ERR_FAILED	Erreur non spécifiée. Utilisez `PassThruGetLastError()` pour obtenir la description.

Exemples

Exemple en C/C++

#include "j2534_dll.hpp"

unsigned long deviceID = 0;
unsigned long physicalChannelID = 0;
unsigned long logicalChannelID = 0;

// Ouvre le dispositif
long ret = PassThruOpen("ScanDoc", &deviceID);
if (ret != STATUS_NOERROR) return;

// Crée la connexion physique CAN
ret = PassThruConnect(deviceID, CAN, CAN_29BIT_ID, 500000, &physicalChannelID);
if (ret != STATUS_NOERROR) {
    PassThruClose(deviceID);
    return;
}

// Configure le descripteur du canal logique ISO 15765
ISO15765_CHANNEL_DESCRIPTOR channelDesc = {0};

// Adresse locale (adaptateur) - 0x18DA00F1 (requête fonctionnelle)
channelDesc.LocalTxFlags = CAN_29BIT_ID;
channelDesc.LocalAddress[0] = 0x18;
channelDesc.LocalAddress[1] = 0xDA;
channelDesc.LocalAddress[2] = 0x00;
channelDesc.LocalAddress[3] = 0xF1;

// Adresse distante (ECU) - 0x18DAF100 (réponse de l'ECU)
channelDesc.RemoteTxFlags = CAN_29BIT_ID | ISO15765_FRAME_PAD;
channelDesc.RemoteAddress[0] = 0x18;
channelDesc.RemoteAddress[1] = 0xDA;
channelDesc.RemoteAddress[2] = 0xF1;
channelDesc.RemoteAddress[3] = 0x00;

// Crée le canal logique
ret = PassThruLogicalConnect(
    physicalChannelID,
    ISO15765_LOGICAL,
    0,  // Flags : semi-duplex
    &channelDesc,
    &logicalChannelID
);

if (ret == STATUS_NOERROR) {
    printf("Canal logique créé : %lu\n", logicalChannelID);

    // On peut maintenant utiliser logicalChannelID pour PassThruReadMsgs/PassThruQueueMsgs

    // Ferme le canal logique
    PassThruLogicalDisconnect(logicalChannelID);
}

// Ferme le canal physique et le dispositif
PassThruDisconnect(physicalChannelID);
PassThruClose(deviceID);

Exemple en Python (ctypes)

from ctypes import *

# Chargement de la bibliothèque
j2534 = cdll.LoadLibrary("libj2534_v05_00.dylib")

# Structure du descripteur de canal
class ISO15765_CHANNEL_DESCRIPTOR(Structure):
    _fields_ = [
        ("LocalTxFlags", c_ulong),
        ("RemoteTxFlags", c_ulong),
        ("LocalAddress", c_ubyte * 5),
        ("RemoteAddress", c_ubyte * 5)
    ]

device_id = c_ulong()
physical_channel_id = c_ulong()
logical_channel_id = c_ulong()

# Ouvre le dispositif
ret = j2534.PassThruOpen(b"ScanDoc", byref(device_id))
if ret != 0:
    print(f"Erreur PassThruOpen : {ret}")
    exit()

# Crée la connexion physique CAN (500 kbit/s, 29-bit ID)
CAN = 0x05
CAN_29BIT_ID = 0x100
ret = j2534.PassThruConnect(device_id, CAN, CAN_29BIT_ID, 500000, byref(physical_channel_id))
if ret != 0:
    print(f"Erreur PassThruConnect : {ret}")
    j2534.PassThruClose(device_id)
    exit()

# Configure le descripteur de canal
ISO15765_LOGICAL = 0x200
ISO15765_FRAME_PAD = 0x40

channel_desc = ISO15765_CHANNEL_DESCRIPTOR()
channel_desc.LocalTxFlags = CAN_29BIT_ID
channel_desc.LocalAddress[0] = 0x18
channel_desc.LocalAddress[1] = 0xDA
channel_desc.LocalAddress[2] = 0x00
channel_desc.LocalAddress[3] = 0xF1

channel_desc.RemoteTxFlags = CAN_29BIT_ID | ISO15765_FRAME_PAD
channel_desc.RemoteAddress[0] = 0x18
channel_desc.RemoteAddress[1] = 0xDA
channel_desc.RemoteAddress[2] = 0xF1
channel_desc.RemoteAddress[3] = 0x00

# Crée le canal logique
ret = j2534.PassThruLogicalConnect(
    physical_channel_id,
    ISO15765_LOGICAL,
    0,
    byref(channel_desc),
    byref(logical_channel_id)
)

if ret == 0:
    print(f"Canal logique créé : {logical_channel_id.value}")
    # ...travail avec le canal...
    j2534.PassThruLogicalDisconnect(logical_channel_id)
else:
    print(f"Erreur : {ret}")

j2534.PassThruDisconnect(physical_channel_id)
j2534.PassThruClose(device_id)

Fonctions associées

PassThruConnect() - Création de la connexion physique
PassThruLogicalDisconnect() - Fermeture du canal logique
PassThruReadMsgs() - Lecture des messages du canal