L’utilisation du port série USB est un moyen pratique et efficace pour communiquer entre un ordinateur et un microcontrôleur. Dans ce tutoriel, nous allons voir comment recevoir une chaine de caractères depuis Processing via le port série USB. Nous verrons comment configurer le port série, comment envoyer et recevoir des données et comment traiter ces données dans Processing. Nous verrons également comment afficher les données reçues dans une fenêtre graphique.
Recevoir une chaine de caractères depuis Processing via le port série USB
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
// 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
// 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
Articles similaires:
- Saisir une chaîne dans un champ texte et l’envoyer vers le port Série
- Saisie d’une chaine de caractère dans Processing sélectionne fichier son
- Recevoir une chaine de caractères depuis le PC via le port série USB
- Processing :
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ATELIERSSerieEnvoiPCVersArduino
Articles Liés
- Réception d'une chaine saisie dans Processing et renvoi vers Processing
Avec l'avènement de l'ère numérique, les technologies de traitement de données sont devenues plus accessibles…
- Mesure analogique à distance (télémétrie) multivoies à partir d'une carte Arduino "serveur" via deux interfaces Processing Client/Serveur sur 2 PC connectés en réseau wifi.
La télémétrie est une technologie qui permet de mesurer des données à distance. Elle est…
- Mesure d'une intensité à l'aide du capteur de courant +/-5A ACS714 (affichage graphique Processing)
La mesure d'une intensité est une tâche importante pour de nombreuses applications industrielles et domestiques.…