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 |

Recevoir une chaine de caractères depuis Processing via le port série USB

Par X. HINAULT - Page créée le : 02/02/2011.

Cliquer sur l'image pour agrandir

1.  Présentation

1.1  Côté Arduino :

Le programme reçoit une chaîne de caractère se terminant par un saut de ligne (depuis une interface Processing) sur le port série USB. Cette chaîne reçue est renvoyée vers l'interface processing qui l'affiche dans sa fenêtre de console. Ce programme utilise la nouvelle classe String du langage Arduino.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC

Ressources utiles associées à ce programme :

  • La librairie Serial - pour les communications séries entre la carte Arduino et l'ordinateur ou d'autres composants

1.2  Côté Processing :

Le programme Processing envoie une chaîne de caractère suivie d'un saut de ligne lors de l'appui sur un bouton inverseur graphique (Toggle) dans l'interface Processing.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers la carte Arduino

Ressources utiles associées à ce programme :

  • La librairie GUI ControlP5

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • aucun matériel supplémentaire.

3.  Instructions de montage

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

4.  Le schéma théorique du montage

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

6.  Fonctionnement du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Explication du programme

  • Voir les commentaires du programme pour les explications.

8.  Mise en oeuvre du programme

8.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
  • Il faut lancer le programme Processing ci-dessous côté PC.

8.2  Fonctionnement

  • Appuyer sur le bouton graphique : la chaîne reçue par la carte Arduino est affichée dans la console Processing.

Cliquer sur l'image pour agrandir

9.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur 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 : 02/02/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 ? ---------
 /* Le programme reçoit une chaîne de caractère se terminant
 par un saut de ligne (depuis une interface Processing)
 sur le port série USB. Cette chaîne reçue est renvoyée vers Processing
 et peut etre affichée dans la console Processing.
 Ce programme utilise la nouvelle classe String du langage Arduino.  */


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

// Utilise la connexion série vers le PC

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

// La connexion série 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 (ASCII)
char caractereRecu=0; // variable pour stockage caractère recu
int compt=0; // variable comptage caractères reçus

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

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

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
        compt=compt+1;

        //Serial.println("Ascii Caractere "+ String(compt) +" = "+ String(octetReception)); // affiche code ASCII Octet reçu

        if (octetReception==10) { // si Octet reçu est le saut de ligne

          //Serial.println("Saut de ligne recu");
          Serial.println("**** Reponse Arduino **** :");
          Serial.println ("Chaine recue : "+chaineReception); // affiche la chaine recue
          chaineReception=""; //RAZ le String de réception
          compt=0; // RAZ compteur
          delay(100); // pause
          break; // sort de la boucle while

        }
        else { // si le caractère reçu n'est pas un saut de ligne

           caractereRecu=char(octetReception); // convertit l'octet reçu en caractère
           chaineReception=chaineReception+caractereRecu; // ajoute le caratère au String
        }

} // fin tant que  octet réception

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



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

10.  Le programme Processing

10.1  Description

  • L'interface graphique est constituée par un bouton inverseur Toggle de la librairie controlP5.
  • Le port série est initialisé à 115200 bauds
  • Lorsque le bouton Toggle change d'état, la routine de gestion de l'évènement analyse l'état du Toggle et envoie la chaine vers la carte Arduino (via le port série USB)
  • Lorsque Arduino répond en renvoyant la chaîne, la routine de gestion de l'évènement Série affiche la chaîne reçue qui est la même que celle envoyée.

10.2  Le programme complet en langage Processing

A copier/coller directement dans l'éditeur Processing

// Programme processing
// généré avec le générateur de code Processing
// X. HINAULT - Janvier 2011 - tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un/des bouton(s) inverseur(s) (Toggle)

/*
L'appui sur le bouton inverseur Toggle envoie une chaîne caractère
suivie d'un saut de ligne sur le port série
*/


// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

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

import controlP5.*; // importe la librairie GUI controlP5
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://www.sojamo.de/libraries/controlP5/

// déclaration objets

// --- port Série ---
Serial  myPort; // Création objet désignant le port série

ControlP5 controlP5; // déclare un objet principal de la librairie GUI controlP5

Toggle t1; // déclare un/des objets Toggle

// déclaration variables globales

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

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

//---- initialisation graphique ----
background(0,0,0); // fond noir

// --- 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
        // 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
        myPort = new Serial(this, "/dev/ttyACM0", 115200); // Initialise une nouvelle instance du port Série
        myPort.bufferUntil('\n'); // attendre arrivée d'un saut de ligne pour générer évènement série

        //======== Initialisation Objets GUI ControlP5 =========

        controlP5 = new ControlP5(this); // initialise l'objet principal de la librairie GUI controlP5

        // typeObjet nomObjet=controlP5.addObjet(paramètres); // pour info : déclaration / initialisation possible en 1 ligne
        // Textfield field = controlP5.addTextfield("myWindowTextfield",70,130,100,20); // exemple

        //======== Initialisation Objets Toggle =========

        // addToggle(String theName, boolean theDefaultValue, float theX, float theY, int theWidth, int theHeight)
        t1=controlP5.addToggle("toggleA",false,15,15,70,70); // initialise et ajoute un Button au ControlP5

        // méthodes propres à l'objet Toggle
        t1.setMode(ControlP5.DEFAULT); // fixe le mode de fonctionnement du Toggle : ControlP5.DEFAULT ou ControlP5.SWITCH


} // 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 c   r       ctère sur le port Série

        // Accès à la valeur des objets GUI controlP5

        //--- accès à la valeur courante du Toggle ---
        //println("Valeur Toggle= "+ t1.value());
        //println("Etat Toggle= "+ t1.getState());
        //delay(100);



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

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

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

                 print(inString); // affiche chaine recue

        } // fin condition chaine recue pas vide


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

// Gestion des évènements des objets GUI controlP5 ----

//------ fonction gestion globale des évènements GUI controlP5
public void controlEvent(ControlEvent theEvent) {

        println(); // saut ligne propreté
        println("*** Gestion évènement Toggle par Processing ***");
        println("Nom évènement = " + theEvent.controller().name());// affiche le nom de l'évènement
        println("Nom Toggle = "+ t1.name());
        println("Etat Toggle = "+ t1.getState());

        //--- si évènement Toggle t1 et si état = vrai
        if ((theEvent.controller().name()==t1.name()) && (t1.getState()==true)) {

          println ("Envoi sur le port Série de la chaine : Etat Toggle = VRAI ");
          myPort.write("Etat Toggle = VRAI \n");

        }

        //--- si évènement Toggle t1 et si état = faux
        if ((theEvent.controller().name()==t1.name()) && (t1.getState()==false)) {

          println ("Envoi sur le port Série de la chaine : Etat Toggle = FAUX ");
          myPort.write("Etat Toggle = FAUX \n");

        }

        println(); // saut ligne propreté

}



//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX