Guide du débutant pour Arduino (9 / 15 étapes)

Étape 9: Entrée par un bouton

Bien sûr, vous pouvez utiliser les broches e/s de l’Arduino comme entrées ainsi. Dans cette étape, nous allons juste utiliser boutons poussoirs comme dispositifs d’entrée, mais bien sûr, vous pouvez utiliser n’importe quel interrupteur.

Pull-up et pull-down

L’Arduino travaille avec entrées logiques: 1 = 5v, 0 = 0v. Pour rendre notre bouton ces tensions de sortie, nous utiliserons une traction ou une résistance de menu déroulant. (image 1 & 2)
Dans le cas d’une résistance de pull-down (image 1), nous nous connectons une jambe du commutateur à 5v et l’autre jambe à travers une résistance (10kΩ dans ce cas) à la masse (0v). La jambe avec la résistance connectés va à la broche d’entrée sur l’Arduino.

De cette façon, quand le bouton n’est pas pressé (et ne se connecte les 2 pieds), l’entrée est à 0v, parce qu’il est connecté à la masse à travers la résistance. Lorsque vous appuyez sur le bouton, l’entrée est à 5v, parce qu’il est directement relié au 5v par l’intermédiaire de l’interrupteur. La résistance n’est pas grave lorsque vous appuyez sur le bouton, il fait juste en sorte que l’entrée est à 0v lorsque la touche pas.

Une résistance pull-up (image 2) fonctionne exactement de la même manière, mais tout est échangé : la première étape est reliée à la terre, au lieu de 5v, le second est relié au 5v, à travers une résistance (donc la résistance de pull-up de nom, puisqu’il il tire jusqu'à 5v). L’entrée pin se connecte toujours sur le côté avec la résistance, mais maintenant, il est élevé quand le bouton n’est pas pressé et va faible lorsque l’interrupteur est fermé.

Branchez ensuite un bouton de commande avec une résistance de menu déroulant à la broche 3 de l’Arduino et un bouton poussoir avec une résistance de pull-up à la broche 5. Raccordez ensuite deux LEDs (avec leur résistance appropriée) aux bornes 10 et 12. (image 3 & 4)

Maintenant ouvrez exemple button2 et ouvrez-le. Ce programme lit les deux entrées juste et définit les sorties dans le même État.

Il y a seulement deux choses nouvelles, et ils sont vraiment évidents : au lieu de la constante de sortie, nous utilisons d’entrée pour définir les broches de nos boutons comme entrées, et la fonction digitalRead(pin) retourne l’état de la broche d’entrée donnée.

Remarque : l’utilisation de pinMode (pin, entrée) est en fait inutile, étant donné que toutes les broches de l’Arduino sont entrées par défaut, mais il est souvent fait de toute façon, pour rendre le code plus lisible.

Lorsque vous téléchargez le croquis, appuyez sur les touches, et vous verrez que le tableau ci-dessus est en effet correct : la LED sur la broche 12 est toujours allumée, jusqu'à ce que vous appuyez sur le bouton sur la broche 5, c’est parce qu’il a une résistance pull-up.

Si vous souhaitez que les LEDs s’allume uniquement lorsque vous appuyez sur le bouton, vous pouvez utiliser l’opérateur booléen not-: cela change juste un « vrai » dans un « faux » (ou un 1 à 0) et vice versa. En C++ (dans l’IDE Arduino), cet opérateur est un point d’exclamation (!)

Résistances de pull-up interne

Il serait vraiment gênant que nous avons dû utiliser une résistance supplémentaire et une chute de fil, chaque fois que nous voulons utiliser un interrupteur normal. C’est pourquoi la puce sur l’Arduino possède une résistance pull-up intégré sur chaque broche.

Il y a deux façons pour leur permettre :

Les deux ont le même effet, mais ce dernier est préféré, parce que c’est plus lisible.

Remarque : Si vous oubliez d’utiliser pinMode (broche, sortie) et vous utilisez digitalWrite (broches, haute) par la suite, vous aurez juste activer la résistance de pull-up, parce que toutes les broches sont définis comme des entrées par défaut.

Reliez maintenant les boutons poussoirs sans résistances, juste la connexion à la terre (comme indiqué dans l’image 5)
Vous pouvez voir qu’il ne faut plus utiliser la broche 5v de l’Arduino, et si nous étions pour cela produire à grande échelle, ces deux résistances, que nous avons économisé ferait une différence dans le coût de production.

Ouvrez l’exemple button2-b. Comme vous pouvez le voir, j’ai utilisé les deux façons d’activer les résistances de pull-up. Notez également que j’ai utilisé l’opérateur « non », donc la sont allumés lorsque le bouton est enfoncé.

Récapitulatifs

• Pour utiliser des boutons et des interrupteurs avec votre Arduino, vous devez utiliser un pull-up ou la résistance de la liste déroulante.
• pinMode (NIP, INPUT_PULLUP) ; mesure les résistances de pull-up interne de l’Arduino.
  digitalWrite (tige, haute) ; sur une broche d’entrée a le même résultat.
• digitalRead(pin) retourne l’état de la broche d’entrée 1 = 5v, 0 = 0v.
  Si vous utilisez un bouton avec une résistance de pull-up (par exemple celui interne), 1 signifie que le bouton n’est pas pressé, 0 signifie qu’elle est pressée.
• Vous pouvez utiliser l’opérateur not (!) pour échanger 1 et 0. Par exemple ! digitalRead(pin) retourne 0 lorsque le bouton n’est pas enfoncé et 1 lorsque le bouton est enfoncé.

Supplémentaire : Manipulation de port Direct (avancée)

DigitalRead, digitalWrite et pinMode sont des fonctions simples et grandes, mais ils sont relativement lents. En outre, vous ne pouvez pas allumer 2 broches ou désactiver exactement au même moment, et écrit 8 bits simultanément pour la communication parallèle n’est pas possible non plus. Parfois, lorsque vous exécutez court sur la mémoire, ces 3 fonctions peuvent utiliser beaucoup de l’espace disponible, aussi.

La solution à ces problèmes est la manipulation directe de port. La puce Atmel a certains (3 sur la plupart des Arduinos) enregistre pour les broches e/s, ce sont juste les octets qui stockent les informations sur la question de savoir si un code pin est une entrée ou une sortie, que ce soit haute ou basse, etc.. Tous les bits de ces octets correspondant à une tige de I/O sur l’Arduino.

Sur l’Arduino Uno, port D contient des broches 0 à 7, port B goupilles 8 à 13 et port C A0 à A5.

Il existe 3 registres pour contrôler les entrées/sorties (où x est la lettre de port) :

• DDRx: Registre de données Direction : Ceci définit si les broches du port sont sorties (0) ou inputs(1). (pinMode)
• PORTx: Registre de données du Port : il s’agit de régler les sorties hautes ou basses et de désactiver ou d’activer les résistances de pull-up d’entrée. (digitalWrite)
• PINx: Port entrée Registre : cet octet contient l’état des entrées numériques. Si la broche est une sortie, il vous donnera juste l’état de la sortie.

Dans l’image ci-dessus, vous pouvez voir le tout mappage de broches de l’Arduino Uno, les numéros de port sont dans les champs jaunes à côté les broches. (crédit image)

Puisque chaque bit de l’octet représente une broche, il est plus facile d’écrire les valeurs en notation binaire. Vous pouvez le faire en ajoutant un capital B avant le numéro, par exemple, B111 est 7 sous forme décimale (2² + 2¹ + 2⁰).

De même, vous pouvez utiliser un 0 pour utiliser la notation octaleou 0 x pour la notation hexadécimale, toutefois, dans ce cas utilise ces deux notations n’a vraiment aucun sens.

Quand compter les bits, le plus à droite (moins significatif, LSB) est de type bit bit 0, donc elle correspond à la première broche du port, tandis que le MSB (bit le plus significatif) correspond à la broche huitième du port.

Quelques exemples :

Définition de broche 7 à une sortie et broches 0-6 comme entrées :

Broche 7 haut de réglage (sortie) :

Activation de la résistance de pull-up interne sur la broche (entrée) 6 :

Lecture de l’état des broches 0 à 7 :

Toutefois, l’utiliser comme ceci peut causer quelques problèmes : par exemple dans le deuxième exemple, broche 7 gestion familiale est implanté, mais tous les autres broches dans le port sont remis à zéro, quelle que soit leur état antérieur. Pour modifier uniquement une broche à la fois, nous pouvons utiliser des opérateurs de bits.

Pour définir un peu élevé, sans modifier les autres bits, nous pouvons utiliser les bits ou-opérateur ( | ). Note : Ceci est seulement un |, contrairement à l’ou-opérateur booléen ||. Au niveau du bit signifie qu’elle est appliquée à chaque morceau séparément. Nous utilisons un masque pour définir le droit peu élevé : le peu que nous voulons créer haute est 1, et tous les autres bits sont à 0.

Si un bit dans le masque est un, ce bit est défini à 1 dans le registre PORTD, si elle est nulle, il gardera seulement la valeur dans previousPORTD. Vous pouvez consulter les tables de vérité et de quelques exemples dans les images ci-dessus.

Pour définir un peu faible, sans modifier les autres bits, nous pouvons utiliser les bits - opérateur and ( & ). Note : Ceci est seulement un &, tandis que l’et-opérateur booléen est & &. Maintenant nous devons inverser notre masque : le bit, nous voulons mettre bas est égale à zéro, et tous les autres bits sont un.

Cette notation fonctionne très bien, mais nous pouvons le faire un peu plus lisible. Au lieu d’écrire un nombre entier binaire pour notre masque, nous pouvons utiliser l’opérateur de décalage de bits gauche (<<). Il décale simplement tous les chiffres à gauche pour un certain nombre d’endroits. Par exemple: 1 << 2 = B100, B101 << 1 = B1010 et ainsi de suite. C’est aussi un moyen facile de calculer les puissances de deux: 1 << 7 = B10000000 = 128 = 2⁷

Mais nous allons l’utiliser pour créer notre masque : par exemple, le masque de B10000000 peut être écrit comme 1 << 7, maintenant vous pouvez facilement voir que c’est la huitième broche dans le registre, sans avoir à compter les zéros.

Pour créer le masque inverse, pour les et notation, nous pouvons utiliser l' opérateur opérateur not ( ~ ) pour inverser tous les bits : B01111111 peut être écrite comme ~ (1 << 7). (Voir l’image)

Si vous voulez juste retourner un ou plusieurs bits, vous pouvez utiliser l' opérateur de-ou exclusif. (xor, ^ ). Cela renvoie 1 si l’un des bits d’entrée est l’un et 0 si les deux entrées sont les mêmes.

Nous pouvons utiliser les opérateurs composés pour rétrécir le code: x = x + 1 ; peut être écrit comme x += 1 ; par exemple. Il en va de même pour les opérateurs de bits. Nous n’avons plus besoin la variable temporaire.

Pour obtenir un bit spécifique dans le registre d’entrée, par exemple, vous pouvez utiliser la fonction bitRead (octets, bits) :

vous pourriez utiliser certains mathématiques de base pour obtenir le même résultat :

Cet exemple utilise un bon décalage de bits (>>) et un opérateur modulo (%): >> fait la même chose que <<, mais dans l’autre sens. Si PIND est B10101010, par exemple, PIND >> 6 = B10, fondamentalement, il côtelettes sur les 6 derniers chiffres (binaires). Le peu que nous avons voulu vérifier est maintenant le plus à droite bit. Modulo vous donne le reste d’une division, par exemple 10 %3 = 1, car 3 * 3 + 1 = 10, 5 %6 = 5, car 0 * 6 + 5 = 5, 23 8 % = 7, parce que 2 * 8 + 7 = 23. x 2 % vous donnera un 0 si x est pair et 1 si x est impair. En notation binaire, le dernier chiffre (bit la plus à droite) d’un nombre pair est 0 et le dernier chiffre d’un nombre impair est 1. Donc si nous voulons juste savoir le dernier chiffre d’un nombre binaire, nous pouvons simplement utiliser x 2 %.

Une autre façon d’obtenir que d’un bit d’un certain nombre utilise l' opérateur conditionnel ( ?: ) :

PIND & (1 << 6) va garder seul le bit 6 de PIND, tous les autres chiffres sera 0. Si PIND est B10101010, par exemple, PIND & (1 << 6) = B00000000, et s’il B01010101, PIND PIND & (1 << 6) = B01000000. Dans ces exemples, vous pouvez voir que le résultat est nul si le bit 6 a 0. Donc, si nous testons si ce résultat == 0, nous connaissons l’état du bit 6. Nous utilisons l’opérateur conditionnel : condition? resultIfTrue : resultIfFalse. Si la condition est vraie, l’opérateur retourne la resultIfTrue, si sa valeur est false, elle retourne resultIfFalse.

Note sur la compatibilité: le mappage de port-au-pin dépend de la puce. Cela signifie que vous devez changer votre programme si vous souhaitez utiliser un autre Arduino. Pour un usage personnel, ce n’est pas tellement un problème, mais si vous écrivez des programmes ou bibliothèques à la communauté et partager en ligne, vous devez en tenir compte.

Référence de l’Arduino : constantes entières

Il a tué mon fils : didacticiel manipulation directe port

Référence de l’Arduino : Manipulation de Port

L’Atmel ATmega 328 p fiche technique p.91 14,4

Référence de l’Arduino : bitRead