1.5 La liaison série : faire communiquer le PC et la carte Arduino.

Maintenant que vous savez faire clignoter une led, vous allez voir comment discuter avec votre Arduino à l’aide de ce que l’on appelle une liaison Série.

Tout d’abord qu’est-ce que la liaison Série ?

La liaison Série est un protocole de communication entre le PC et la carte Arduino via le câble USB permettant un échange d’informations entre vous et votre carte Arduino via ce qu’on appelle le moniteur série !

Le moniteur série est accessible depuis le logiciel Arduino en cliquant sur la loupe en haut à droite de la fenêtre :
ss (2016-07-25 at 11.36.10)
Voici à quoi ressemble le moniteur série:
Image du moniteur série arduino

En bas à droite de la fenêtre vous pouvez lire 9600 baud, il s’agit de la fréquence de transmission à laquelle le moniteur série est réglé.

Hello world Arduino !

Construisons pas à pas notre programme qui permettra à votre Arduino d’écrire  » Hello les makers !  »

Tout d’abord,  il vous faut activer et configurer la liaison série. Pour cela dans la fonction setup()  ajoutez cette ligne :

Serial.begin(9600);

Cette ligne permet d’initialiser la liaison Série à 9600 bauds.
Remarque : Si vous décidez de spécifier une autre valeur, ( afin de communiquer plus rapidement par exemple ) il  vous faudra spécifier la même valeur dans le moniteur Série (en bas à droite de la fenêtre).

Ensuite pour que votre carte Arduino envoie un message sur le moniteur série vous avez cette fonction :

Serial.print("Hello les makers "); //Permet d'afficher Hello les makers sur le moniteur série

Afin de n’afficher le texte qu’une fois nous allons placer ce morceau de code dans le setup, juste après l’initialisation de la liaison série.

Voilà ce que donne le code complet :

void setup() {
// mettre ici le code qui sera répété qu'une fois:
Serial.begin(9600); // Permet d'initialiser le moniteur série à 9600 bauds
Serial.print("Hello les makers "); //Permet d'afficher Hello les makers sur le moniteur série 
}

void loop() {
// mettre ici le code qui sera répété en boucle:
// On ne fait strictement rien ! 
}
Hello les makers

Téléversez le programme puis ouvrez le moniteur série: Vous devrez voir le texte   » Hello les makers  » qui s’affiche une seule fois.

Et vous pouvez ajouter autant de fois que vous voulez du texte avec la même fonction Serial.print, pour afficher du texte sur la même ligne, ou bien utiliser la fonction Serial.println, pour sauter à la ligne après avoir écrit le message.

Petit exemple d’utilisations de ces deux fonctions :

void setup() {
// mettre ici le code qui sera répété qu'une fois:
Serial.begin(9600); // Permet d'initialiser le moniteur série à 9600 bauds
Serial.print("Hello les makers "); //Permet d'afficher Hello les makers sur le moniteur série 
Serial.println(" j'espère que : ");
Serial.println(" => ce tutoriel vous plaît, ");
Serial.println(" => vous êtes heureux et en bonne santé ");
Serial.println(" => que tout va bien dans le meilleur des mondes ");
Serial.println(""); // Permet de sauter une ligne
Serial.print("            signé : " );
Serial.println("mike118" );

}

void loop() {
// mettre ici le code qui sera répété en boucle:
// On ne fait strictement rien ! 
}
Serial.print et Serial.println

N’hésitez pas à le téléverser pour voir ce que ça donne et même le modifier pour être sûr que vous avez bien compris!

Arduino repète après moi !

Bon vous avez vu comment l’Arduino peut vous écrire des messages maintenant voyons comment elle peut recevoir ce que vous écrivez et du coup faisons la répéter ce que vous écrivez dans le moniteur série !

Dans ce but, l’Arduino doit scruter le moniteur série en continue pour savoir si il y a un texte à enregistrer dans cette variable.

Pour cela on a une fonction qui nous permet de savoir si des données sont présentent sur port série.
Cette fonction est : Serial.available() qui retourne le nombre de caractères disponibles sur le moniteur série. Caractères que l’on aurait envoyé via le moniteur en tapant du texte en haut du moniteur série et en pressant entrer.

Du coup afin de tester en continu si des caractères sont disponibles on va créer au début de la fonction loop une ligne  « Si ( caractère disponible ) Alors  (faire ceci ) Sinon ( faire cela )  » comme ceci :

if (Serial.available() )
{ 
      //Si un message a été reçu  faire ceci
}
else
{
 // Si rien n'est reçu faire cela
}
If & else

Du coup maintenant que l’Arduino sait qu’on a des caractères qui sont disponibles à la lecture, elle va lire les caractères  !

Pour cela il y a la fonction Serial.readString(); //Lit le message reçu et le retourne sous forme de message que l’on peut mettre dans la fonction Serial.println()  » .
Et vu que nous ce qui nous intéresse c’est d’afficher ce qu’on a reçu on sur le moniteur série pour montrer que l’Arduino a bien compris ce que vous lui avez envoyé on va faire  tout simplement  « Serial.println(Serial.readString());  // lit la valeur qu’on a envoyé et l’affiche sur le moniteur »

Donc on obtient comme programme ceci :

void setup() {
// mettre ici le code qui sera répété qu'une fois:
Serial.begin(9600); // Permet d'initialiser le moniteur série à 9600 bauds
Serial.print("Hello les makers "); //Permet d'afficher Hello les makers sur le moniteur série 
Serial.println(" j'espère que : ");
Serial.println(" => ce tutoriel vous plaît, ");
Serial.println(" => vous êtes heureux et en bonne santé ");
Serial.println(" => que tout va bien dans le meilleur des mondes ");
Serial.println(""); // Permet de sauter une ligne
Serial.print("            signé : " );
Serial.println("mike118" );

}

void loop() {
// mettre ici le code qui sera répété en boucle:
if (Serial.available() )
{ 
      //Si un message a été reçu  faire ceci
      Serial.println(Serial.readString());  // Lit le message reçu et l'affiche sur le moniteur
}
else
{
 // Si rien n'est reçu faire cela
}
}
Arduino repeat after you

Téléversez le programme puis ouvrez le moniteur série: Vous devrez voir le texte   » Hello les makers  » qui s’affiche une seule fois, suivi du petit mot où je vous souhaite tout plein de bonnes choses et puis plus rien.
En fait l’Arduino se met à attendre que vous tapiez quelque chose dans le moniteur série !
c’est l’encart en haut, écrivez y ce que vous voulez et puis appuyez sur  » envoyer  » ! =)
Que se passe t’il ? =)

Utilisons maintenant les variables!

Les variables sont des éléments qui vont contenir en mémoire du texte ou des chiffres , le contenu de ces variables est défini par les mots clés types tel String. String est un type de variable qui peut contenir du texte, il existe d’autres types de variables pour les chiffres, nous nous y intéresserons très bientôt mais pour le moment nous nous concentrerons sur la variable String.

 

Afin d’améliorer un peu le programme précédent nous allons donc y déclarer une nouvelle variable String avant le setup()  de cette façon:

String msg;// Variable pour contenir du texte comme " Hello les makers "
déclaration d'un string

Grâce à cette variable String nommé pour l’exemple msg, nous pourrons stocker le texte reçu au lieu de directement l’afficher. Ainsi nous pourrons par exemple l’utiliser plusieurs fois !  Bien entendu vous pouvez changer le nom « msg » (qui est le diminutif de message) par ce que vous voulez , exemple nickname ou encore messageReçu, etc… tant que vous le changez partout dans votre code.

Maintenant que l’on a notre variable String qui peut contenir du texte on va donc remplacer cette ligne

« Serial.println(Serial.readString());  // lit la valeur qu’on a envoyé et l’affiche sur le moniteur »

par ces deux lignes :

« msg = Serial.readString();  // lit la valeur qu’on a envoyé et l’enregistre dans la variable msg »
« Serial.println(msg);  //Affiche le texte contenu dans msg sur le moniteur »

Du coup le code devient :

String msg;// Variable pour contenir du texte comme " Hello les makers "

void setup() {
// mettre ici le code qui sera répété qu'une fois:
Serial.begin(9600); // Permet d'initialiser le moniteur série à 9600 bauds
Serial.print("Hello les makers "); //Permet d'afficher Hello les makers sur le moniteur série 
Serial.println(" j'espère que : ");
Serial.println(" => ce tutoriel vous plaît, ");
Serial.println(" => vous êtes heureux et en bonne santé ");
Serial.println(" => que tout va bien dans le meilleur des mondes ");
Serial.println(""); // Permet de sauter une ligne
Serial.print("            signé : " );
Serial.println("mike118" );

}

void loop() {
// mettre ici le code qui sera répété en boucle:
if (Serial.available() )
{ 
      //Si un message a été reçu  faire ceci
      msg = Serial.readString();  // lit la valeur qu'on a envoyé et l'enregistre dans la variable msg
 Serial.println(msg);  //Affiche le texte contenu dans msg sur le moniteur
}
else
{
 // Si rien n'est reçu faire cela
}
}
arduino répète après moi avec variable

Le fonctionnement est identique que précédemment, cependant vous pouvez dorénavant utiliser plusieurs fois le texte que vous avez envoyé car il est enregistrer dans la mémoire de votre Arduino dans la variable msg!

Rencontre avec Dori!

Voici un petit exemple sympas, fournis par Jekert, afin de montrer comment peuvent être utilisé les variables et qui en plus reprend quelques fonctions qu’on a vu dans le chapitre précédent!  N’hésitez pas à l’essayer et à le modifier 😉

// define 
#define TEMPSENMEMEOIRE 3000 // votre arduino est un poisson rouge qui retient votre prénom pendant 3000 secondes

//Variables :
String msg = "  "; //Variable de type suite de caractère qui est initialisé avec un espace vide

void setup()
{
Serial.begin(9600);
Serial.println("Salut ! Quel est ton prenom ?");
}

void loop()
{
if (Serial.available() ) 
{ 
msg = Serial.readString(); //Stocke le message sous forme de String dans msg
Serial.print("--> "); //Affiche une flèche
Serial.println(msg); //Puis votre message
Serial.print( "Salut " ); 
Serial.println(msg); //Puis votre 
Serial.println(""); //Puis on saute une ligne
delay(TEMPSENMEMEOIRE); // on attend que le temps de mémoire qu'on a choisi en defien
msg =" "; //On oublie le prénom , on vide la mémoire
Serial.println("Salut ! Quel est ton prenom ?");
}
}
Dori rencontre quelqu'un

Voilà ce que le code de jekert est censé vous donner ! =)

 

ss-2016-09-14-at-06-00-13Vous pouvez modifier le programme à votre guise pour vérifier que vous avez bien tout compris!

Maintenant si vous voulez vous amuser davantage, il est important de bien faire le point sur certaines notions basiques mais très importantes, les variables, que vous avez commencé à découvrir avec les String,  mais aussi les boucles et les fonctions. Pour cela nous allons nous servir de l’excuse d’améliorer le code précédent pour aborder ces thèmes !

 

<- Retourner à la page précédente | Passer à la page suivante ->

13 réflexions sur « 1.5 La liaison série : faire communiquer le PC et la carte Arduino. »

  3. Bonjour, ceci est fort intéressant. voilà, je cherche à monter un contrôleur usb qui me servirait à conduire un train en simulateur (jeu de simulation de train. l’idée étant d’envoyer depuis Arduino qui sera équipé d’un système permettant de recevoir des infos via mes actions. avant de dire à l’arduino ce que je veux qu’il envoie à l’ordi, il me faut comprendre comment envoyer des infos à l’ordinateur via usb et c’est là ma question, comment envoyer à l’ordinateur des infos via usb

    Répondre

    1. Une arduino zéro permet de facilement faire ce genre de chose en se faisant passer pour un clavier ou une souris sur un ordinateur ( « On the arduino zero the USB connector of the Native port is directly connected to the USB host pins of the SAMD21. Using the Native port enables you to use the Zero as a client USB peripheral (acting as a mouse or a keyboard connected to the computer) » ) Avec une arduino uno il faut une application capable d’ouvrir le port de communication de l’arduino pour faire de la communication série. Après le mieux pour ce genre de question est de la poser sur le forum : http://www.robot-maker/forum =)

      Répondre

  4. Bonjour, votre tutoriel est vraiment très intéressant et utile, et je vous en remercie 😉 Mon projet, consisterait à créer une machine permettant d’accompagner un pecheur. En effet, ce serait comme un canon permettant de propulser l’hamecon ainsi que le fil de peche à une distance comprise entre 0 et 100 mètres. Dans mon programme ce n’est pas la vitesse de propulsion qui varie mais l’angle entre le canon et le trépieds. Mon programme étant presque terminer, il ne me reste plus qu’à faire en sorte que mon arduino puisse envoyer une commande au moteur en lui disant de s’incliner ( selon l’angle calculer précèdemment avec la dichotomie ) Pourriez vous m’aider à résoudre ce dernier problème.

    Répondre

  5. bonsoir, est-ce que pouvez-vous m’aider à traiter cette exercice?
    Le nom, le prénom et l’adresse mail de l’étudiant sont
    sauvegardés dans l’Ar-
    duino. A l’aide de la liaison série avec l’ordinateur, quand on
    envoie Nom,
    Prenom ou
    Mail à l’Arduino, celui-ci renvoie le nom, le prénom ou
    l’adresse mail
    sauvegardée dans
    l’Arduino.

    Répondre

    1. Bonjour,
      Je pense qu’il faut sélectionner le port com4 dans grbl 1.1
      Le Port com qui va s’afficher sur votre ordinateur va dépendre du matériel que vous allez brancher …

      Répondre

  7. bonjours et merci pour votre programme car j’étais bloqué plusieurs semaine.

    voila mon programme cadeaux.
    ———————————————————————————
    String commande;

    char* message[4]={« commande ‘banane’ reçus », »commande ‘pomme’ reçus », »commande ‘cerise’ reçus », »commande ‘poire’ reçus »};
    char* BSF[]= { « Boissons », »Sandwichs », »Friandises », »Chips » };
    int longueur = strlen(BSF[2]);

    int a15=LOW;
    int b15=LOW;
    int c15=LOW;
    int d15=LOW;

    void setup() {

    // ——————–prog outyl N°1——————–
    // ! OUTYL POUR LA PROGRAMMATION. !
    // !Il serre de contrôle pour aidé à la création de la !
    // ! programmation. !
    // ! 1 .Il donne la version du programme. !
    // ! 2 Il signal la mis en fonction du programme. !
    // ——————————————————

    Serial.begin(9600);
    Serial.println(« Version 0.2 »);Serial.println(« —–etude les condition if logique ‘and’ et autre 0-1 29 janvier 2021—-« );
    Serial.println(« programme en Marche-> »);

    // ======== fin outyl prog N°1============
    // ________________________________________________________________*/
    Serial.println(message[1]);
    Serial.println(BSF[2]);Serial.print(« longueur du texte « );Serial.println(longueur);
    } //setup

    void loop() {

    // ça marche !!! ouaaih!

    // ————prog outyl « Serial.available()0-2————
    // ! OUTYL POUR LA PROGRAMMATION. !
    // ! Il serre a envoyé des commande en direct dans un !
    // ! programme en cours de fonctiomment. |
    // ———————————————————

    if (Serial.available() )
    {
    //Si un message a été reçu faire ceci
    //NON! NON! NON! ils faut pas mettre des Serial.print(reasdStringe()) ÇA VIDE LE BUFFÉ…
    //Serial.println(Serial.readString()); // Lit le message reçu et l’affiche sur le moniteur
    /*detection[1]=Serial.readString();*/
    /* commande = Serial.readString();
    Serial.println (commande);*/

    //essayé ça!!!
    commande = Serial.readString(); // vide le buffé du clavier dans ‘commande’ donc si il y a méssage il sera dedans,

    //Serial.println(Serial.readString());
    if (commande== »a1″) {a15=HIGH;Serial.println( » A15=HIGH « );commande= » »;}
    if (commande== »a0″) {a15=LOW;Serial.println( » A15=LOW « );commande= » »;}
    if (commande== »b1″) {b15=HIGH;Serial.println( » B15=HIGH « );commande= » »;}
    if (commande== »b0″) {b15=LOW;Serial.println( » B15=LOW « );commande= » »;}
    if (commande== »c1″) {c15=HIGH;Serial.println( » C15=HIGH « );commande= » »;}
    if (commande== »c0″) {c15=LOW;Serial.println( » C15=LOW « );commande= » »;}
    if (commande== »d1″) {d15=HIGH;Serial.println( » D15=HIGH « );commande= » »;}
    if (commande== »d0″) {d15=LOW;Serial.println( » D15=LOW « );commande= » »;}

    /* if (a15!=c15 || b15!=d15)
    { Serial.print(a15);Serial.print(« != »);Serial.print(b15);Serial.print(« || »);
    Serial.print(c15);Serial.print(« != »);Serial.print(d15);Serial.println( » ok autorisation de passé. »);}
    else {Serial.print(a15);Serial.print(« != »);Serial.print(b15);Serial.print(« || »);
    Serial.print(c15);Serial.print(« != »);Serial.print(d15);Serial.println( » stop! on passé pas. »);}*/

    if (a15!=c15) { Serial.print(a15);Serial.print( » != « );Serial.print(b15);Serial.println( » ok autorisation de passé. »);}
    else {Serial.print(a15);Serial.print( » != « );Serial.print(b15);Serial.println( » stop! on passé pas. »);}
    }
    else
    {
    // Si rien n’est reçu faire cela
    }

    // ici c’est le bordels!!!!! ça marche ou il y a des choses paranormale!!!

    /* // ————prog outyl « Serial.available()0-1————
    // ! OUTYL POUR LA PROGRAMMATION. !
    // ! Il serre a envoyé des commande en direct dans un !
    // ! programme en cours de fonctiomment. |
    // ———————————————————–
    Serial.print(«  »);

    if (Serial.available()>=3) {for (char i=1;i=48 && tableau[1]=48 && tableau[2]<=50){ // filtre pour les sorties Serial.available () donc on attend 48,49,50.

    if (tableau[1]==49){detection[1]=HIGH;}//1
    if (tableau[1]==48){detection[1]=LOW;}//0
    if (tableau[2]==50){detection[3]=HIGH;}//2
    if (tableau[2]==48){detection[4]=LOW;}//0//

    //}

    Serial.println(message[1]);
    for (char i=1;i<=6;i=i+1) { Serial.write(tableau[i]);Serial.print(" tableau [");Serial.print(i+0);Serial.print("] =");Serial.print(tableau[i]+0);Serial.println(" ");}

    } // boucle available.

    detection_precedent[1]=detection[1];detection_precedent[2]=detection[2];

    if (detection[1]==detection_precedent[1] != detection[2]==detection_precedent[2])
    {Serial.println("detection[1] différent de detection[2] donc il y a changement! et un nouvelle evenement.");
    Serial.println(" ");
    Serial.print(detection[1]+0);Serial.print("=detection[1] ");Serial.print("==");Serial.print("detection_detection[1]=");Serial.print(detection_precedent[1]+0);
    Serial.print("!=");
    Serial.print(detection[2]+0);Serial.print("=detection[2] ");Serial.print("==");Serial.print("detection_detection[2]=");Serial.print(detection_precedent[2]+0);

    } */

    j'ai recommencé a vous envoyé ce message, je crois que le premier n'a pas marché.

    Répondre

    1. Bonjour,
      Merci pour cet excellent programme.
      Juste deux trois remarques…
      Pour la structure : Une meilleure indentation avec des sauts de lignes permet plus de lisibilité (et permet du pas à pas …).
      Pour l’écriture en français : merci d’améliorer votre orthographe car ça fait décidément très très mal aux yeux ^^

      Bien à Vous

      Répondre

Répondre à MATONDO Annuler la réponse

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *