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.
Cela se fait en utilisant la fonction dans la fonction « setup() »
Serial.begin(115200);
appels. Le nombre « 115200 » représente le débit en bauds – c'est-à-dire la vitesse – auquel les symboles (et non les bits ou les octets) sont transmis via l'interface série. Vous devez faire dépendre cette vitesse de la « qualité » de la ligne de connexion.
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 :
50 110 150 300 1200 2400 4800 9600 19200 38400 57600 115200 230400 460800 500000
Quelle que soit la vitesse que vous réglez, cette valeur doit également être réglée dans le « moniteur série », c'est-à-dire l'autre partenaire de communication pour la communication série. Ce n'est qu'alors que les caractères seront reçus et envoyés correctement. Vous en saurez plus à ce sujet au fil du texte.
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.
Cela envoie le texte « Bonjour tout le monde ! » y compris les sauts de ligne vers l'ordinateur.
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); }
Dans la combinaison suivante, la fonction envoie le texte « Hello world ! » à l'ordinateur sans sauts de ligne.
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); }
Si vous souhaitez envoyer des valeurs de variables – dans ce cas la valeur de la variable « funny_variable » – vous pouvez le faire comme suit :
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); }
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.
Vous pouvez le trouver dans le cadre de l'IDE Arduino sous l'élément de menu « Outils/Moniteur série ». Des outils comme ce « Serial Monitor » sont également appelés programmes de terminal. Le programme est également une bonne alternative au « Serial Monitor » de l’IDE Arduino HTERM.
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.
Ceci est expliqué en détail dans la section « Envoi de commandes et de paramètres à l'Arduino ».
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);
La variable « VariableWithAMeasured Value » doit bien sûr contenir votre valeur mesurée sous forme de nombre.
Vous devez ensuite démarrer le traceur série sur l'ordinateur. Vous pouvez le trouver sous « Outils/Traceur série ».
Un exemple simple qui génère une courbe sinusoïdale sur le traceur série est le suivant. Essayez simplement le code. Il devrait fonctionner sur n'importe quel Arduino. N'oubliez pas de régler votre « traceur série » sur 115 200 bauds.
/* _ _ _ _ _
| | | | |(_) | |
__ ____ ____ __ | | | ___ _ __ __| | _ _ _ __| | ___
/ / / / / / / / / | . ` | / _ | '__|/ _` || || | | | / _` | / _
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 }
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()
Cela vérifie si de nouveaux caractères sont contenus dans le tampon de réception de l'Arduino. Le tampon de réception est un type de tampon dans lequel les caractères reçus sont stockés jusqu'à ce que le microcontrôleur de l'Arduino ait le temps de « prendre soin » des caractères reçus.
Dans le cas où de nouveaux caractères ont été reçus mais pas encore lus dans le tampon de réception, la fonction « Serial.available() » renvoie « true », sinon « 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).
Dans la boucle while, les caractères contenus dans le tampon de réception sont lus caractère par caractère (Serial.read()), affectés à la variable « caractère actuel » et ajoutés à la chaîne « tampon série ».
C'est là qu'intervient le terminateur de ligne mentionné dans la section « Moniteur série ». Dans ce programme (et dans tous les autres programmes de terminal), vous pouvez définir un caractère qui est automatiquement ajouté et envoyé à chaque fois qu'un caractère ou une chaîne de caractères est envoyé.
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)...
Ne laissez pas le 13 vous embrouiller. Le problème avec les terminateurs de ligne est qu'ils ne sont pas répertoriés sur un clavier. Vous ne pouvez donc pas les « saisir » dans le code comme caractères de comparaison.
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).
Par exemple, si vous stockez un « A » dans l'Arduino, il stocke en fait la valeur numérique « 65 ».
Si vous souhaitez maintenant vérifier si un caractère reçu correspond à un « A », vous pouvez soit
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
Nous ou l'Arduino avons donc reçu une commande. Ceci est stocké dans la variable de chaîne « Serial Buffer » et est transmis en tant que paramètre de fonction à la fonction « receive_character_evaluate() ».
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.
Vous pouvez ensuite utiliser une simple requête IF pour vérifier quelle chaîne de caractères correspond à la commande reçue. Ici, par exemple, on vérifie si la commande correspond à la chaîne « simplerCommandDerWasTut ».
Si tel est le cas, la fonction « simpler_command_that_does_(); » réalisé.
En utilisant ces commandes « absolues », vous pouvez désormais émettre des commandes simples. Par exemple, pour allumer ou éteindre une lumière.
Afin de pouvoir transférer des valeurs, les commandes de la forme «brightnessSetUp=20» doivent également pouvoir être évaluées.
Ainsi, le nom de la commande (dans ce cas « BrightnessSetOn ») et la valeur (dans ce cas « 20 ») doivent être reconnus.
Ceci est fait dans la partie suivante du code ci-dessus.
Si aucune des commandes « absolues » ne correspond à la chaîne de caractères reçue, il est vérifié s'il y a un caractère « = » dans la chaîne de caractères reçue.
Par exemple, si vous avez envoyé la commande « setBrightness=100 » à l'Arduino, il ne pourra pas attribuer la totalité de la chaîne « setBrightness=100 » à une commande « absolue ».
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('='));
Maintenant, le « 100 » est stocké dans la variable « receivedValue » et la commande « setBrightness » est stockée dans la variable « receivedParameter ».
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é. 🙂
Français 
Deutsch 
English 
Español 
Nederlands