View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Envoi d'une chaine de caractères d'une carte Arduino vers une autre carte Arduino via deux interfaces Processing Client/Serveur sur 1 seul PC.

Présentation

  • Cet ensemble de 4 programmes permet de faire communiquer entre-elles 2 cartes Arduino via deux interfaces Processing Client/Serveur réseau, en utilisant le réseau local de la machine (ip : 127.0.0.1).
  • La procédure pourra sembler "compliquée" à première vue pour ce que l'on veut faire, mais en fait il s'agit d'une base très utile pour développer sur un même poste les 4 programmes de la chaine de communication, les interfaces Processing Client/Serveur réseau pouvant ensuite être déployée sur un vrai réseau avec machine distante. Mais utiliser d'emblée le réseau avec machine distante rend assez chronophage le développement et le codage, d'où la solution que je propose ici.

Le montage utilisé :

  • 2 cartes Arduino sont connectées sur le même PC :
    • une des cartes est celle d'où partira la chaine de caractère et est appelée client. Elle utilisera son propre port série.
    • l'autre cartes est celle qui recevra la chaine de caractère et est appelée serveur. Elle utilisera son propre port série.

Truc : pour fixer le numéro des ports USB sous Ubuntu, il suffit de brancher les cartes Arduino dans l'ordre successif voulu : la première carte branchée sera sur le port série USB0, la deuxième sur le port USB 1.

Procédure à suivre

  • Programmmer la carte Arduino "client" sur le port USB0
  • Programmer la carte Arduino "serveur" sur le port USB1
  • Lancer le programme Processing SERVEUR en premier, c'est important.
  • Lancer le programme Processing CLient en deuxième.
  • L'intérêt évident ici est de pouvoir développer tous les programmes de la "chaine" sur le même poste : il sera toujours temps de déployer les programmes ensuite sur un vrai réseau.
  • On verra les messages suivants dans la console de Processing, témoignant du parcours de la chaine de caractères.

Le programme Arduino "Client"

Explication

  • Ce programme envoie tout simplement une chaîne sur le port série à intervalle régulier.
  • La carte Arduino "client" utilise le port série USB0 dans mon cas. J'ai donc ouvert une première instance du logiciel Arduino et j'ai sélectionné ce port dans le logiciel Arduino.
  • A noter que ce programme peut être testé simplement dans le Terminal Série sur le même port.

Le programme Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 31/3/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Ce programme envoie une chaine à intervalle régulier sur le port Série. */

// --- Fonctionnalités utilisées ---

// Utilise la connexion série matérielle vers le PC
// Utilise / fonctionne avec une interface Processing coté PC

// -------- Circuit à réaliser ---------

// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)


// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

// --- Déclaration des constantes utiles ---

// --- Déclaration des constantes des broches E/S numériques ---


// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---




// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---


// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

Serial.begin(115200); // initialise connexion série matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission


// ------- Broches en sorties numériques -------  

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// ------- Initialisation des variables utilisées -------  

// ------- Codes d'initialisation utile -------  

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()


// --- ici instructions à exécuter par le programme principal ---

Serial.println("ma chaine");

delay(5000);


//while(1); // stop loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////


// ////////////////////////// Fin du programme ////////////////////

 

Le programme Processing Client réseau

Explication

  • Ce programme sert de "relais" pour l'envoi de la chaine reçue sur le port Série vers le réseau local de la machine.
  • Ce programme d'une part reçoit la chaine sur le port Série de la carte Arduino "client" (USB0 pour moi)
  • Ce programme d'autre part crée un Client réseau et envoie la chaine reçue sur le port série vers le réseau à l'adresse 127.0.0.1 sur le port 12345.
  • Attention : vous devrez installer la police voulue (dans Processing : Tools > Create Font..) ou mettre en commentaire les lignes utilisant la police texte.

Programme


// Programme processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT - Avril 2011 - tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise un Client réseau : ce programme nécessite un serveur réseau accessible

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.serial.*; // importe la librairie série processing

import processing.net.*; // importe la librairie pour connexion réseau Client/Serveur

// déclaration objets

// --- port Série ---
Serial  myPortClientBoard; // Création objet désignant le port série de la carte Arduino Client

// --- objet Client Réseau ---
Client myClientNetwork; // déclaration d'un objet client réseau
String inStringServerNetwork; // pour réception chaine en provenance Serveur Réseau
String inStringClientBoard; // pour réception chaine en provenance carte Arduino Client

// --- police texte ---
PFont fontA; // crée un objet de police texte

// déclaration variables globales

//------ déclaration des variables de couleur utiles ----
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);


// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

        // ---- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc...
        fill(0,0,255); // couleur remplissage RGB
        stroke (0,0,0); // couleur pourtour RGB
        rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
        imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
        //strokeWeight(0); // largeur pourtour
        frameRate(30);// Images par seconde

        // --- initialisation fenêtre de base ---
        size(200, 150); // ouvre une fenêtre xpixels  x ypixels
        background(vert); // couleur fond fenetre

// --- initialisation des objets et fonctionnalités utilisées ---

        //------------- initialisation de la police texte - à mettre avant série ----
        fontA = loadFont("Arial-Black-14.vlw"); // charge le fichier police dans l'objet police texte
        // ce fichier doit être présent dans un rép <data> dans le répertoire du programme
        // pour générer un fichier de police à partir des polices système aller dans Tools > create Fonts
        // voir également http://processing.org/learning/text/

        textFont(fontA, 14); // Initialise la police et sa taille (en pixels)

        text("Client Processing actif !", 10, 60);

        //------------- initialisation port série ----
        println(Serial.list()); // affiche dans la console la liste des ports séries
        // Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec  Serial.list()[index]
        myPortClientBoard = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série carte Arduino Client
        //myPort = new Serial(this, "/dev/ttyUSB0", 115200); // Initialise une nouvelle instance du port Série carte Arduino Client
        myPortClientBoard.bufferUntil('\n'); // attendre arrivée d'un saut de ligne pour générer évènement série

//------------- initialisation objet Client réseau ----
  // Connexion du Client au serveur ayant l'adresse indiquée et sur le port indiqué
  // 127.0.0.1 pour connexion en local sur la machine
  myClientNetwork = new Client(this, "127.0.0.1", 12345); // Remplacer avec l'adresse IP du serveur et le numéro de port utilisé
  //myClient = new Client(this, "192.168.1.13", 5905); // pour réseau local sur port 5905
  // info : le port utilisé doit être ouvert sur le PC client et le PC serveur ainsi que sur le routeur du réseau


} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

        //------------- Code pour port série ----
        //  myPort.write('H'); // envoie le caractère sur le port Série
        // myPort.write("chaine\n"); // envoie la chaine suivi saut ligne sur le port Série
        //------------- Code pour Client Réseau ----

      // myClientNetwork.write("ma chaine "+"\n"); //--- envoie une chaine vers le Serveur  suivie d'un saut de ligne
      // delay(1000); // entre deux envois


        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

        //------------- Fonction de gestion des évènements série ----
         void serialEvent (Serial myPortClientBoard) { // fonction appelée lors de la survenue d'un évènement série

        // ******** Gestion de la valeur reçue sur le port série depuis la carte Arduino Client **********

        String inStringClientBoard = myPortClientBoard.readStringUntil('\n'); // chaine stockant la chaîne reçue sur le port Série depuis la carte Arduino Client
        // saut de ligne en marque de fin

        if (inStringClientBoard != null) { // si la chaine recue n'est pas vide

                // print (inString); // affichage brut de la chaine recue
                inStringClientBoard = trim(inStringClientBoard); // enlève espace blancs de la chaine recue
                //int inByte_brut=int(inStringClientBoard); // conversion valeur reçue en valeur numérique entiere
                //float inByte = float(inStringClientBoard); // conversion valeur reçue en valeur numérique décimale

                println("1. Client Arduino ==> client Processing : "+ inStringClientBoard); // affiche la chaine dans la console

                //----- renvoie la chaine reçue vers le Serveur Réseau ----
                myClientNetwork.write(inStringClientBoard+"\n"); //--- envoie une chaine vers le Serveur  suivie d'un saut de ligne
                delay(1000); // entre deux envois


        } // fin condition chaine recue pas vide


} // fin de la fonction de gestion des évènements Série

//---- fin du programme - -------------------
 

Le programme Processing Serveur réseau

Explications

  • Ce programme sert de "relais" pour l'envoi de la chaine reçue depuis le Client du réseau local de la machine vers la carte Arduino Serveur via le port Série où est connecté cette carte Arduino.
  • Ce programme d'une part crée un Serveur réseau (adresse 127.0.0.1) et reçoit la chaine reçue via le réseau sur le port 12345.
  • Ce programme d'autre part envoie la chaine sur le port Série de la carte Arduino "serveur" (USB1 pour moi)
  • Attention : vous devrez installer la police voulue (dans Processing : Tools > Create Font..) ou mettre en commentaire les lignes utilisant la police texte.

Programme


// Programme processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT - Avril 2011 - tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise un Serveur réseau

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.serial.*; // importe la librairie série processing

import processing.net.*; // importe la librairie pour connexion réseau Client/Serveur

// déclaration objets

// --- port Série ---
Serial  myPortServerBoard; // Création objet désignant le port série de la carte Arduino "serveur"
String inStringServerBoard; // pour réception chaine en provenance carte Arduino "serveur"

// --- objet Client Réseau ---
Client myClientNetwork; // déclaration d'un objet client réseau (pour réception données depuis client réseau)

// --- objet Serveur Réseau ---
Server myServerNetwork; // déclaration d'un objet Serveur réseau
String inStringClientNetwork; // pour réception chaine en provenance Client réseau


// --- police texte ---
PFont fontA; // crée un objet de police texte

// déclaration variables globales

//------ déclaration des variables de couleur utiles ----
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);


// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

        // ---- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc...
        fill(0,0,255); // couleur remplissage RGB
        stroke (0,0,0); // couleur pourtour RGB
        rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
        imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
        //strokeWeight(0); // largeur pourtour
        frameRate(30);// Images par seconde

        // --- initialisation fenêtre de base ---
        size(200, 150); // ouvre une fenêtre xpixels  x ypixels
        background(jaune); // couleur fond fenetre

// --- initialisation des objets et fonctionnalités utilisées ---

        //------------- initialisation de la police texte - à mettre avant série ----
        fontA = loadFont("Arial-Black-14.vlw"); // charge le fichier police dans l'objet police texte
        // ce fichier doit être présent dans un rép <data> dans le répertoire du programme
        // pour générer un fichier de police à partir des polices système aller dans Tools > create Fonts
        // voir également http://processing.org/learning/text/

        textFont(fontA, 14); // Initialise la police et sa taille (en pixels)

        text("Serveur Processing actif !", 10, 60);


        //------------- initialisation port série ----
        println(Serial.list()); // affiche dans la console la liste des ports séries
        // Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec  Serial.list()[index]
        //myPortServerBoard = new Serial(this, Serial.list()[1], 115200); // Initialise une nouvelle instance du port Série
        myPortServerBoard = new Serial(this, "/dev/ttyUSB1", 115200); // Initialise une nouvelle instance du port Série - utilisé par la carte Arduino "serveur"
        myPortServerBoard.bufferUntil('\n'); // attendre arrivée d'un saut de ligne pour générer évènement série

//------------- initialisation objet Serveur réseau ----
   myServerNetwork = new Server(this, 12345); // Ouvre un simple Serveur - Remplacer avec le numéro de port utilisé
  //myServer = new Server(this, 5905); // Ouvre un simple Serveur sur port 5905

  // info : le port utilisé doit être ouvert sur le PC client et le PC serveur ainsi que sur le routeur du réseau
  // info : l'adresse du serveur devra être utilisé par le client


} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

        //------------- Code pour port série ----
        //  myPort.write('H'); // envoie le caractère sur le port Série
        // myPort.write("chaine\n"); // envoie la chaine suivi saut ligne sur le port Série

//------------- Code pour Serveur Réseau ----

  myClientNetwork = myServerNetwork.available(); // l'objet client est un client connecté au serveur si il existe

  if (myClientNetwork != null) { // si myClient existe

    inStringClientNetwork = myClientNetwork.readString(); // lit la chaine envoyée par le Client
    print ("2. client Processing ==> serveur Processing : "+inStringClientNetwork); // affiche la chaine reçue
    //inStringClient = inStringClient.substring(0, inStringClient.indexOf("\n")); // Garde uniquement ce qui est avant le saut de ligne

    //--------- renvoi de la chaine sur le port Série de la carte Arduino serveur
    myPortServerBoard.write(inStringClientNetwork); // envoie la chaine suivi saut ligne sur le port Série

  } // fin si client existe


        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

        //------------- Fonction de gestion des évènements série ----
         void serialEvent (Serial myPortServerBoard) { // fonction appelée lors de la survenue d'un évènement série


        // ******** Gestion de la valeur reçue sur le port série : **********

        String inStringServerBoard = myPortServerBoard.readStringUntil('\n'); // chaine stockant la chaîne reçue sur le port Série
        // saut de ligne en marque de fin

        if (inStringServerBoard != null) { // si la chaine recue n'est pas vide

                // print (inString); // affichage brut de la chaine recue
                inStringServerBoard = trim(inStringServerBoard); // enlève espace blancs de la chaine recue
                //int inByte_brut=int(inStringServerBoard); // conversion valeur reçue en valeur numérique entiere
                //float inByte = float(inStringServerBoard); // conversion valeur reçue en valeur numérique décimale

                println("3. Serveur Processing ==> Serveur Arduino : "+ inStringServerBoard); // affiche la chaine dans la console

                println(); //
                println("--------------------------------------------------"); //
                println(); //

        } // fin condition chaine recue pas vide



} // fin de la fonction de gestion des évènements Série

// ------ fin du programme ------------------
 

Le programme Arduino "Serveur"

Explication

  • Le programme sur la carte Arduino "serveur" va recevoir la chaine envoyée par Processing sur son port série et va renvoyer cette chaine pour affichage vers l'interface Processing afin d'attester que la chaine a bien été reçue.

On pourra tester ce programme simplement à l'aide du Terminal Série : saisir une chaine dans le champ et clic sur <send>. Le message accusant réception s'affichera dans la console Série.

Le programme Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 31/3/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Ce programme reçoit une chaine sur le port Série et renvoie la chaine reçue pour attester que la chaine est bien reçue.  */

// --- Fonctionnalités utilisées ---

// Utilise la connexion série matérielle vers le PC
// Utilise / fonctionne avec une interface Processing coté PC

// -------- Circuit à réaliser ---------

// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)


// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

// --- Déclaration des constantes utiles ---

// --- Déclaration des constantes des broches E/S numériques ---


// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---

int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
String chaineReception=""; // déclare un objet String vide pour reception chaine



// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---


// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

Serial.begin(115200); // initialise connexion série matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission


// ------- Broches en sorties numériques -------  

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// ------- Initialisation des variables utilisées -------  

// ------- Codes d'initialisation utile -------  

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()


// --- ici instructions à exécuter par le programme principal ---

//---- code type réception valeur sur le port série ---

if (Serial.available()>0) { // si un octet en réception


//---- code type réception chaine sur le port série ---
while (Serial.available()>0) { // tant qu'un octet en réception

        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception==10) { // si Octet reçu est le saut de ligne
                Serial.println ("Chaine recue="+chaineReception); // affiche la chaine recue
                //chaineReception=""; //RAZ le String de réception
                break; // sort de la boucle while
        }
        else { // si le caractère reçu n'est pas un saut de ligne
                chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
        }

} // fin tant que  octet réception

} // --- fin Serial available

//----- une fois que le saut de ligne est reçu, on sort du While et on se positionne ici


chaineReception=""; //RAZ le String de réception

//while(1); // stop loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////



// ////////////////////////// Fin du programme ////////////////////