Se rendre au contenu
Logiciel · Développement

Rust dans PCAN-Basic : un langage système à mémoire sûre rejoint la boîte à outils CAN

Rust et l'API PCAN-Basic

PCAN-Basic 5.1 prend en charge Rust sous la forme d'un module FFI (Foreign Function Interface). Les développeurs Rust accèdent ainsi directement à l'API PCAN-Basic, éprouvée de longue date.

Pourquoi Rust compte pour les applications CAN

Le logiciel des véhicules et des machines doit être à la fois rapide, fiable, maintenable et sûr. À mesure que les architectures deviennent zonales et qu'une part croissante du développement, du test, du diagnostic, de l'enregistrement, de la simulation et des passerelles s'exécute sur des PC, le choix des langages et des API prend de l'importance.

Les défauts de sécurité mémoire — dépassements de tampon, utilisation après libération, accès par pointeur invalide, accès concurrents — provoquent des plantages, des comportements imprévisibles et des failles de sécurité. Les langages système traditionnels comme le C et le C++ offrent un contrôle et des performances élevés, mais ils font reposer une lourde responsabilité sur le développeur et sur le processus de développement.

Rust répond à ce problème par ses règles de propriété et d'emprunt vérifiées à la compilation. En Rust sûr, elles écartent de larges familles d'erreurs de mémoire et de concurrence avant même l'exécution, sans ramasse-miettes. Rust ne rend pas une application automatiquement correcte ni certifiée, et les frontières FFI demandent toujours du soin ; il réduit toutefois des risques d'implémentation importants tout en gardant les performances du code natif et un contrôle de bas niveau.

C'est ce qui rend Rust de plus en plus pertinent pour l'outillage automobile, les systèmes de test, le diagnostic, l'acquisition de données, les passerelles et les utilitaires en ligne de commande qui dialoguent avec des réseaux CAN. Avec PCAN-Basic 5.1, Rust accède au matériel PC CAN de PEAK par le même modèle d'API que les autres langages pris en charge.

Architecture de PCAN-Basic avec le module FFI Rust
Figure 1 — Rust est un point d'entrée supplémentaire vers l'API PCAN-Basic et l'architecture de pilotes existantes.

PCAN-Basic, l'API de développement CAN

PCAN-Basic est l'API de PEAK pour développer des applications communiquant en CAN classique, CAN FD et CAN XL. Elle fournit les fonctions nécessaires pour dialoguer avec le matériel PCAN : initialisation des canaux, réglage des débits, émission et réception de messages, lecture d'état, identification du matériel, enregistrement de traces et autres paramètres de canal. L'architecture comprend le pilote de périphérique et une bibliothèque d'interface qui donne accès aux fonctions de l'API ; elle est conçue pour qu'une application se porte d'une plateforme à l'autre avec peu de modifications, sous Windows 10 et 11 comme sous Linux.

PCAN-Basic prend déjà en charge un large éventail de langages : C++, C#, C++/CLR, Pascal objet, VB.NET, Java et Python. La version 4 a apporté le CAN FD, la version 5 le CAN XL, et la version 5.1 ajoute le module FFI Rust et ses exemples en console. Pour les prérequis exacts (plateforme, chaîne d'outils Rust), se reporter au paquet PCAN-Basic en vigueur et aux fichiers README des exemples.

Parmi les capacités utiles au développeur d'applications :

  • communication CAN classique, CAN FD et CAN XL par des fonctions d'initialisation, de lecture et d'écriture propres à chaque protocole ;
  • plusieurs applications PEAK et une application personnalisée simultanément sur un même canal physique ;
  • jusqu'à 16 canaux par type de matériel, et passage simple d'un canal à l'autre ;
  • files de réception côté pilote, réception horodatée, état des canaux et événements de réception configurables ;
  • API utilisable sans risque depuis plusieurs fils d'exécution ;
  • enregistrement au format PCAN-Trace et nombreux paramètres d'identification, de réception et de journalisation.

Rust en quelques mots

Rust est un langage système compilé, et non un langage de script. Il vise les mêmes domaines que le C et le C++ : logiciels aux performances prévisibles, contrôle direct des ressources, interaction étroite avec le système d'exploitation ou le matériel.

Sa marque de fabrique est le modèle de propriété. Chaque valeur a un propriétaire, et le compilateur vérifie la façon dont les valeurs sont déplacées, empruntées, partagées et libérées. Les durées de vie décrivent les relations entre références, de sorte qu'une référence invalide est refusée dès la compilation. Ces contrôles sont particulièrement utiles dans les programmes multi-fils, où le système de types de Rust écarte de nombreux accès concurrents.

La gestion des erreurs est tout aussi explicite : une opération qui peut échouer renvoie en général une valeur Result, une valeur facultative un Option. Le code appelant doit donc traiter délibérément le succès, l'échec et l'absence. Rust est enfin livré avec Cargo, son système de construction et gestionnaire de paquets, qui réunit compilation, dépendances, tests, exemples et documentation dans un même flux de travail.

mod PCANBasic;
use crate::PCANBasic::*;

fn main() {
    match Initialize(PCAN_USBBUS1, PCAN_BAUD_500K) {
        Ok(_) => println!("PCAN-USB initialized successfully."),
        Err(status) => println!("Error initializing PCAN-USB: {:?}", status)
    }
}

Initialisation d'un canal PCAN-USB en Rust. Le code sûr offre de solides garanties ; un appel qui franchit la frontière FFI doit toujours respecter le contrat de l'API native.

Ce que signifie la prise en charge de Rust

PCAN-Basic 5.1 ajoute Rust sous la forme d'un module FFI, le mécanisme par lequel du code Rust appelle les fonctions d'une bibliothèque native. Concrètement, la couche Rust expose le jeu de fonctions éprouvé de PCAN-Basic à l'application : elle ne remplace pas le pilote PCAN et ne réécrit pas l'API en Rust pur.

La nuance a son importance. Le développeur gagne le langage, l'outillage de projet et le contrôle de types de Rust autour de son code applicatif. En contrepartie, il doit déployer la bonne bibliothèque PCAN-Basic et le bon pilote, choisir un matériel et des débits compatibles, vérifier chaque code d'état renvoyé et suivre les règles d'initialisation et de libération de l'API.

Les avantages pour le développeur

  • Des performances sans ramasse-miettes. Rust compile en code natif : il convient aux boucles de réception continues, au traitement de données à haut débit, à l'automatisation de tests et aux outils de protocole.
  • Une protection dès la compilation. Le Rust sûr écarte de nombreux accès mémoire invalides et accès concurrents avant l'exécution, ce qui réduit l'effort de débogage sans remplacer les tests système, la revue de code ni les processus de sûreté de fonctionnement.
  • Une gestion explicite des états et des erreurs. Les opérations PCAN-Basic renvoient un code d'état, que le style Result de Rust invite à convertir en chemins de succès et d'erreur clairs.
  • Un outillage moderne. Cargo offre une manière homogène de compiler, tester, lancer les exemples, gérer les dépendances et automatiser l'intégration continue.
  • Un modèle de concurrence solide. Rust se prête aux architectures qui séparent réception CAN, décodage, journalisation, interface et retransmission réseau en fils ou en tâches asynchrones maîtrisés.
  • Des outils faciles à distribuer. Rust produit des exécutables autonomes et efficaces pour la production, le service après-vente, la validation ou le diagnostic.

Ces avantages ont un prix : la propriété, l'emprunt, les durées de vie et les abstractions par traits diffèrent du C, du C++, du C# ou de Python. Une équipe doit prévoir un temps de prise en main et des conventions de revue de code.

Les exemples Rust livrés avec PCAN-Basic

Les exemples fournis couvrent les opérations dont la plupart des applications CAN ont besoin :

  • recherche d'un canal disponible ;
  • lecture et écriture des paramètres du matériel et du canal ;
  • lecture et écriture manuelles de messages ;
  • lecture de messages par un fil dédié ;
  • réception pilotée par événement ;
  • création d'un fichier PCAN-Trace.

Mieux vaut partir de l'exemple livré que recopier un extrait d'article : il contient l'organisation exacte des modules, les constantes, les structures de données, la configuration de l'édition de liens et la gestion des erreurs de la version publiée.

Un premier programme, étape par étape

  1. choisir ou rechercher un canal PCAN disponible ;
  2. l'initialiser pour le protocole et le débit voulus (CAN classique, CAN FD ou CAN XL) ;
  3. vérifier le code d'état renvoyé avant de poursuivre ;
  4. créer la structure de message propre au protocole ;
  5. émettre avec la fonction d'écriture correspondante ;
  6. lire jusqu'à ce que la file de réception soit vide, en traitant les données et l'horodatage ;
  7. interroger ou mettre en forme les erreurs pour le diagnostic ;
  8. toujours libérer le canal en fin de programme.

L'exemple ci-dessous suit ce déroulement : il recherche un canal PCAN-USB, lit ses capacités, l'initialise en CAN XL, en CAN FD ou en CAN classique selon le matériel, émet un message, vide la file de réception puis libère le canal.

mod PCANBasic;
use crate::PCANBasic::*;

const BITRATE: TPCANBaudrate = PCAN_BAUD_500K;
const BITRATE_FD: &str = "\
f_clock_mhz=20, nom_brp=5, nom_tseg1=2, nom_tseg2=1, nom_sjw=1, \
data_brp=2, data_tseg1=3, data_tseg2=1, data_sjw=1";
const BITRATE_XL: &str = "\
f_clock=160000000, brp=1, nom_tseg1=255, nom_tseg2=64, nom_sjw=64, \
fd_tseg1=63, fd_tseg2=16, fd_sjw=16, fd_ssp_offset=0, \
xl_tseg1=10, xl_tseg2=9, xl_sjw=9, xl_ssp_offset=10, xl_error_signaling=1, xl_transceiver_mode_switch=0";

const MESSAGE: TPCANMsg = TPCANMsg { ID: 0x100, MSGTYPE: PCAN_MESSAGE_EXTENDED, LEN: 8, DATA: [0; 8] };
const MESSAGE_FD: TPCANMsgFD = TPCANMsgFD { ID: 0x100, MSGTYPE: PCAN_MESSAGE_FD | PCAN_MESSAGE_BRS, DLC: 15, DATA: [0; 64] };
const MESSAGE_XL: TPCANMsgXL = TPCANMsgXL { PID: 0x100, VCID: 0, AF: 0, RRS: 0, SEC: 0, SDT: 0, MSGTYPE: PCAN_MESSAGE_XL, DLC: 2047, DATA: [0; 2048] };

fn main() {
    let parameters = format!("{}={}", LOOKUP_DEVICE_TYPE, "PCAN_USB");
    let handle: TPCANHandle = match LookUpChannel(¶meters) {
        Ok(handle) => { println!("Looked up channel"); handle }
        Err(status) => { println!("Error looking up channel: {}", status); return; }
    };

    let features: u32 = match GetValueInt32(handle, PCAN_CHANNEL_FEATURES) {
        Ok(features) => { println!("Retrieved features"); features }
        Err(status) => { println!("Error retrieving features: {}", status); return; }
    };
    let is_fd = (features & FEATURE_FD_CAPABLE as u32) == FEATURE_FD_CAPABLE as u32;
    let is_xl = (features & FEATURE_XL_CAPABLE as u32) == FEATURE_XL_CAPABLE as u32;

    let initialize_result = match (is_xl, is_fd) {
        (true, _) => InitializeXL(handle, BITRATE_XL),
        (false, true) => InitializeFD(handle, BITRATE_FD),
        (false, false) => Initialize(handle, BITRATE),
    };
    match initialize_result {
        Ok(_) => println!("Initialized channel"),
        Err(status) => { println!("Error initializing channel: {}", status); return; }
    }

    let write_result = match (is_xl, is_fd) {
        (true, _) => WriteXL(handle, &mut MESSAGE_XL),
        (false, true) => WriteFD(handle, &mut MESSAGE_FD),
        (false, false) => Write(handle, &mut MESSAGE),
    };
    match write_result {
        Ok(_) => println!("Wrote message"),
        Err(status) => println!("Error writing message: {}", status),
    }

    loop {
        let result = match (is_xl, is_fd) {
            (true, _) => ReadXL(handle).map(|_| println!("Received XL message")),
            (false, true) => ReadFD(handle).map(|_| println!("Received FD message")),
            (false, false) => Read(handle).map(|_| println!("Received CC message")),
        };
        match result {
            Ok(_) => continue,
            Err(status) if status == PCAN_ERROR_QRCVEMPTY => break,
            Err(status) => { println!("Error reading message: {}", status); return; }
        }
    }

    match Uninitialize(handle) {
        Ok(_) => println!("Uninitialized channel"),
        Err(status) => println!("Error uninitializing channel: {}", status),
    }
}
Exemple Rust de PCAN-Basic ouvert dans un éditeur de code
Figure 2 — PCAN-Basic 5.1 est livré avec des exemples Rust en console.

Pour une application de production, il est recommandé d'envelopper cette séquence d'appels natifs dans une petite abstraction Rust qui :

  • conserve ensemble le canal et le mode de protocole, pour ne pas mélanger par mégarde les fonctions CAN classique, CAN FD et CAN XL ;
  • convertit chaque code d'état en un type d'erreur Rust parlant, texte d'erreur PEAK compris ;
  • libère le canal par un objet garde (implémentation de Drop), tout en permettant un arrêt explicite ;
  • valide identifiants, types de message, longueurs de données et chaînes de débit avant de franchir la frontière FFI ;
  • vide la file de réception après une notification : un événement signale des données disponibles, il ne remplace pas la lecture ;
  • confine le code unsafe autour des appels FFI et n'expose que des méthodes sûres au reste du programme.

Cas d'usage typiques

  • Test et validation automobiles : stimulation de calculateurs, simulation du reste du bus, tests de non-régression automatisés, intégration HiL, utilitaires de mesure.
  • Diagnostic et outils de service : outils ciblés, en ligne de commande ou de bureau, pour lire des états, émettre des requêtes de diagnostic et conserver des preuves.
  • Acquisition et enregistrement de données : réception à haut débit, traitement des horodatages, filtrage, conversion, création de fichiers PCAN-Trace.
  • Passerelles et ponts : retransmission d'un trafic CAN choisi vers Ethernet, des services cloud, des fichiers ou des bases de données.
  • Production et fin de ligne : utilitaires robustes de configuration, d'identification, de flashage, de vérification et de collecte de résultats.
  • Outillage de développement : générateurs de trames, analyseurs de protocole, outils de rejeu, bancs de fuzzing.
  • Écosystèmes embarqués et IoT : outils compagnons pour les équipes qui emploient déjà Rust sur leurs cibles embarquées.

Ce que Rust garantit, et ce qu'il ne garantit pas

Rust écarte de nombreux défauts de mémoire et de concurrence dans le code sûr, mais un logiciel automobile fiable dépend toujours d'exigences correctes, de la conception du protocole, du comportement temporel, de la configuration matérielle, de la topologie du réseau, de la gestion des erreurs et de la vérification. L'emploi de Rust ou de PCAN-Basic n'établit à lui seul ni la sûreté de fonctionnement, ni la conformité en cybersécurité, ni des garanties temps réel.

Le module FFI relie nécessairement du code Rust sûr à une API native. Il faut donc garder les opérations unsafe réduites, relire attentivement le contrat de l'API, valider longueurs et pointeurs, et bâtir une enveloppe sûre qui reflète fidèlement le cycle de vie d'un canal PCAN-Basic. Ce n'est pas une contrainte propre à PCAN-Basic : c'est la règle chaque fois que Rust s'intègre à une bibliothèque native mature.

En résumé

De plus en plus d'ingénieurs veulent écrire leurs applications CAN sur PC dans le langage qu'ils emploient déjà ailleurs. PCAN-Basic 5.1 y répond avec un module FFI Rust et des exemples prêts à l'emploi. Les développeurs C et C++ y trouvent un moyen de conserver les performances natives tout en confiant au compilateur de nombreux contrôles de mémoire et de concurrence ; les autres, un outillage moderne et une gestion d'erreurs explicite. Et personne ne part d'une page blanche : il suffit de reprendre les exemples officiels, de vérifier la communication avec une interface PCAN, puis de faire évoluer le tout vers une architecture sûre en CAN classique, CAN FD ou CAN XL.

Neutralisé