TP BUS CAN-LIN-I2C Commander par la carte Scan-Lin

1 TP BUS CAN-LIN-I2C Commander par la carte Scan-Lin 189 Avenue de Choisy 75013 Paris

2 Sommaire BUS de terrain CAN (Controller Area Network)... 3 1- Introduction... 3 2- Caractéristiques... 3 3- Origine du bus CAN... 3 4- Présentation du réseau CAN AUTOMOBILE... 4 5- Constitution d une trame CAN... 5 1. Format standard... 5 2. Trame au format étendu... 7 6. Bus LIN (Local Interconnect Network):... 7 a. Caractéristiques... 7 b. Trame LIN... 7 7. Exemple de message lin :... 8 Partie Programmation... 10 Généralité... 11 Q1) Faire un programme qui analyse les messages reçus... 14 Q2) Editez le programme suivante qui servira à monter et descendre les vitres... 14 Q2) Faire un programme servant à monter et descendre les vitres... 15 Q3) Gestion du potentiomètre et du capteur de température en fonction de la vitesse du moteur... 16 Ossature du programme à modifier... 17 Q4) Gestion des hautes priorités :... 17 Application CAR-CAN sur la plateforme CAN-LIN-I2C... 19 Q5) Réception de message :... 19 Q6) Exécution d un message reçu... 21 189 Avenue de Choisy 75013 Paris

3 BUS de terrain CAN (Controller Area Network) 1- Introduction Le CAN a été lancé en 1990 pour répondre aux besoins de l'industrie automobile devant la montée de l'électronique embarquée. ). Bien plus qu'un bus au sens électrique, le bus CAN est un réseau à part entière respectant le modèle d'interconnexion des systèmes ouverts OSI(operation system information) de l'iso. C'est un réseau de terrain aussi car il doit fonctionner dans un environnement limité et sévère comme une usine, un atelier, une voiture Le bus/réseau CAN, standard de fait, est promu à un essor rapide. En 2005 une voiture moyenne comporte une centaine de microcontrôleurs. Pour éviter les 2 kms de câblage d'une grosse voiture actuelle, soit 100 kg de cuivre, il fallait définir un bus série simplifiant énormément l'intégration des fils dans le châssis. 2- Caractéristiques Bus série asynchrone Jusqu à 1 Mbps (réseaux < 40 m) et 125 kbps (réseau < 500 m). Un seul message à la fois Tous les nœuds peuvent envoyer des messages Tous les nœuds reçoivent les messages Les conflits (collisions) et les erreurs sont gérés automatiquement Chaque message possède un identifiant Un nœud peut filtrer les identifiants pour ne conserver que certains messages Couches 1 et 2 du modèle OSI (Physique et liaison de données) Bus Multi-Maîtres Bidirectionnel Différentielle : moins sensible aux perturbations(bruits) 3- Origine du bus CAN Avec plus de 2000 m de câble dont 1800 connexions en 1995, La fiabilité et la sécurité sont menacées. Les normes en matière de pollution et de consommation d énergie multiplient les capteurs et actionneurs intelligents. Le besoin de sécurité accrue (ABS, ESP, AIR-BAG ) et la demande de confort (mémorisation des réglages de conduite, climatisation régulée par passager, système de navigation ) ne font que renforcer cette tendance. 189 Avenue de Choisy 75013 Paris

4 Suite à ces avantages, les composants CAN se démocratisent et investissent d autres secteurs de l industrie (engins travaux publique, agricole, médical, produits numériques, systèmes électrotechnique ) 4- Présentation du réseau CAN AUTOMOBILE En pratique, il y a trois bus CAN différents dans une voiture, à des débits différents : un bus très rapide pour gérer la sécurité (freinage, ABS, détection chocs, airbags...) ; un bus à vitesse moyenne pour gérer le moteur (commandes et capteurs) ; un bus lent pour gérer tous les accessoires (lampes, moteurs d asservissements, boutons...). Il existe sous deux versions : CAN2.0A : trame standard identificateur de 11 bits (CAN standard) ; CAN2.0B : trame plus longue avec identificateur sur 29 bits (CAN étendu). 189 Avenue de Choisy 75013 Paris

5 Dans nos cartes de simulation du bus CAN, on propose une version standard (4 bit) et étendu (1 octet) : Il existe également cinq débits possibles (k bits/s): 500 250 200 100 50 5- Constitution d une trame CAN 1. Format standard Une trame est répartie en 7 champs: 189 Avenue de Choisy 75013 Paris

6 Le début de trame SOF (Start Of Frame), 1 bit dominant ; la ligne étant précédemment au repos. Composée de 12 bits (zone d'identification de la trame (11 bits + RTR) : les 11 premiers indiquent l identité du contenu du message, et servent également à l arbitrage (gestion des priorités) bit RTR (Remote Transmission Request) : détermine s'il s'agit d'une trame de données (ex : régime moteur) ou d'une d une trame de demande de message (ex : demande de T eau). Le bit à 0 (dominant) pour une trame de données et le bit à 1 (récessif) pour une trame de demande. Champ de commande constitué de 6 bits : les 2 premiers serviront pour une éventuelle évolution du protocole (bits de réserve) ; les 4 derniers permettent de coder le nombre d octets du champ de données. Ce champ contient de 0 à 8 octets de données (64 bits maxi) Zone CRC (Cyclic Redundancy Code) de 15 bits : Ces bits sont recalculés à la réception et comparés aux bits reçus. S'il y a une différence, une erreur CRC est déclarée Zone d'acquittement (ACKnowledge) est composé d'un bit à l'état récessif ainsi qu'un bit séparateur ACK. Le premier bit doit être forcé à l'état dominant par les stations ayant bien reçu cette trame. Zone de fin de trame EOF (End Of Frame), 7 bits récessifs (à l état 1). 189 Avenue de Choisy 75013 Paris

7 Remarque : 3 bits à l état 1 séparent obligatoirement 2 trames consécutives 2. Trame au format étendu Champ d arbitrage : SRR (Substitute Remote Request). IDE (Identifier Extension bit) qui établit la distinction entre format standard (état dominant) et format étendu (état récessif). RTR (Remote Transmission Request) détermine s'il s'agit d'une trame de données ou d'une trame de demande de message. 6. Bus LIN (Local Interconnect Network): a. Caractéristiques - Débit jusqu à 20kbs et peut avoir un niveau de tension de 0 jusqu à 18volt. - Asynchrone -Bus Single Master / Multi Slave (up to 16) -Bidirectionnel -Half duplex Le BUS LIN permet une communication économique dans les applications où la bande passante et la polyvalence du CAN ne sont pas requises. b. Trame LIN 189 Avenue de Choisy 75013 Paris

8 Break : Permet à l esclave de détecter la présence d un message sur le bus. Il est constitué d au moins 13 zéros. Synchronisation : Sync est défini comme étant le caractère 0x55. Ce caractère permet d'effectuer une détection automatique de la vitesse de transfert afin d ajuster l horloge pour la récupération de la suite du message. Identifiant du message : Il correspondra à une adresse logique d un nœud esclave. Chaque nœud possède une adresse différente et peut avoir plusieurs adresses. Data: Ce champ est transmis par la tâche esclave et contient de 1 à 8 octets. Checksum : Somme de contrôle (1 octet) Cette réponse est toujours introduite par un nœud esclave. A noter qu un nœud esclave peut être contenu par un module maître. 7. Exemple de message lin : On va envoyer un message lin permettant d écrire sur les trois afficheurs 7 segments. Il faut donc connaître l identifiant des afficheurs, comprendre comment écrire. On met une valeur en hexa dans le logiciel SCAN_ANALYSE et les trois afficheurs 7 segments affichent cette valeur en décimal. Pour réaliser cela, on va suivre les étapes suivantes après avoir câblé a) Câblage! 189 Avenue de Choisy 75013 Paris

9 b) Paramétrage et Envoi du message Dans un premier temps, il convient d ouvrir le logiciel SCAN_ANALYSE fourni avec la carte et paramétrez le comme suit : - Envoi du message LIN en spécifiant l identifiant du composant à commander, le type de message à envoyer et type de trame à capturer. On a envoyé la valeur 00 FF (équivalent de 255 en décimal) vers les afficheurs 7 segments (qui ont comme identifiant 20). On va donc choisir une trame de type données, et une trame de 1 quartet vu la taille des données que l on veut envoyer à travers le bus vers les afficheurs 7 segments. Voici la trame obtenue sur l analyseur du logiciel SCANLIN_ANNALYSE en capturant le bus LIN-1. Par souci de place, on a mis la trame en 2 parties 189 Avenue de Choisy 75013 Paris

10 -affichage de la valeur FF envoyé par le bus LIN en décimale sur les afficheurs 7 segments de la carte CAR-SCAN. Partie Programmation Pour que l on puisse faire communiquer la carte SCAN-LIN avec la carte CAR-SCAN-I2C, il faut respecter les étapes fournies dans le manuel de prise en main de MPLABX V3.05 pour les modules CAR-SCAN. Ensuite, Lire attentivement ce manuel pour comprendre comment reprogrammer les PIC18 (de la carte fille) et du DsPIC (de la carte mère). Programmer le DSPic de la carte SCAN-LIN (carte mère) avec le programme USER_CANLIN_MONITEUR que l utilisateur pourra modifier sur MPLABX et mettre l interrupteur SW5 de la carte à la position P pour pouvoir programmer le DSPic, ne pas oublier de remettre en position N une fois la programmation finie. Programmer Z1 (pic 18 du micro CAN de la carte fille) et Z2 (pic 18 du micro LIN de la carte fille) respectivement avec les programmes USER_CAR_CAN_MONIT et USER_CAR_LIN_MONIT. Remarque : Les programmes USER_CANLIN_MONITEUR, USER_CAR_CAN_MONIT, USER_CAR_LIN_MONIT fournis avec les cartes contiennent déjà la base pour développer un TP. 189 Avenue de Choisy 75013 Paris

11 Travaux pratiques : Généralité Une application va être mise en place associant : les boutons à des actions ainsi que des variables telles que : Choc (boutton CH) = variable CAR_Stat_bt_CH Démarrage (DM) = CAR_Stat_bt_DM Vitre Montée (VM) = CAR_Stat_bt_VM Vitre descendue (VD) = CAR_Stat_bt_VD Porte (PT) = CAR_Stat_bt_PT Ceinture (CT) = CAR_Stat_bt_CT Le Potentiomètre (POTAR) est associé à un accélérateur avec la variable CAR_Stat_Accel Les 8 Leds <RL2> sont associées au niveau de la vitre avec la variable CAR_Stat_Vitre La variable CAR_Stat_Proxi mémorise la valeur du capteur de proximité La variable CAR_Stat_Chauf indique la valeur de l'indicateur de la température du moteur Les identifiants acceptés par la CAR_CAN sont des identifiants <standard> (sur 11 bits) MSG_CAN_RX_LED_CH MSG_CAN_RX_LED_DM MSG_CAN_RX_VITESSE MSG_CAN_RX_GETPROXI MSG_CAN_RX_MOTEUR MSG_CAN_RX_GETSTATUS MSG_CAN_RX_POOLPROXI MSG_CAN_RX_RESET_NODE 0x01 0x02 0x03 0x04 0x07 0x08 0x09 0x0A Les identifiants acceptés par la CAR_LIN sont des identifiants <standard> (sur 11 bits) MSG_LIN_RESET 0x00 MSG_LIN_LECBVMVD 0x04 MSG_LIN_LECBPTCT 0x08 MSG_LIN_LEDBOUTON 0x0C MSG_LIN_LEDNIVEAU 0x10 MSG_LIN_SEG_DECI 0x14 MSG_LIN_SEG_HEXA 0x18 MSG_LIN_SEG_BINR 0x1C MSG_LIN_BUZZER 0x20 MSG_LIN_CHGENUMNODE 0x24 MSG_LIN_CHGEVITLIN 0x28 MSG_LIN_CHGEVITCAN 0x2C MSG_LIN_CHGEPARAMS 0x30 MSG_LIN_CARILLON 0x34 189 Avenue de Choisy 75013 Paris

12 Le fonctionnement global des modules associés à l application CAR-SCAN à établir est le suivant : Pour faire tourner le moteur, il faut : - La Led CH doit être éteinte (appuyer sur le bouton CH si nécessaire) - Fermer la porte (Led PT éteinte) - Boucler la ceinture (Led CT éteinte) - Appuyer sur le bouton DM pour une marche en avant. -Pour une marche en arrière, il faut appuyer sur le bouton CH puis sur DM. Lorsque le moteur tourne : - Augmenter ou diminuer la vitesse en tournant le POTAR (potentiomètre) - l'afficheur SEG0 indique par un chiffre entre 0 et 7, le rapport de la <boîte de vitesse>. - les afficheurs SEG3-SEG2-SEG1 indiquent la vitesse donnée par l'encodeur du moteur. Si on appuie sur le bouton CH, on simule un choc : -Le moteur doit s'arrêter et activer le buzzer. -Le capteur de proximité est activé et la valeur qu'il envoie est affichée sur SEG3-SEG2-SEG1. -Il faut appuyer sur le bouton CH pour arrêter le buzzer et le capteur. -Le moteur s arrête en appuyant sur le bouton DM. Les mouvements de la vitre sont activés par les boutons : - VM pour monter et allumer les leds de RL2 une à une. - VD pour descendre et éteindre les leds de RL2 une à une. 189 Avenue de Choisy 75013 Paris

13 Application CAN-LIN-I2C sur les plateformes SCAN-LIN Remarque : Il faut suivre les instructions données dans le manuel MPLAB dédié à la programmation des PIC18F et des DSPIC fourni avec ses cartes. Partie 1 : Microcontrôleur Z1 (DsPIC-30F5011) pour la gestion de la carte Mère ( Scan lin) SYNOPTIQUE DE LA CARTE 189 Avenue de Choisy 75013 Paris

14 Q1) Faire un programme qui analyse les messages reçus void Car_Scan_Appli(void) // Pilotage de la carte CAR-SCAN par le système superviseur SCAN_LIN { // analyser les messages CAN reçues while (1) { if (CAR_Flag_Periode!= 0) { // à chaque expiration du Timer, on appelle la fonction qui allume ou éteint une Led supplémentaire // L'attente et la lecture d'un message CAN est une fonction de la librairie. Elle renseigne la variable <Can_MsgSid> et le // tableau <Can_MsgBuf> (données du message) break; // il n'y a pas de message // Le numéro de la carte et le numéro du message est dans la variable <Can_MsgSid> (voir le fichier SCANLIN_MSG_CAN.h) // Pour un message CAN en réception, le numéro de carte est sur les bits 7 à 4 // Pour un message LIN à envoyer, le numéro de carte doit être mis sur les 2 bits de poids faible // Analyser le message et décider quoi faire, si message = changement de l'indicateur de <chauffe> if (msge == MSG_CAN_TX_CHGE_CHAUF) { // Mémoriser la nouvelle valeur dans la variable // si message = bouton <CH> est appuyé else if (msge == MSG_CAN_TX_CHGE_CH) { // si message = bouton <DM> est appuyé else if (msge == MSG_CAN_TX_CHGE_DM) { // si message = changement de la position du POTAR else if (msge == MSG_CAN_TX_CHGE_POTAR) { // si message = bouton <VM> ou <VD> est appuyé else if (msge == MSG_CAN_TX_CHGE_VMVD) { // Si l'état des boutons n'est pas dans le message alors envoyer un message pour lire l'état des 2 boutons //Pour démarrer l'animation : Car_MonteDescVitre(); cette fonction démarre le Timer qui permet d'envoyer les // messages périodiques pour allumer ou éteindre une nouvelle Led et utiliser Car_StartPeriode(); // Si message = bouton <PT> ou <CT> est appuyé else if (msge == MSG_CAN_TX_CHGE_PTCT) { // Si message = nouvelle valeur de l'encodeur du moteur else if (msge == MSG_CAN_TX_VAL_ENCOD) { // Si message = nouvelle valeur du capteur de proximité else if (msge == MSG_CAN_TX_CHGE_PROXI) { Q2) Editez le programme suivante qui servira à monter et descendre les vitres 189 Avenue de Choisy 75013 Paris

15 Q2) Faire un programme servant à remonter et descendre les vitres void Car_MonteDescVitre(void) // Allumer (bouton VM) ou éteindre (bouton VD) une Led supplémentaire { // si le bouton VM est appuyé et pas le bouton VD if (CAR_MoveVitre == 0x01) { // monter //vérifier que tous les bits ne sont pas tous à 1, si c est le cas on ajoute 1 bit à 1 //et on affiche //if (...) { // // si le bouton VD est appuyé et pas le bouton VM else if (CAR_MoveVitre == 0x80) { // descendre // si les bits ne sont pas tous à 0, on enlève 1 bit à 1 et // on affiche //if (...) { // Application CAN sur les plateformes CAR-SCAN et SCAN-LIN Partie2 : Microcontrôleur Z1 (PIC-18F2480) pour la gestion du BUS CAN pour commander la carte fille (Car- Scan-I2C) Programmation Bus Can : Gestion du moteur et du capteur de proximité. Schéma global : 189 Avenue de Choisy 75013 Paris

16 Il faut suivre les instructions données dans le manuel MPLAB dédié à la programmation des PIC18F et des DSPIC fourni avec les cartes. Importer le projet et éditez le programme USER_CAR_CAN_MONIT en suivant les indications données sur les questions et les commentaires de l ossature du code. Ce dernier étant la base du TP à modifier. Q3) Gestion du potentiomètre et du capteur de température en fonction de la vitesse du moteur Suivez l arborescence USER_CAR_CAN/Souces Files/ CARCAN_APPLIC et modifiez le programme pour mettre en place les taches détaillés dans l ossature donnée à la page suivante : Tous les paramètres utiles à la réalisation de cette fonction sont déjà initialisés dans CARSCAN_AMAIN.c et dans Header files. Par la suite, des explications sur les paramètres à utiliser pour réaliser cette fonction seront données. Pour d ample explication, voir la documentation CAR_SCAN_V2 pour comprendre les différents identifiant utilisé : -MSG_CAN_TX_CHGE_CHAUF : <Identifiant> = 0x04 ; data = D0 Ce message est envoyé au superviseur en réponse à la réception d un message <MSG_CAN_RX_GETPROXI>, ou périodiquement quand la scrutation du capteur de proximité est activée. L octet D0 du champ de données donne la valeur de la tension délivrée par le capteur (entre 0x00 et 0xFF) 189 Avenue de Choisy 75013 Paris

17 Ossature du programme à modifier void Lecture_Periode(void) //----------------------------------------------- { BYTE Old_Val, diff; 1) Tester l'indicateur de température du moteur chauffe moteur (bit TSD_MOTOR) 2) S'il a changé d'état, envoyer un message au superviseur avec Can_Send_Msge(MSG_CAN_TX_CHGE_CHAUF, 1); 3) Si la scrutation est activée, lire le capteur de proximité 4) Définir les conditions d'activation 5) Si la différence entre nouvelle et ancienne valeur est supérieure au seuil alors -Envoyer un message can au superviseur SCAN-LIN en utilisant Can_Send_Msge(MSG_CAN_TX_CHGE_PROXI, 1); 6) Lire l état potentiomètre suivant des conditions d'activation qui sont définis selon l application - si la différence entre nouvelle et ancienne valeur est supérieure au seuil alors -envoyer un message au superviseur if (Scrut_Encod!= 0) { diff = Val_Encod - Old_Encod; if (diff & 0x80) diff = ~diff + 1; if (diff > 4) { Val_Msge1 = Val_Encod >> 8; Val_Msge2 = Val_Encod; Old_Encod = Val_Encod; Can_Send_Msge(MSG_CAN_TX_VAL_ENCOD, 2); Q4) Gestion des hautes priorités : 189 Avenue de Choisy 75013 Paris

18 Répondre à cette question en complétant le programme suivant void Intr_High(void) //--------------------------------------------------- // Interruptions de <high> priorité // INT0 (bouton <CH>), INT1 (bouton <DM>) et bus CAN //--------------------------------------------------- { // Tester INT0 if (INTCONbits.INT0IF) { Action à faire : - envoyer un message au superviseur -effacer cette interruption // Tester INT1 Action à faire : - envoyer un message au superviseur -effacer cette interruption //Tester INT2 Action à faire -Comme il est non utiliser, ne rien faire - effacer cette interruption // Test des interruptions du bus CAN if (PIR3!= 0) { // le module CAN est configuré en mode 0 Action à faire : -appeler une fonction pour plus de clarté -tester l erreur de bus if (PIR3bits.ERRIF) { Action à faire : -reconfigurer le bus // le module CAN a deux buffer de réception (0 et 1), on va donc tester les 2 buffers // test reception buffer 0 If (PIR3bits.RXB0IF) { Action à faire : -appeler la fonction de réception, lecture et d'analyse du message - effacer le message // test réception buffer 1 if (PIR3bits.RXB1IF) { Action à faire : -appeler la fonction de réception, lecture et d'analyse du message - effacer le message // Ignorer les autres interruptions et effacer les flags 189 Avenue de Choisy 75013 Paris

19 Application LIN sur les plateformes CAR-SCAN et SCAN-LIN Partie3 : Programmation du microcontrôleur Z2 (PIC-18F2480) pour la gestion du BUS LIN pour commander la carte fille (Car-Scan-I2C) Un schéma global : Q5) Réception de message : Ecrire une fonction qui sert à Analyser les messages reçus : Elle sera appelée à chaque réception de message et aura comme but d analyser la trame reçue pour ensuite l adresser au module ou composant que le message a été destiné. Editez l ossature en dessous. Cette fonction se trouve dans l arborescence USER_CAR_LIN/Souces Files/ CARLIN_APPLIC.c : 189 Avenue de Choisy 75013 Paris

20 void Recep_Message(void) // Fonction appelée à chaque réception d'un octet. // La variable Start_Trame indique le numéro de l'octet // La variable Rcp_Data contient l'octet { // Start_Trame == 1 apres reception du <break> If(on a bien reçu une trame) Action à faire Si le début du trame =0x55 //Annuler la trame goto sortie; else if (on a reçu une trame valable) { Action à faire -vérification de l Identifiant if ((Si l identifiant du message reçu et le masque sont différent de zéro) // si c est égal à zero faut reseter && (Identifiant du message &masque du nœud est différent d un numéro de node LIN) { Action à faire Annuler la trame et sortir car le message n'est pas pour ce module Rcp_Data &= LIN_MSGE_MASQ; // garder juste la fonction *(Msge_wr+Rcp_Idc) = Rcp_Data; // Fonction Rcp_Idc++; if (Rcp_Data == MSG_LIN_LECBVMVD Rcp_Data == MSG_LIN_LECBPTCT) { // c' est le module qui fournit les data et le crc Action à faire Désactiver l interruption, terminer la trame et Appeler le flag goto sortie; else if ( trame = 4) { // data-1 ou Crc *(Msge_wr+Rcp_Idc) = Rcp_Data; // Incremente Rcp_Idc Rcp_Ok =1; // Trame Ok = reception break+synchro+ident+crc else if (Start_Trame == 5) { // data-2 ou Crc *(Msge_wr+Rcp_Idc) = Rcp_Data; // - Incremente Rcp_Idc Rcp_Nbd=1; // data-1 + crc else if (Start_Trame == 6) { // data-3 ou Crc *(Msge_wr+Rcp_Idc) = Rcp_Data; // -Incremente Rcp_Idc; -Mettre Rcp_Nbd à 2; // data-1,2 + crc else if (Start_Trame == 7) { // Crc *(Msge_wr+Rcp_Idc) = Rcp_Data; // -Mettre Rcp_Nbd à 3; // data-1,2,3 + crc Sortie: return; 189 Avenue de Choisy 75013 Paris

21 Q6) Exécution d un message reçu Suivre l arborescence USER_CAR_LIN/Souces Files/ CARLIN_APPLIC.c et éditez ce programme pour mettre en place les taches détaillés dans l ossature suivante. Le but est : Analyser tous les types de message qui sont contenus dans CARLIN_FONC.h Exécuter les messages reçus. On aura donc 11 types de messages à analyser et à exécuter les fonctions correspondante : Par exemple rester la carte, allumer une LED, allumer un afficheur 7 segment, démarrer le buzzer. Voici les types de message à exécuter en se servant de l ossature données en dessus. MSG_LIN_RESET MSG_LIN_LEDBOUTON MSG_LIN_LEDNIVEAU MSG_LIN_SEG_DECI MSG_LIN_SEG_HEXA MSG_LIN_SEG_BINR MSG_LIN_BUZZER MSG_LIN_CARILLON MSG_LIN_CHGENUMNODE MSG_LIN_CHGEVITLIN MSG_LIN_CHGEVITCAN MSG_LIN_CHGEPARAMS void Execute_Message(void) // Exécuter la fonction correspondante au message (M_fonc) réçue // M_fonc = un message MSG_LIN_xxx (fichier SCANLIN_MSG_LIN.h){ if (M_fonc == MSG_LIN_RESET) { Reset_Flag = 1; // pour réinitialiser le micro //else if (M_fonc == MSG_LIN_xxx && M_nbdat >= n) { Action à faire // fonction_du_message(); // fichier "CARLIN_FONC.h" et cité avant //else if (...) { //... 189 Avenue de Choisy 75013 Paris