HowTo: Ardunio - Utilisation du port série - Nerdiy.de - Nerdy DIY HowTo sur l'électronique, l'impression 3D et plus encore.

Chaque carte Arduino est normalement programmée via l'interface série.
Mais non seulement le code du programme peut être transféré sur l'Arduino. Vous pouvez également envoyer des commandes de contrôle à l'Arduino ou recevoir des valeurs de l'Arduino.

Comment cela fonctionne et quelles options vous avez, je décris dans l'article suivant.

Consignes de sécurité

Je sais que les notes suivantes sont toujours un peu ennuyeuses et semblent inutiles. Malheureusement, de nombreuses personnes qui savaient "mieux" ont perdu des yeux, des doigts ou d'autres choses à cause d'une négligence ou se sont blessées. La perte de données est presque négligeable en comparaison, mais même celles-ci peuvent être vraiment ennuyeuses. Par conséquent, veuillez prendre cinq minutes pour lire les consignes de sécurité. Parce que même le projet le plus cool ne vaut pas une blessure ou d'autres problèmes.
https://www.nerdiy.de/sicherheitshinweise/

Liens d'affiliation/publicitaires

Les liens vers des boutiques en ligne répertoriés ici sont des liens dits d'affiliation. Si vous cliquez sur un tel lien d'affiliation et effectuez un achat via ce lien, Nerdiy.de recevra une commission de la boutique en ligne ou du fournisseur concerné. Le prix ne change pas pour vous. Si vous effectuez vos achats via ces liens, vous aidez Nerdiy.de à pouvoir proposer d'autres projets utiles à l'avenir. 🙂

Préparer l'interface série

Pour utiliser l'interface série dans votre programme, vous devez l'initialiser.
Dies geschieht indem Ihr in der “setup()”-Funktion die Funktion

Serial.begin(115200);

aufruft. Die Zahl “115200” steht dabei für die Baudrate – also die Geschwindigkeit – mit der die Symbole Nicht Bits oder Bytes) über die serielle Schnittstelle übertragen werden. Diese Geschwindigkeit solltet ihr von der “Qualität” der Verbindungsleitung abhängig machen.

Par exemple, si vous avez un câble blindé et très court, la vitesse peut être réglée très haut.
Dans le cas de câbles non blindés et/ou très longs, cette vitesse ne doit pas être choisie aussi élevée.

Les débits en bauds courants sont, par exemple, les valeurs suivantes :

Egal welche Geschwindigkeit Ihr einstellt, dieser Wert muss auch im “Seriellen Monitor” – also dem anderen Kommunikationspartner der seriellen Kommunikation – eingestellt werden. Nur dann werden die Zeichen korrekt empfangen und gesendet. Mehr dazu erfahrt Ihr im Laufe des Textes.

Si vous ne savez pas quel débit en bauds utiliser, je recommande des valeurs comprises entre 9600 bauds et 115200 bauds. Ces valeurs et les valeurs intermédiaires sont également les valeurs habituelles pour de nombreux produits finis tels que les capteurs et les actionneurs.

Envoyer des données de la carte Arduino à l'ordinateur connecté

Afin de pouvoir envoyer des données de votre carte Arduino vers l'ordinateur connecté, vous devez appeler la fonction suivante.

Diese sendet den Text “Hallo Welt!” inklusive Zeilenumbruch an den Computer.

Serial.println("Bonjour le monde !");

Vous pouvez essayer le code suivant comme exemple.

void setup() { Serial.begin(115200); } void loop() { Serial.println("Hello world!"); retard(1000); }

Dadurch erhaltet Ihr die abgebildete Ausgabe. Nach jedem “Hallo Welt!” wird automatisch ein Wechsel in die nächste Zeile vorgenommen.

In der folgenden Kombination sendet die Funktion den Text “Hallo Welt!” ohne Zeilenumbruch an den Computer.

Serial.print("Bonjour le monde!");

Il y a un autre exemple de cela.

void setup() { Serial.begin(115200); } void loop() { Serial.print("Hello world!"); retard(1000); }

Da nun nach dem “Hallo Welt!” kein Zeilenumbruch vorgenommen wird entsteht eine Lange Zeile aus mehreren “Hallo Welt!”-Abschnitten.

Wollt Ihr Variabel-Werte – in diesem Fall den Wert der Variable “lustige_variable” – senden könnt Ihr dies wie folgt tun:

uint8_t drôle_variable=5 ; Serial.println(String(drôle_variable));

A titre d'exemple, le tout ressemble à nouveau à ceci.

void setup() { Serial.begin(115200); } void loop() { uint8_t funny_variable=5; Serial.println(String(drôle_variable)); retard(1000); }

La valeur (5) de la variable est sortie avec un saut de ligne.

L'envoi d'un saut de ligne signifie qu'en plus du contenu réel du message, un caractère de contrôle est également envoyé qui signale au destinataire de passer à la ligne suivante.

Utiliser le moniteur série

Le moniteur série est le pendant de la carte Arduino. C'est le programme qui reçoit les données sur l'ordinateur et les rend lisibles pour vous.
Ihr findet es als Teil der Arduino-IDE unter dem Menüpunkt “Werkzeuge/Serieller Monitor”. Tools wie dieser “Serielle Monitor” werden auch Terminalprogramme genannt. Eine gute Alternative zu dem “Seriellen Monitor” der Arduino-IDE ist auch das Programm HTERM.

Im Fenster des Seriellen Monitors lassen sich das Zeilenabschlusszeichen und die Baudrate einstellen. Durch einen Klick auf “Ausgabe löschen” lässt sich außerdem der Inhalt des Ausgabefensters löschen.

Le débit en bauds peut être défini dans la fenêtre du moniteur série. La même valeur doit être définie ici que celle précédemment définie dans le code de programme.
Avez-vous les gars avec la commande

Serial.begin(115200);

c'est-à-dire qu'un débit en bauds de 115200 bauds est défini, vous devez également définir un débit en bauds de 115200 bauds dans le moniteur série.

En plus du débit en bauds, la terminaison de ligne peut également être réglée. Vous n'avez besoin de ce paramètre que si vous souhaitez envoyer des données de l'ordinateur à l'Arduino.

Ici, vous pouvez définir le caractère qui est automatiquement ajouté et envoyé après chaque envoi d'une valeur.

Vous pouvez très bien l'utiliser dans votre code, par exemple, pour reconnaître sur l'Arduino si la transmission d'une commande ou d'une valeur est terminée.

Im Bereich “Befehle und Parameter an den Arduino senden” wird dies ausführlich erklärt.

Utiliser un traceur série

Le traceur série est un outil avec lequel vous pouvez afficher des valeurs numériques (par exemple des valeurs mesurées) directement sur l'ordinateur sous forme de progression chronologique. Pour ce faire, vous devez programmer l'Arduino pour envoyer les valeurs numériques à l'ordinateur.
Cela peut être fait, par exemple, avec la commande :

Serial.println(VariableWithAReading);

Die Variable “VariableMitEinemMesswert” sollte natürlich euren Messwert als Zahl enthalten.
Auf dem Computer müsst ihr dann den Seriellen Plotter starten. Diesen findet ihr unter “Werkzeuge/Serieller Plotter”.

Ein simples Beispiel das auf dem seriellen Plotter eine Sinus-Kurve ausgibt ist das folgende. Probiert den Code einfach aus. Er sollte sich auf jedem Arduino ausführen lassen. Denkt daran Euren “Seriellen Plotter” auf 115200 baud einzustellen.

/* _ _ _ _ _
                                 | | | | |(_) | |
  __ ____ ____ __ | | | ___ _ __ __| | _ _ _ __| | ___
    / / / / / / / / / | . ` | / _ | '__|/ _` || || | | | / _` | / _
    V V / V V /_ | | __/| | (_| || |_| | (_| || __/)
    \_/\_/ \_/\_/ \_/\_/(_)|_| \_| \___||_| \__,_||_| \__, |(_)\__,_| \___|
                                                               __/ |
                                                              |___/
     sinusTest par Fabian Steppat
     Infos sur https://www.nerdiy.de/ardunio-die-serielle-schnittstelle/

     Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier.
     sous les termes de la Licence Publique Générale GNU telle que publiée par
     the Free Software Foundation, soit la version 3 de la Licence, soit
     (à votre choix) toute version ultérieure.

     Ce programme est distribué dans l'espoir qu'il sera utile,
     mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de
     MERCHANTABILITY ou FITNESS FOR A PARTICULAR PURPOSE.  Voir la
     GNU General Public License pour plus de détails.

     Vous devez avoir reçu une copie de la Licence Publique Générale GNU avec ce programme.
     en même temps que ce programme.  Si ce n'est pas le cas, voir .

     Vous trouverez de plus amples informations sur ce projet à l'adresse suivante :
     HowTo : Ardunio - Utiliser le port série


     Ce code imprime une onde sinusoïdale via une console série ou un traceur série */ //variables et constantes float degreeAngle = 0; flotteur valeur sinus = 0 ; constant float pi = 3,1415 ; float radianAngle = 0 ; const uint8_t facteur sinus = 50 ; void setup() { Serial.begin(115200); } void loop() { radiantAngle = degreeAngle * pi / 180; //faire deg en radians sinusValue = sin(radiantAngle); //calculer le sinus à partir de l'angle de rayonnement degreeAngle += 1.0 ; //augmenter le délai d'angle(5); // rend la sortie un peu plus lente if (degreeAngle > 360) // si la limite de degré est atteinte, réinitialisez-la à zéro { degreeAngle = 0; } Serial.println(sinusFactor * sinusValue); //sortie vers un moniteur/traceur série }

L'exemple ci-dessus doit afficher l'onde sinusoïdale affichée sur le traceur série.

Bien sûr, le traceur fonctionne non seulement avec le sinus mais aussi avec toutes les autres valeurs numériques.

Envoyer des commandes et des paramètres à l'Arduino

Alors maintenant, vous savez comment envoyer divers messages d'état ou valeurs de l'Arduino à l'ordinateur.
Mais ça marche aussi dans l'autre sens. Ceci est particulièrement utile ou pratique si vous contrôlez l'Arduino de l'extérieur et que vous ne souhaitez pas connecter de périphériques d'entrée tels que des boutons et autres à l'Arduino (ou vous ne pouvez pas s'il n'y a pas de GPIO).

Par exemple, vous pouvez régler la luminosité ou la couleur d'une LED ou la vitesse du moteur d'un moteur connecté via l'interface série uniquement.

L'IDE Arduino fournit quelques fonctions utiles pour la communication via l'interface série. (La documentation avec plus de détails peut être trouvée ici : https://www.arduino.cc/reference/en/language/functions/communication/serial/)

Pour que la réception et l'évaluation des commandes fonctionnent, il y a maintenant trois tâches à résoudre :
1. Comment l'Arduino reconnaît-il les caractères reçus ?
2. Comment les commandes complètes sont-elles composées des caractères reçus ?
3. Comment ces commandes reçues peuvent-elles être évaluées ?

1. Comment l'Arduino reconnaît-il les caractères reçus

Pour réagir aux caractères entrants, il y a la fonction

Série.disponible()

Diese prüft ob neue Zeichen im Empfangspuffer des Arduino enthalten sind. Der Empfangspuffer ist dabei eine Art zwischenspeicher in dem empfangene Zeichen solange gespeichert werden bis der Mikrocontroller des Arduinos Zeit hat sich um die empfangegenen Zeichen zu “kümmern”.

In dem Fall, dass neue Zeichen empfangen, aber noch nicht aus dem Empfangspuffer gelesen wurden gibt die Funktion “Serial.available()” “true” zurück ansonsten “false”.

Cette fonction est donc parfaite pour vérifier si des caractères actuellement reçus doivent maintenant être évalués. La commande ne nous dit pas combien de caractères ont été reçus. Il indique simplement qu'il y a au moins un caractère dans le tampon de réception.

2. Comment transformer les caractères reçus en commandes complètes

Bon, maintenant grâce à la fonction précédente nous avons reconnu qu'au moins un caractère est disponible dans le tampon de réception. Mais comment obtient-on les signes reçus ?

Les caractères du tampon de réception peuvent être lus avec la commande

Série.read()

lire à haute voix. La fonction sort le premier caractère contenu dans le tampon de réception et le supprime automatiquement du tampon de réception.
Afin de lire maintenant tous les caractères et de les écrire dans une variable, nous lisons maintenant à partir du tampon de réception jusqu'à ce qu'il soit vide et notons chaque caractère lu.
Vous pouvez le faire avec une boucle, par exemple :

void check_serial_receive() { String serialbuffer; while (Serial.available()) { char currentChar = (char)Serial.read(); if (currentChar == 13) //vérifie si le caractère lu est le terminateur de ligne { évalue_received_characters(serialbuffer); } else { tampon série += caractère actuel ; } } }

Comme vous pouvez le voir, le code consiste en une boucle while qui s'exécute jusqu'à ce que le tampon de réception soit vide (puis Serial.available()==false).
Innerhalb der while-Schleife werden währenddessen zeichenweise die auf dem Emfpangspuffer enthaltenen Zeichen ausgelesen (Serial.read()), der Variable “aktuellesZeichen” zugewiesen und an den String “seriellerPuffer” angehängt.

Hier kommt nun auch das im Abschnitt “Serieller Monitor” erwähnte Zeilenabschlusszeichen ins Spiel. In diesem (und jedem anderen Terminalprogramm) lässt sich nämlich ein Zeichen einstellen, welches nach jedem Absenden eines Zeichens oder einer Zeichenkette automatisch angehängt und mitgesendet wird.

Ce terminateur de ligne peut maintenant être utilisé pour reconnaître si la chaîne de caractères précédemment lue est complète et peut donc être évaluée.
Cela signifie que chaque caractère reçu doit être vérifié pour voir s'il s'agit de la fin de ligne. Dans le code ci-dessus, cela se fait par

si (currentChar == 13)...

Lasst euch von der 13 nicht verwirren. Das Problem bei Zeilenabschlusszeichen ist nämlich, dass diese auf einer Tastatur nicht aufgeführt sind. Man kann sie also nicht als Vergleichszeichen in den Code “eintippen”.
Afin de toujours vérifier le caractère reçu pour le caractère de fin, nous utilisons une astuce ici.

Grace à Tableau ASCII nous savons que chaque caractère dans l'ordinateur correspond à une valeur d'octet (c'est-à-dire une valeur numérique comprise entre 0 et 255).
Wenn ihr im Arduino also zum Beispiel ein “A” speichert, so speichert dieser eigentlich den Zahlenwert “65”.
Würde man nun prüfen wollen ob ein empfangenes Zeichen einem “A” entspricht könnte man entweder

si (caractère actuel == "A")

ou aussi

si (caractère courant == 65)

écrire. Les deux comparaisons conduiraient au même résultat.

Utilisons cette astuce maintenant. Pour vérifier si le caractère actuellement reçu est un terminateur de ligne tel que CR (=CarriageReturn), nous ne vérifions pas le caractère lui-même mais la valeur du caractère dans la table Ascii : c'est-à-dire 13.

Ainsi une fois ce caractère reçu, on sait que tous les caractères précédemment envoyés sont destinés à représenter une commande et doivent maintenant être évalués.

3. Comment ces commandes reçues peuvent-elles être évaluées

Wir bzw. der Arduino hat nun also einen Befehl empfangen. Dieser ist in der String-Variable “seriellerPuffer” gespeichert und wird als Funktionsparameter an die Funktion “empfangene_zeichen_auswerten()” übergeben.

Par exemple, cette fonction pourrait ressembler à ceci :

void Évaluer_caractères_reçus(ChaîneTamponSérie)
{
   Serial.println("""" + chaîne(tamponSérie) + "" reçu.") ; //sortie de la commande qui vient d'être reçue
   
   if (tampon série == "commandeSimpleCeQu'ilFait")
   {
      commande_simplificatrice_qui_fait() ;
   } else if (seriellerPuffer.indexOf('=') != -1)
   {
      uint16_t valeur reçue = seriellerPuffer.substring(seriellerPuffer.indexOf('=') + 1).toInt() ;
      Chaîne ParamètreRéceptionné = tamponSérie.substring(0, tamponSérie.indexOf('=')) ;
      
      if (paramètreReçu == "commandeDéfinirUneValeur"))
      {
         if (valeur reçue = 0)
         {
            commande_qui_met_une_valeur(valeur_reçue ) ;
         } else
         {
            Serial.println(F("Valeur en dehors de la plage de valeurs autorisées.")) ;
         }
      } else
      {
         Serial.print(F("La commande "")) ;
         Serial.print(tampon sériel) ;
         Serial.print(F("" n'a pas été reconnu.")) ;
      }
   } else
   {
      Serial.print(F("La commande "")) ;
      Serial.print(tampon série) ;
      Serial.print(F("" n'a pas été reconnu.")) ;
   }
}

Une fois qu'une commande a été reçue, elle est à nouveau émise, ce qui est particulièrement utile à des fins de débogage. Ainsi, vous pouvez vérifier quelle chaîne de caractères est finalement arrivée dans l'Arduino.

Danach kann mit einer einfachen IF-Abfrage geprüft werden welcher Zeichenkette der empfangene Befehl entspricht. Hier wird zum Beispiel geprüft ob der Befehl der Zeichenkette “simplerBefehlDerWasTut” entspricht.
Ist dies der Fall wird die Funktion “simpler_befehl_der_was_tut();” ausgeführt.

Mithilfe dieser “absoluten” Befehle könntet ihr nun einfache Befehle absetzen. Zum Beispiel um ein Licht ein- oder auszuschalten.

Um nun aber auch Werte übergeben zu können müssen auch Befehle der Form “helligkeitSetzenAuf=20” ausgewertet werden können.
Es muss also der Befehlsname (in diesem Fall “helligkeitSetzenAuf”) und der Wert (in diesem Fall “20”) erkannt werden.

Ceci est fait dans la partie suivante du code ci-dessus.
Sollte nämlich keiner der “absoluten” Befehle zu der empfangenen Zeichenkette passen wird geprüft ob in der empfangenen Zeichenkette ein “=”-Zeichen Vorhanden ist.

Solltet Ihr also zum Beispiel den Befehl “setzeHelligkeit=100” an den Arduino gesendet haben wird er die gesamte Zeichenkette “setzeHelligkeit=100” keinem “absoluten” Befehl zuordnen können.

Dans ce cas, la chaîne de caractères reçue est vérifiée pour un signe égal et celui-ci est également trouvé.

La chaîne de caractères reçue est ensuite décomposée en la partie avant et après le signe égal avec les commandes suivantes.

uint16_t valeur reçue = serialbuffer.substring(serialbuffer.indexOf('=') + 1).toInt(); Chaîne de paramètres reçus = serialbuffer.substring(0, serialbuffer.indexOf('='));

Nun ist in der Variable “empfangenerWert” die “100” und in der Variable “empfangenerParameter” der Befehl “setzeHelligkeit” gespeichert.

Une fois extraites de la chaîne de caractères reçue, les deux valeurs peuvent ensuite être traitées et réagies.

Essayez-le. 🙂
Vous pouvez trouver le code complet pour réessayer ici :

/* _ _ _ _ _
                                 | | | | |(_) | |
  __ ____ ____ __ | | | ___ _ __ __| | _ _ _ __| | ___
    / / / / / / / / / | . ` | / _ | '__|/ _` || || | | | / _` | / _
    V V / V V /_ | | __/| | (_| || |_| | (_| || __/)
    \_/\_/ \_/\_/ \_/\_/(_)|_| \_| \___||_| \__,_||_| \__, |(_)\__,_| \___|
                                                               __/ |
                                                              |___/
     serialTest par Fabian Steppat
     Infos sur https://www.nerdiy.de/ardunio-die-serielle-schnittstelle/

     Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier.
     sous les termes de la Licence Publique Générale GNU telle que publiée par
     the Free Software Foundation, soit la version 3 de la Licence, soit
     (à votre choix) toute version ultérieure.

     Ce programme est distribué dans l'espoir qu'il sera utile,
     mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de
     MERCHANTABILITY ou FITNESS FOR A PARTICULAR PURPOSE.  Voir la
     GNU General Public License pour plus de détails.

     Vous devez avoir reçu une copie de la Licence Publique Générale GNU avec ce programme.
     en même temps que ce programme.  Si ce n'est pas le cas, voir .

     Vous trouverez de plus amples informations sur ce projet à l'adresse suivante :
     HowTo : Ardunio - Utiliser le port série


     Ce codenippet est un concept de base d'une communication série pour contrôler un arduino via des commandes série.
*/

{
  Serial.begin(115200) ;
}

void loop()
{
  check_seriellen_reception() ;
}

void check_seriellen_reception()
{
  Chaîne de caractères TamponSérie ;
  while (Serial.available())
  {
    char CaractèreCourant = (char)Serial.read() ;
    if (caractèreActuel == 13)
    {
      évaluer_caractère_reçu(tamponSérie) ;
    } else
    {
      tampon série += caractère courant ;
    }
  }
}
void Évaluer_caractères_reçus(ChaîneTamponSérie)
{
  Serial.println(""" + Chaîne(tampon série) + "" reçu ;)

  if (tampon série == "commandeSimpleCeQueTout")
  {
    instruction_simplificatrice_qui_fait_quoi() ;
  } else if (seriellerPuffer.indexOf('=') != -1)
  {
    uint16_t valeur reçue = seriellerPuffer.substring(seriellerPuffer.indexOf('=') + 1).toInt() ;
    Chaîne ParamètreRéceptionné = tamponSérie.substring(0, tamponSérie.indexOf('=')) ;
    if (paramètreReçu == "commandeDéfinirUneValeur"))
    {
      if (valeur reçue & lt ; = 23 & amp ; & valeur reçue & gt ; = 0)
      {
        commande_qui_met_une_valeur(valeur_reçue ) ;
      } else
      {
        Serial.println(F("Valeur en dehors de la plage de valeurs autorisées.")) ;
      }
    } else
    {
      Serial.print(F("La commande "")) ;
      Serial.print(tampon sériel) ;
      Serial.print(F("" n'a pas été reconnu.")) ;
    }
  } else
  {
    Serial.print(F("La commande "")) ;
    Serial.print(tampon série) ;
    Serial.print(F("" n'a pas été reconnu.")) ;
  }
}

Amusez-vous avec le projet

J'espère que tout a fonctionné comme décrit. Si ce n'est pas le cas ou si vous avez des questions ou des suggestions, faites-le moi savoir dans les commentaires. Je les ajouterai à l'article si nécessaire.
Les idées de nouveaux projets sont toujours les bienvenues. 🙂

PS Beaucoup de ces projets - en particulier les projets matériels - coûtent beaucoup de temps et d'argent. Bien sûr, je le fais parce que j'aime ça, mais si vous pensez que c'est cool que je partage l'information avec vous, je serais heureux d'un petit don au fonds du café. 🙂