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 |

Une carte Arduino ("client") envoie une chaine vers une autre carte Arduino ("serveur") via une interface Processing de transfert

Présentation générale

  • Cet ensemble de programme montre comment réaliser une communication unilatérale d'une carte Arduino vers une autre carte Arduino.
  • Le but ici est de montrer le principe de la communication entre 2 cartes Arduino connectées au même PC sur 2 ports série différents, l'interface Processing faisant la "jonction" entre les 2 ports série.

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 de "transfert client/serveur"

Explication

  • Le programme Processing va faire plusieurs choses :
    • 1. il va recevoir la chaine transmise par la carte Arduino "client" sur le port série que la carte Arduino "client" utilise (USB0 dans mon cas).
    • 2. il va renvoyer cette chaine vers la carte Arduino "serveur" sur le port série que la carte Arduino "serveur" utilise (USB1 dans mon cas)
    • 3. il va recevoir la réponse de la carte "serveur" toujours sur le port série que cette carte utilise et il va afficher la chaine dans la console Processing afin de visualiser la bonne transmission de la chaine.
  • Ce programme utilise donc 2 instances de port série : une pour le port série utilisé par la carte "client" et une pour le port série utilisé par la carte "serveur".

Le programme processing


// 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

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

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

// déclaration objets

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

// déclaration variables globales

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

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

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

        //------------- initialisation port série ----

        println(Serial.list()); // affiche dans la console la liste des ports séries

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


         //---------- le port Série de la carte "serveur" ------------    
        // Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec  Serial.list()[index]
        //myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
        myPortServer = new Serial(this, "/dev/ttyUSB1", 115200); // Initialise une nouvelle instance du port Série
        myPortServer.bufferUntil('\n'); // attendre arrivée d'un saut de ligne pour générer évènement série


} // 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

        // 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 myPort) { // fonction appelée lors de la survenue d'un évènement série

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

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

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

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

                println("chaine reçue du client : "+ inStringClient); // affiche la chaine dans la console

                // ---- envoi la chaine vers la carte Arduino "serveur"
                myPortServer.write(inStringClient+"\n"); // envoie la chaine suivi saut ligne sur le port Série

        } // fin condition chaine recue sur le port Série Client pas vide


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

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

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

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

                println("chaine reçue du Serveur : "+ inStringServer); // affiche la chaine dans la console


        } // fin condition chaine recue sur le port Série Client pas vide


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

 

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.

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 ////////////////////