Étape 10 : Communication avec l’ordinateur
Jusqu'à présent, nous avons utilisé uniquement la connexion USB pour télécharger de nouveaux programmes à l’Arduino. Mais nous pouvons aussi utiliser la connexion pour envoyer des données depuis et vers l’ordinateur.
Quelques conseils d’Arduino comme Leonardo ont un microcontrôleur qui gère la communication USB tout par ses propres, mais la plupart des conseils ont un second, plus petit microcontrôleur, uniquement pour la communication. Sur l’Arduino Uno, c’est le petit carré noir entre le connecteur USB et les LED TX-RX. La communication entre ce morceau et le microcontrôleur principal se fait en utilisant une connexion série, puis la deuxième puce indique à l’ordinateur « Hey, je suis un serial port », puis simplement convertit les données de série de la puce principale au format USB et convertit les messages de l’ordinateur en série pour le microcontrôleur principal.
Série signifie que les bits sont envoyés sur le même fil, l’un après l’autre, alors que les connexions parallèles envoyer 8 bits ou plus simultanément, à séparent les fils (comme le port d’imprimante parallèle grande sur le dos de certains ordinateurs plus anciens).
L’Arduino utilise deux lignes série : celle de l’Arduino pour la puce USB, la transmission (TX) et une ligne de la puce USB à l’Arduino, la ligne de réception (RX). Ces lettres sont écrites à côté de broche 0 et 1. Cela signifie que ces goupilles sont utilisées lorsque vous êtes connecté à l’ordinateur en cours d’exécution, vous ne pouvez pas utiliser les LEDs ou boutons etc.. Si vous arrêtez la communication encore une fois, vous pouvez simplement utiliser les broches d’e/s comme d’habitude.
Si vous souhaitez vous connecter l’Arduino vers un autre appareil utilisant des communications série, vous devez également utiliser ces deux broches.
Envoi des entrées à l’ordinateur
Ouvrez l’exemple serialButton et le télécharger.
La configuration de montage d’essai est le même que dans l’étape précédente.
Ensuite, ouvrez le moniteur série: outils > Serial Monitor, cliquez sur la loupe dans le coin supérieur droit ou frappé CTRL + MAJ + m Make sûr autoscroll est activé et la vitesse de transmission est défini sur 9600.
Vous verrez un tas d’uns. Maintenant, appuyez sur le bouton poussoir relié à la broche 3, et vous verrez des zéros. C’est juste l’entrée brute de la broche.
Maintenant, ouvrez la table traçante série: outils > série traceur ou CTRL + MAJ + L. Cela va tracer les valeurs dans un graphique.
Nous allons jeter un coup d’oeil sur le code :
Dans la configuration, nous ajoutons une nouvelle commande : Serial.begin(9600). C’est juste pour commencer la communication et le 9600 est le débit en bauds, le nombre d’impulsions par seconde, donc la vitesse de la connexion série. 9600 est simplement la valeur par défaut. Si vous choisissez une valeur différente, vous devrez le changer dans le moniteur de série ainsi. Sinon, il va être synchronisées et vous donner très étranges personnages. C’est le contraire de Serial.begin(...) Serial.end(). Vous pouvez l’utiliser lorsque vous avez à utiliser les broches 1 et 0 comme e/s normales encore une fois, après avoir utilisé la connexion série, toutefois il n'est pas vraiment recommandé.
Dans la boucle, vous verrez le même mot clé série, cette fois utilisée avec la fonction println(...) . Ceci affiche juste sur la valeur qui est spécifiée entre les parenthèses, suivies d’une nouvelle ligne (ln).
(Notez que cela n’est pas juste il convertir en binaire pour l’envoyer au fil de la série, au lieu de cela, elle convertit en ASCIIet l’envoie ensuite au fil de la série, afin que l’ordinateur peut imprimer. Si vous voulez envoyer les octets binaires au fil de la série, utilisez la fonction de Serial.write(...) .)
Pour obtenir une nouvelle ligne, vous pouvez également utiliser Serial.print(...) ainsi que le caractère \n (nouvelle ligne) ou du caractère \r (retour chariot), qui indiquent une ligne terminée, au lieu de la ln.
Les guillemets indiquent que c’est un personnage.
Une autre particularité est le \t (tabulation), nous allons l’utiliser pour imprimer les entrées des deux commutateurs. Il s’agit d’exemple serial2Buttons. Téléchargez et ouvrez le moniteur série pour voir le résultat.
Référence de l’Arduino : Serial
Envoyer des commandes à l’Arduino
La communication fonctionne également l’inverse : nous allons écrire un programme de contrôle LED de l’ordinateur.
Ouvrez l’exemple serialLEDs.
Télécharger, ouvrir le moniteur de la série et essayez de renvoyer des valeurs comprises entre 0 et 3. Maintenant envoyer 4. Téléchargez comment ça marche ?
Nous allons vérifier le code :
Le programme d’installation devrait ressembler assez familier, sauf une seule commande : il s’agit d’une boucle while. Une boucle while répète, tant que la condition entre les crochets est vraie (on pourrait le compare à une boucle for, mais sans le premier et le dernier argument, seuls l’État.) J’ai utilisé explicitement les supports incurvés pour indiquer c’est une boucle, mais vous pouvez aussi simplement utiliser un point-virgule à la place : while (! Série) ;
Série retourne true lorsque la communication série est active (lorsque vous ouvrez le moniteur série, par exemple). Donc si nous ajoutons un opérateur not (!), l’expression est vraie lorsque la communication n’est pas active. Donc la boucle while continue à répéter de suite alors que la communication n’est pas active et essentiellement attend pour qu’il devienne actif. Nous savons que nous puissions commencer à envoyer des données avec la fonction println(...). Si nous ne serait pas utiliser la boucle while pour attendre, certains conseils comme Leonardo (et autres conseils qui ont des capacités USB dans la puce principale) seront juste perdent les premières données. Il cherche à envoyer à l’ordinateur, mais rien n’y est à l’écoute pour l’entrée série.
Dans la boucle, il y a une autre nouvelle déclaration : l' instruction if, c’est probablement la plus importante déclaration en informatique. Il fait exactement ce que son nom l’indique : il exécute un morceau de code, uniquement si une certaine condition est vraie. Sinon, le code entre les crochets courbes est ignoré.
Maintenant, je vais prendre un moment pour expliquer comment l’Arduino reçoit les messages de la série :
Comme je l’ai expliqué plus tôt, série envoie un bit après l’autre, octet par octet. Cela signifie que votre message, « test », par exemple, obtient séparé en morceaux de 1 octet. Un caractère correspond à un octet en taille, donc il ressemblera à quelque chose comme ' t ' « e » ' ' t ' quand vous l’envoyez au fil de la série. Lorsque l’Arduino reçoit ces octets, il les stockera dans un tampon (juste un petit morceau de mémoire pour stocker temporairement). Il reçoit il octet par octet, ce qui rend le tampon ressemblera à quelque chose comme ça "" (vide) "t", "te", "tes" "test".
Lorsque le tampon est vide, la fonction Serial.available() retourne 0, si il a reçu des données dans la mémoire tampon, il retourne le nombre d’octets dans la mémoire tampon, donc 4 dans ce cas. Si vous appelez la fonction Serial.read() , il va lire le premier octet (' t ') dans la zone tampon, supprimez-le de la mémoire tampon et passer le tampon, donc il contient maintenant "est", et Serial.available() renvoie 3. Si vous appelez Serial.read() encore une fois, il retourne « e », et le tampon sera « st ». Vous pouvez continuer à lire jusqu'à ce que Serial.available() est égal à zéro. (Si vous voulez savoir le premier octet sans le supprimer en le faisant, vous pouvez utiliser la fonction Serial.peek() ).
Donc la première if(Serial.available > 0) vérifiera s’il y a toutes les données dans la mémoire tampon. Dans l’affirmative, il va lire le premier octet et stocker dans la variable serialValue. Ensuite, il vérifie si la valeur, qu'il vient de lire est « 0 ». Notez les guillemets simples, cela indique le caractère zéro (ASCII: ' 0 = 48) et pas 0 comme valeur, puisque le serial monitor envoie sous forme de texte. Si la valeur est « 0 », il s’éteint les deux LEDs. Si la valeur n’est pas de « 0 », code dans la section «autre» s’exécutera : donc il va maintenant vérifier si la valeur est "1", dans l’affirmative, elle la première LED s’allume et se transforme de la seconde. Si elle n’est pas non plus « 1 », il vérifiera si elle est « 2 », si donc, il le deuxième LED s’allume et s’éteint le premierà. S’il n’est pas « 2 », il vérifiera si elle est « 3 », dans l’affirmative, il tourne sur les deux LEDs, sinon, il exécute le code dans la dernière section d’autre et imprime les valeurs que vous devez entrer.
Vous pouvez consulter l’organigramme de l’image si l’explication n’était pas suffisamment claire.
Notez qu’un signe d’égalité double est utilisé pour vérifier si deux valeurs sont identiques. Si vous souhaitez utiliser un signe d’égalité unique, (si (serialValue = « 0 »)) il ne sera pas vérifier quoi que ce soit, il sera juste assigner une valeur de « 0 » à la variable serialValue. Il s’agit d’une erreur très commune.
Autres opérateurs pour tester les valeurs sont < (moins de) > (supérieur à) < = (inférieur ou égal à) > = (supérieur ou égal à)! = (non égal à).
À l’intérieur de votre instruction if, vous pouvez également utiliser des opérateurs logiques (opérateurs booléens), de vérifier plusieurs conditions : & & (et), || (ou)
Quelques exemples :
5 > 3 true →
Faux → 5 < 3
3 > 3 faux →
3 > = 3 → true
5! = 3 → true
3 == 3 → true
pour vérifier si une valeur de x est comprise entre 1 et 100 :
(1 < = x) & & (x < = 100)
une autre façon d’écrire cette (non recommandé, à titre d’exemple)
! ((x < 1) || (x>100))
Vous pouvez essayer de comprendre comment il fonctionne, vous-même et ensuite vérifier avec les tables de vérité dans l’image ci-dessus.
Remarque : Tout comme en mathématiques, supports sont utilisés pour indiquer l’ordre des opérations, par exemple, dans la dernière expression, ' x < 1' sera testé tout d’abord, puis ' x > 100', puis ' ||' et enfin '!'.
Référence de l’Arduino : tandis que
Arduino référence : si (et les opérateurs de comparaison)
Référence de l’Arduino : autre
Référence de l’Arduino : opérateurs booléens
_
Résumé
- La plupart des Arduinos ont une deuxième puce pour communication USB. Cette puce communique avec le microcontrôleur principal à l’aide d’une connexion série.
- Série, que ça sont envoyée après l’autre, à la fois. Il y a une ligne de transmission et une ligne de réception (TX et RX respectivement).
- Vous pouvez utiliser le Serial Monitor (CTRL + MAJ + M) et la série traceur (CTRL + MAJ + L) pour montrer les données de que l’Arduino est l’envoi et d’envoyer des données à l’Arduino.
- Serial.Begin(Baud) ; démarre la communication série avec l’ordinateur. La vitesse de transmission par défaut est de 9600.
- Serial.end(); met fin à la communication série.
- Serial.Print(Text) ; imprime le texte à l’ordinateur, il peut être lu dans la série monitor/table traçante. Notez que les nombres sont convertis en ASCII : par exemple Serial.print(0) ; envoie une valeur de série de 48 (code ASCII pour le caractère zéro).
- Serial.println(Text) ; est-la même impression, mais la volonté ajoute une nouvelle ligne après le message.
- « \n » est un caractère de nouvelle ligne « \r » est un retour chariot et « \t » est le caractère de tabulation (pour les retraits)
- Serial.Write(Byte) ; envoie un octet brut au cours de la série. Par exemple, Serial.write(48) ; imprime un caractère-0 dans le moniteur de la série.
- while(condition) {...} est appelé la boucle while. Code entre les accolades sera exécuté et répétée tant que la condition entre parenthèses normales est vraie.
- Série retourne true lorsque la communication série est active (lorsque vous ouvrez le moniteur série, par exemple).
- while (! Série); répétera « rien"(lire « attendre ») tant que la communication sérielle n’est pas active.
- if(condition) {code if} else {sinon-code} exécutera le code if si la condition est vraie et exécuter le code d’autre si la condition est false.
- Des données série a reçu de l’Arduino sont stockées dans une mémoire tampon, il y reste jusqu'à ce que vous avez bien lu, ou jusqu'à ce que le buffer overflow.
- Serial.available() ; retourne le nombre d’octets disponibles dans le tampon.
- Serial.Read() ; va retourner le premier octet dans la mémoire tampon et supprimez-le ensuite.
- Serial.Peek() ; renvoie le premier octet dans la mémoire tampon, sans le supprimer.
- Dans vos conditions, vous pouvez utiliser ces opérateurs de test: == (égal à), < (moins de), > (supérieur à), < = (inférieur ou égal à), > = (supérieur ou égal à),! = (non égal à).
- Et vous pouvez également utiliser la logique & & (et) et || (ou) des opérateurs.
Supplémentaires : commutateur
Dans le dernier exemple, nous avons utilisé beaucoup de if... else déclarations. Même si c’est le moyen le plus rapide de le faire, il n’est pas facile à lire. Si vous souhaitez comparer une variable pour certaines valeurs de données, vous pouvez utiliser un commutateur.
Ouvrez l’exemple serialLEDsSwitch.
Comme vous pouvez le voir, le commutateur démarre avec le mot clé « switch », suivi par la variable que vous voulez vérifier entre parenthèses. Entre les supports incurvés, nos valises sont définis. Ils utilisent la syntaxe 'affaire valeur: ", suivi par le code à exécuter si la variable donnée est égale à la valeur dans cette « affaire ». Après le code de cas particuliers, le 'break;' mot clé est utilisé pour fermer le "cas".
Notez que la valeur que vous entrez ne peut pas être une variable. Si vous souhaitez comparer 2 variables, vous devrez utiliser des instructions if.
Le code dans le 'par défaut:' affaire est exécutée si la variable ne correspond à aucune des valeurs d’autres cas. Ce cas est facultatif et peut être omis.
