Interrupteurs Arduino et molette : 9 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Dans cet article, nous examinons l'utilisation des commutateurs à molette/molette avec nos systèmes Arduino. Voici quelques exemples provenant de PMD Way.

Étape 1:

Pour les non-initiés, chaque interrupteur est un segment vertical et ils peuvent être connectés ensemble pour former différentes tailles. Vous pouvez utiliser les boutons pour sélectionner les chiffres de zéro à neuf. Il existe des alternatives disponibles qui ont une molette que vous pouvez déplacer avec votre pouce au lieu des boutons d'augmentation/diminution.

Avant l'époque des interfaces utilisateur sophistiquées, ces commutateurs étaient des méthodes très populaires pour définir la saisie de données numériques. Cependant, ils sont toujours disponibles aujourd'hui, alors voyons comment ils fonctionnent et comment nous pouvons les utiliser. La valeur du commutateur est disponible via une décimale codée en binaire ou une décimale directe. Considérez l'arrière du commutateur sous forme BCD.

Étape 2:

Nous avons le commun à gauche, puis les contacts pour 1, 2, 4 et 8. Si vous appliquez une petite tension (disons 5V) au commun, la valeur de l'interrupteur peut être mesurée en ajoutant les valeurs des contacts qui sont dans le état ÉLEVÉ. Par exemple, si vous sélectionnez 3, les contacts 1 et 2 seront à la tension commune. Les valeurs comprises entre zéro et neuf peuvent être représentées telles quelles dans le tableau.

Étape 3:

À présent, vous devriez réaliser qu'il serait facile de lire la valeur d'un commutateur - et vous avez raison, c'est le cas. Nous pouvons connecter 5V au commun, les sorties aux broches d'entrée numérique de nos cartes Arduino, puis utiliser digitalRead() pour déterminer la valeur de chaque sortie. Dans l'esquisse, nous utilisons des mathématiques de base pour convertir la valeur BCD en un nombre décimal. Alors faisons-le maintenant.

D'un point de vue matériel, nous devons prendre en compte une autre chose: l'interrupteur à roue-poussoir se comporte électriquement comme quatre boutons-poussoirs normalement ouverts. Cela signifie que nous devons utiliser des résistances pull-down afin d'avoir une nette différence entre les états haut et bas. Le schéma d'un interrupteur est donc comme indiqué ci-dessus.

Étape 4:

Maintenant, il suffit de connecter les sorties étiquetées 1, 2, 4 et 8 (par exemple) aux broches numériques 8, 9, 10 et 11. Connectez 5V au point "C" du commutateur et GND à… GND. Ensuite, nous devons avoir un croquis qui peut lire les entrées et convertir la sortie BCD en décimal. Considérez le croquis suivant:

/* Utilise le shield d'affichage numérique SAA1064 https://www.gravitech.us/7segmentshield.html Utilise le moniteur série si vous n'avez pas le shield SAA1064 */ #include "Wire.h" #define q1 8 #define q2 9 # define q4 10 #define q8 11 void setup() { Serial.begin (9600); Fil.begin(); // rejoindre le bus i2c (adresse facultative pour le maître) delay(500); pinMode(q1, INPUT); // molette '1' pinMode(q2, INPUT); // molette '2' pinMode(q4, INPUT); // molette '4' pinMode(q8, INPUT); // molette '8' } void dispSAA1064(int Count) // envoie l'entier 'Count' à Gravitech SAA1064 shield { const int lookup[10] = { 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F }; int milliers, centaines, dizaines, base; Wire.beginTransmission (0x38); Wire.write(0); Wire.write(B01000111); Wire.endTransmission(); Wire.beginTransmission (0x38); Wire.write(1); Milliers = Compte/1000; Centaines = (Compter-(En milliers*1000))/100; Dix = (Compter-((Milliers*1000)+(Centaines*100)))/10; Base = Compte-((Milliers*1000)+(Centaines*100)+(Dizaines*10)); Wire.write(lookup[Base]); Wire.write(lookup[Dizaines]); Wire.write(lookup[Centaines]); Wire.write(lookup[Millers]); Wire.endTransmission(); retard(10); } int readSwitch() { int total=0; if (digitalRead(q1)==HIGH) { total+=1; } if (digitalRead(q2)==HIGH) { total+=2; } if (digitalRead(q4)==HIGH) { total+=4; } if (digitalRead(q8)==HIGH) { total+=8; } renvoie le total; } boucle vide() { dispSAA1064(readSwitch()); // envoie la valeur du commutateur pour afficher le bouclier Serial.println(readSwitch()); // envoie la valeur du commutateur au boîtier de surveillance série }

La fonction readSwitch() est la clé. Il calcule la valeur du commutateur en ajoutant la représentation numérique de chaque sortie de commutateur et renvoie le total comme résultat. Pour cet exemple, nous avons utilisé un écran d'affichage numérique contrôlé par le NXP SAA1064.

Étape 5:

La fonction readSwitch() est la clé. Il calcule la valeur du commutateur en ajoutant la représentation numérique de chaque sortie de commutateur et renvoie le total comme résultat. Pour cet exemple, nous avons utilisé un écran d'affichage numérique contrôlé par le NXP SAA1064.

Si vous n'en avez pas, ce n'est pas grave - les résultats sont également envoyés au moniteur série. Voyons maintenant cela en action dans la vidéo.

Étape 6:

D'accord, cela ne ressemble pas à grand-chose, mais si vous avez besoin d'une entrée numérique, cela économise beaucoup d'espace physique et offre une méthode de saisie précise.

Alors voilà. Les utiliseriez-vous réellement dans un projet ? Pour un chiffre – oui. Pour quatre? Probablement pas – il serait peut-être plus facile d'utiliser un clavier à 12 chiffres. Il y a une idée…

Étape 7: plusieurs commutateurs

Nous allons maintenant examiner comment lire quatre chiffres - et ne pas gaspiller toutes ces broches numériques dans le processus. Au lieu de cela, nous utiliserons le CI d'extension de port 16 bits Microchip MCP23017 qui communique via le bus I2C. Il dispose de seize broches d'entrée/sortie numériques que nous pouvons utiliser pour lire l'état de chaque commutateur.

Avant d'aller de l'avant, veuillez noter que certaines connaissances supposées sont nécessaires pour cet article - le bus I2C (parties un et deux) et le MCP23017. Nous décrirons d'abord les connexions matérielles, puis le croquis Arduino. Rappelez-vous le schéma utilisé pour l'exemple de commutateur unique.

Lorsque le commutateur était directement connecté à l'Arduino, nous lisons l'état de chaque broche pour déterminer la valeur du commutateur. Nous allons recommencer, à plus grande échelle en utilisant le MCP23017. Considérez le schéma de brochage:

Étape 8:

Nous avons 16 broches, ce qui permet de connecter quatre commutateurs. Les communs de chaque commutateur sont toujours connectés à 5 V et chaque contact de commutateur a toujours une résistance de rappel de 10 k vers GND. Ensuite, nous connectons les broches 1, 2, 4, 8 du chiffre un à GPBA0 ~ 3; chiffre deux 1, 2, 4, 8 à GPA4~7; chiffre trois 1, 2, 4, 8 à GPB0~3 et chiffre quatre 1, 2, 4, 8 à GPB4~7.

Maintenant, comment lisons-nous les commutateurs ? Tous ces fils peuvent vous faire penser que c'est difficile, mais le croquis est assez simple. Lorsque nous lisons la valeur de GPBA et B, un octet est renvoyé pour chaque banque, le bit le plus significatif en premier. Chaque quatre bits correspondra au réglage du commutateur connecté aux broches d'E/S correspondantes. Par exemple, si nous demandons les données des deux banques d'E/S et que les commutateurs sont réglés sur 1 2 3 4, la banque A renverra 0010 0001 et la banque B renverra 0100 0011.

Nous utilisons des opérations de décalage de bits pour séparer chaque quatre bits en une variable distincte – ce qui nous laisse avec la valeur de chaque chiffre. Par exemple, pour séparer la valeur du commutateur quatre, nous décalons les bits de la banque B >> 4. Cela repousse la valeur du commutateur trois et les bits vides à gauche deviennent zéro.

Pour séparer la valeur du commutateur trois, nous utilisons un composé au niveau du bit & – qui laisse la valeur du commutateur trois. L'image montre une ventilation des valeurs de commutateur binaire - elle montre les valeurs brutes de GPIOA et d'octet B, puis la valeur binaire de chaque chiffre et la valeur décimale.

Étape 9:

Voyons donc le croquis de démonstration:

/* Exemple 40a - Lecture de quatre commutateurs BCD à molette via MCP23017, affichage sur un affichage LED SAA1064/4 chiffres à 7 segments */ // MCP23017 broches 15~17 à GND, l'adresse du bus I2C est 0x20 // Adresse du bus SAA1064 I2C 0x38 # inclure "Wire.h" // pour les définitions de chiffres LED int digits[16]={ 63, 6, 91, 79, 102, 109, 125, 7, 127, 111, 119, 124, 57, 94, 121, 113 }; octet GPIOA, GPIOB, dig1, dig2, dig3, dig4; void initSAA1064() { //configuration 0x38 Wire.beginTransmission (0x38); Wire.write(0); Wire.write(B01000111); // Sortie 12mA, pas de suppression de chiffre Wire.endTransmission(); } void setup() { Serial.begin(9600); Fil.begin(); // démarrer le bus I2C initSAA1064(); } void loop() { // lit les entrées de la banque A Wire.beginTransmission(0x20); Wire.write(0x12); Wire.endTransmission(); Wire.requestFrom (0x20, 1); GPIOA=Wire.read(); // cet octet contient les données de commutation pour les chiffres 1 et 2 // lit les entrées de la banque B Wire.beginTransmission(0x20); Wire.write(0x13); Wire.endTransmission(); Wire.requestFrom (0x20, 1); GPIOB=Wire.read(); // cet octet contient les données de commutation pour les chiffres 3 et 4 // extrait la valeur pour chaque commutateur // dig1 LHS, dig4 RHS dig4=GPIOB >> 4; dig3=GPIOB & B00001111; dig2=GPIOA >> 4; dig1=GPIOA & B00001111; // envoie toutes les données GPIO et de commutateur individuel au moniteur série // pour le débogage et l'intérêt Serial.print("GPIOA = "); Serial.println(GPIOA, BIN); Serial.print("GPIOB = "); Serial.println(GPIOB, BIN); Serial.println(); Serial.print("chiffre 1 = "); Serial.println(dig1, BIN); Serial.print("chiffre 2 = "); Serial.println(dig2, BIN); Serial.print("chiffre 3 = "); Serial.println(dig3, BIN); Serial.print("chiffre 4 = "); Serial.println(dig4, BIN); Serial.println(); Serial.print("chiffre 1 = "); Serial.println(dig1, DEC); Serial.print("chiffre 2 = "); Serial.println(dig2, DEC); Serial.print("chiffre 3 = "); Serial.println(dig3, DEC); Serial.print("chiffre 4 = "); Serial.println(dig4, DEC); Serial.println(); // envoyer la valeur de commutation à l'affichage LED via SAA1064 Wire.beginTransmission (0x38); Wire.write(1); Wire.write(chiffres[dig4]); Wire.write(chiffres[dig3]); Wire.write(chiffres[dig2]); Wire.write(chiffres[dig1]); Wire.endTransmission(); retard(10); retard(1000); }

Et pour les non-croyants… une démonstration vidéo.

Alors voilà. Quatre chiffres au lieu d'un, et sur le bus I2C en conservant les broches d'E/S numériques Arduino. En utilisant huit MCP23017, vous pouviez lire 32 chiffres à la fois. Amusez-vous à faire ça !

Vous pouvez commander des commutateurs BCD et décimaux de différentes tailles auprès de PMD Way, avec une livraison gratuite dans le monde entier.

Cet article vous est présenté par pmdway.com - tout pour les fabricants et les passionnés d'électronique, avec une livraison gratuite dans le monde entier.