Débuter Arduino. Recevoir des commandes depuis le port série (compatible ESP32 ESP8266)

Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

Table des matières

Il est possible d’utiliser le port série pour recevoir des commandes directement dans le code Arduino. On pourra par exemple piloter le GPIO depuis le moniteur série d’un éditeur de code tel que l’IDE Arduino ou PlatformIO. 

 

On pourra également faire communiquer plusieurs cartes de développement ou des micro-contrôleurs entre eux (STM32, ESP32, ESP8266) via le port série.

Ouvrir le port série dans le code Arduino

Avant de pouvoir recevoir des messages depuis le port série, il est nécessaire d’initialiser la communication avec la commande Serial.begin(vitesse). Cette méthode prend comme paramètre la vitesse du port série en bauds.

Par défaut, elle est fixée à 9600 bauds.

Vous pouvez opter pour l’une de ces vitesses 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, ou 115200.

La plupart des cartes de développement actuelles supportent sans aucun problème la vitesse de 115200 bauds.

Serial.begin(115200);

Comment recevoir des commandes depuis le port série ?

L’utilisation du port série comme une entrée de commande n’est pas beaucoup plus compliquée que la sortie série.

On connait déjà la commande Serial.print() (et les fonctions associées) qui permet d’envoyer des caractères vers le port série ainsi que les autres commandes dérivées présentées en détail dans cet article.

A LIRE AUSSI :
ESP32-CAM, flash du firmware officiel modifié avec capture d'image

Pour recevoir des caractères sur le port série, on dispose de plusieurs commandes (documentation officielle)

Serial.available() qui permet d’écouter tout ce qui arrive sur le port série et de déclencher un traitement.

On évitera d’utiliser la fonction Serial.Event() qui ne fonctionne pas avec les cartes Arduino Due, Leonardo, Micro, Yún et les cartes de nouvelle génération SAMD.

availableForWrite() permet de connaître le nombre d’octets (caractères) disponibles pour l’écriture dans le tampon série sans bloquer l’opération d’écriture.

Les méthodes pour lire dans la mémoire tampon (buffer) du port série

Serial.read() lire tout ce qui arrive sur le port série.

4 autres fonctions plus spécialisées

Serial.find() lit les données du tampon série jusqu’à ce que la chaîne recherchée soit trouvée. La fonction renvoie true si la chaîne est trouvée.

Serial.findUntil() lit les données du tampon série jusqu’à ce qu’une chaîne cible d’une longueur donnée ou une chaîne de terminaison soit trouvée. La fonction renvoie true si la chaîne cible est trouvée.

Serial.setTimeout(duree) permet de modifier le Timeout, le temps d’attente avant que l’execution des fonctions Serial bloquantes soient abandonnées. Le Timeout est de 1 seconde par défaut.

La durée d’attente est en millisecondes. 1 seconde = 1000ms

Les fonctions suivantes sont bloquantes : find(), findUntil(), parseInt(), parseFloat(), readBytes(), readBytesUntil(), readString(), readStringUntil().

Téléverser le projet pour piloter une LED en envoyant des commandes sur le port série

Créer un nouveau croquis sur l’IDE Arduino ou un nouveau projet PlatformIO et collez le code suivant.

Les commandes suivantes sont acceptées

  • led=on pour allumer la LED
  • led=off pour éteindre la LED
  • ledstatus pour connaître l’état de la LED (ON ou OFF) qui est stocké dans la variable led_status
  • Tout autre commande retourne l’erreur Invalid command

Avant de téléverser le code, modifiez la constante LED_PIN qui indique la broche sur laquelle la LED est branchée

#include <Arduino.h>

#define LED_PIN 32
bool led_status = false;
String command;
 
void setup() {
    Serial.begin(115200); 
    pinMode(LED_PIN, OUTPUT);
}

void send_led_status(){
  if ( led_status ) {
    Serial.println("LED is ON");
  } else {
    Serial.println("LED is OFF");
  }
} 
void loop() {
    if(Serial.available()){
        command = Serial.readStringUntil('\n');

        Serial.printf("Command received %s \n", command);

        if(command.equals("led=on")){
            digitalWrite(LED_PIN, HIGH);
            led_status = 1;
        } else if(command.equals("led=off")){
            digitalWrite(LED_PIN, LOW);
            led_status = 0;
        } else if(command.equals("ledstatus")){
            send_led_status();
        } else{
            Serial.println("Invalid command");
        }
    }
}

Circuit du projet

Pour ce projet, on va simplement connecter une LED sur une sortie numérique d’une carte Arduino. Le code est compatible avec n’importe quelle carte ESP32 ou ESP8266. Modifiez simplement la broche sur laquelle est connectée la LED.

Ici, la LED est branchée sur la sortie 32 d’une carte de développement ESP32.

ESP32 Timer Alarm blink LED

Explication du code

La commande Serial.available() passe à vrai dès que la mémoire tampon du port série contient de nouveaux caractères. En plaçant la fonction dans le thead principal du programme, la boucle loop(), on pourra recevoir immédiatement les commandes entrantes

if( Serial.available() ){ 
  ... traitement des commandes entrantes sur le port série
}

Comme nous l’avons vu dans l’introduction, on dispose de plusieurs fonctions pour lire dans le tampon de port série.

Le moniteur série termine l’envoie par le caractère de contrôle \n correspondant à la fin de ligne.

On peut utiliser la méthode Serial.readUntil(“\n”) qui permet de lire jusqu’à la chaîne passée en paramètre. On stocke la chaîne dans la variable command de type String.

command = Serial.readStringUntil('\n');

Il ne reste plus qu’à utiliser les fonctions de traitement des chaînes pour identifier la commande et le paramètre.

Toutes les fonctions de traitement des String sont détaillées dans cet article

A LIRE AUSSI :
String C++. concat•c_srt•indexOf•replace•subString... pour Arduino ESP32 ESP8266

Ici, on va simplement tester si on vient de recevoir l’une des trois commandes led=on, led=off, ledstatus.

L’état de la LED est stocké dans la variable led_status

if(command.equals("led=on")){
    digitalWrite(LED_PIN, HIGH);
    led_status = 1;
} else if(command.equals("led=off")){
    digitalWrite(LED_PIN, LOW);
    led_status = 0;
} else if(command.equals("ledstatus")){
    send_led_status();
} else{
    Serial.println("Invalid command");
}

La fonction send_led_status imprime sur le port série l’état de la LED sous la forme d’une chaîne à l’aide de la fonction println(). Pour en savoir plus sur toutes les méthodes pour écrire sur le port série, vous pouvez continuer par la lecture de cet article

A LIRE AUSSI :
Fonctions C++ print•println•printf•sprintf pour Arduino ESP32 ESP8266. Combiner•formater → port série
void send_led_status(){
  if ( led_status ) {
    Serial.println("LED is ON");
  } else {
    Serial.println("LED is OFF");
  }
}

Tester le projet depuis le moniteur série de l’IDE Arduino

Ouvrez le moniteur série depuis le menu Outils -> Moniteur série ou à l’aide de l’icône

Un champ de saisie est situé au dessus de la fenêtre du moniteur série. Appuyez sur le bouton Envoyer ou sur la touche Entrée de votre clavier pour envoyer la chaîne à l’Arduino.

Comment envoyer des commandes vers le port série depuis l'IDE Arduino

Maintenant, vous pouvez tester le fonctionnement des trois commandes led=on, led=off, ledstatus.

La démonstration en vidéo

Tester le projet depuis le moniteur série de PlatformIO

Par défaut, le moniteur série de PlatformIO ne permet pas d’envoyer des commandes depuis le Terminal.

Pour pouvoir envoyer des commandes (chaînes de caractères) sur le port série, il faut ajouter des filtres à l’aide de l’option monitor_filters détaillée ici au fichier platformio.ini.

Filtre Description
<span class="pre">default</span> Supprimer les codes de contrôle
<span class="pre">colorize</span> Appliquer différentes couleurs pour les commandes received et echo
<span class="pre">debug</span> Imprimer ce qui est envoyé et reçu
<span class="pre">direct</span> Ne rien faire, transférer toutes les données inchangées
<span class="pre">hexlify</span> Afficher une représentation hexadécimale des données
<span class="pre">log2file</span> Consigner les données dans un fichier «platformio-device-monitor-%date%.log» situé dans le répertoire de travail du projet
<span class="pre">nocontrol</span> Supprimer tous les codes de contrôle, y compris CR et LF (Line Feed)
<span class="pre">printable</span> Afficher le code décimal pour tous les caractères non ASCII et remplacer la plupart des codes de contrôle
<span class="pre">time</span> Ajouter un horodatage en millisecondes pour chaque nouvelle ligne
<span class="pre">send_on_enter</span> Envoyer un texte à l’appareil sur ENTER
<span class="pre">esp32_exception_decoder</span> Filtre personnalisé pour ESP32 qui  permet de décoder l’exception en cas plantage
<span class="pre">esp8266_exception_decoder</span> Filtre personnalisé pour ESP8266 qui permet de décoder l’exception en cas plantage

Voici un exemple de configuration que vous pouvez utiliser dans vos projets. La commande est envoyée en appuyant sur la touche enter. Le journal des échanges est consigné dans un fichier à la racine du projet.

monitor_filters = debug, send_on_enter, log2file

Enregistrez le fichier de configuration puis relancez le moniteur série en cliquant sur la poubelle.

Placer le curseur (non visible) en cliquant dans le Terminal puis saisir la commande. Envoyer en appuyant sur la touche entrée du clavier.

Attention, il n’est pas possible de modifier la commande en cas d’erreur, c’est moins souple que le moniteur série de l’IDE Arduino
[TX:'l']  [TX:'e']  [TX:'d']  [TX:'=']  [TX:'o']  [TX:'n']  [TX:'\r\n']  [RX:'C'] C [RX:'ommand received led=on \n'] ommand received led=on 
 [TX:'l']  [TX:'e']  [TX:'d']  [TX:'=']  [TX:'o']  [TX:'f']  [TX:'f']  [TX:'\r\n']  [RX:'C'] C [RX:'ommand received led=off \n'] ommand received led=off 
 [TX:'l']  [TX:'e']  [TX:'d']  [TX:'s']  [TX:'t']  [TX:'a']  [TX:'t']  [TX:'u']  [TX:'s']  [TX:'\r\n']  [RX:'C'] C [RX:'ommand received ledstatus \nLED '] ommand received ledstatus 
LED  [RX:'i'] i [RX:'s OFF\r\n'] s OFF

Utiliser CoolTerm pour Windows, macOS ou Linux

Une dernière alternative bien pratique est le logiciel Open Source CoolTerm développé par Roger Meier que vous pouvez télécharger ici.

Ouvrez le menu Connection puis Settings. Sélectionnez de port COM de la carte Arduino, ESP32, ESP8266, STM32 ainsi que le débit, ici 115200 bauds.

coolterm option connection coolterm arduino serial port send command

Enregistrer les paramètres de connexion et cliquer sur l’icône Connect

coolterm connect

Ouvrez le menu Connection -> Send String…

coolterme send string serial port arduino esp8266 esp32 stm32

Saisir la commande désirée puis cliquer sur Send pour envoyer

Attention, la touche Enter / Entrée du clavier renvoie le curseur à la ligne, ce qui va poser un problème coté code Arduino.

coolterm comman history arduino esp32 esp8266 stm32

Mises à jour

2/10/2020 Publication de l’article

English Version

Avez-vous aimé cet article ?
[Total: 1 Moyenne: 5]
Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

Vous avez aimé ce projet ? Ne manquez plus aucun projet en vous abonnant à notre lettre d’information hebdomadaire!

quel modèle esp8266 choisir
Quel modèle d'ESP8266EX choisir en 2020 ?
guide choix esp32 development board
Quel ESP32 choisir en 2020 ?

Vous rencontrez un problème avec ce sujet ?

Peut-être que quelqu’un a déjà trouvé la solution, visitez le forum avant de poser votre question

Nous serions ravis de connaître votre avis

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Calculateurs
×
Calculateur loi d'Ohm
Tension (U) - en Volt
Courant (I) - en Ampère
Résistance (R) - en Ohms
Puissance (P) - en Watts

Ce calculateur permet de calculer les relations entre le courant, la tension, la résistance et la puissance dans les circuits résistifs.

Saisir au moins deux valeurs puis cliquer sur calculer pour calculer les valeurs restantes. Réinitialisez après chaque calcul.

Rappel sur la Loi d'Ohm
La loi d'Ohm explique la relation entre la tension, le courant et la résistance en déclarant que le courant traversant un conducteur entre deux points est directement proportionnel à la différence de potentiel entre les deux points.
La loi d'Ohm s'écrit U = IR, où U est la différence de tension, I est le courant en ampère et R est la résistance en Ohms (symbole Ω).
Loi d'Ohm (U=RI)
×
Déchiffrer le code couleur d'une résistance à 4 bandes
Bande 1 Bande 2 Multiplicateur Tolérance
   

Résistance:  

1 000 Ω ±5%

Comment déchiffrer le code couleur d'une résistance à 4 anneaux
Formule : ab*cΩ ±d%
Les deux premières bandes (a, b) permettent de déterminer le chiffre significatif. La première bande correspond au chiffre de la dizaine, le second anneau le chiffre de l'unité. Par exemple Brun(1), Noir (0) donne le nombre 10.
La troisième bande (c) est un coefficient multiplicateur. Par exemple, l'anneau rouge est un coefficient multiplicateur de 100, ce qui donne 10 X 100 = 1000Ω.
Le quatrième anneau (d) indique la tolérance de la valeur nominale de la résistance. Par exemple l'anneau Or correspond à ±5%. Donc le fabricant de la résistance s'engage à ce que sa valeur soit comprise entre 950 Ω et 1050 Ω.
Déchiffrer code couleur 4 bandes
×
Déchiffrer le code couleur d'une résistance à 5 bandes
Bande 1 Bande 2 Bande 3 Multiplicateur Tolérance

Résistance:  

1 000 Ω ±5%

Comment déchiffrer le code couleur d'une résistance à 5 anneaux
Formule : abc*dΩ ±e%
Les trois premières bandes permettent de déterminer le chiffre significatif. La première bande correspond au chiffre de la dizaine, le second anneau le chiffre de l'unité. Par exemple Brun(1), Noir (0), Noir (0) donne le nombre 100
La quatrième bande est un coefficient multiplicateur. Par exemple, l'anneau brun correspond au coefficient multiplicateur 10, ce qui donne 100 X 10 = 1000Ω.
Le cinquième anneau indique la tolérance de la valeur nominale de la résistance. Par exemple l'anneau Or correspond à ±5%. Donc le fabricant de la résistance s'engage à ce que la valeur de la résistance soit comprise entre 950 Ω et 1050 Ω.
Déchiffrer code couleur 5 bandes
×
Calculateur de résistance série pour une ou plusieurs LED
Tension d'alimentation en Volt
Tension directe en Volt
Courant en mA
Résistance calculée en Ω
Puissance estimée en W

Ce calculateur permet de déterminer la résistance requise pour piloter une ou plusieurs LED connectées en série à partir d'une source de tension à un niveau de courant spécifié.

Remarque. Il est préférable d'alimenter le circuit avec une puissance nominale comprise entre 2 et 10 fois la valeur calculée afin d'éviter la surchauffe
Couleur Longueur d'onde (nm) Tension (V) pour LED ⌀3mm Tension(V) pour LED ⌀5mm
Rouge 625-630  1,9-2,1 2,1-2,2
Bleu 460-470 3,0-3,2 3,2-3,4
Vert 520-525 2,0-2,2 2,0-2,2
Jaune 585-595 2,0-2,2 3,0-3,2
Blanc 460-470 3,0-3,2 1,9-2,1
Résistance en série pour une ou plusieurs LED
×
Calculateur durée de vie d'une batterie
Capacité de la batterie
Consommation de l'appareil ou objet connecté

Ce calculateur estime la durée de vie d'une batterie, en fonction de sa capacité nominale et du courant ou de la puissance qu'une charge en tire.

La durée de vie de la batterie est une estimation idéalisée. La durée de vie réelle peut varier en fonction de l'état de la batterie, de son âge, de la température, du taux de décharge et d'autres facteurs. C'est le mieux que vous pouvez espérer obtenir.

Autonomie de la batterie = capacité de la batterie en mAh / courant de charge en mA

Durée de vie batterie
Publicité
À lire aussi
Composants
Sur le Forum
Domotique et objets connectés à faire soi-même
Domotique et objets connectés à faire soi-même
Vous avez aimé ce tutoriel

Ne manquez plus les prochains projets

Recevez chaque semaine le récapitulatif des tutoriels et projets.

Vous pouvez vous désabonner à tout moment.