Arduino und Daumenrad-Schalter - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

In diesem Artikel untersuchen wir die Verwendung von Push-Wheel-/Daumenrad-Schaltern mit unseren Arduino-Systemen. Hier sind einige Beispiele von PMD Way.

Schritt 1:

Für Uneingeweihte ist jeder Schalter ein vertikales Segment und sie können miteinander verbunden werden, um verschiedene Größen zu bilden. Mit den Tasten können Sie zwischen den Ziffern null bis neun wählen. Es gibt Alternativen, die ein Rad haben, das Sie mit dem Daumen anstelle der Tasten zum Erhöhen/Verringern bewegen können.

Vor den Tagen der ausgefallenen Benutzeroberflächen waren diese Schalter recht beliebte Methoden zur Einstellung der numerischen Dateneingabe. Sie sind jedoch auch heute noch verfügbar. Sehen wir uns also an, wie sie funktionieren und wie wir sie verwenden können. Der Wert des Schalters wird binär codiert dezimal oder gerade dezimal zur Verfügung gestellt. Betrachten Sie die Rückseite des Schalters in BCD-Form.

Schritt 2:

Links haben wir Masse, dann Kontakte für 1, 2, 4 und 8. Wenn Sie eine kleine Spannung (z. B. 5 V) an Masse anlegen, kann der Wert des Schalters gemessen werden, indem die Werte der Kontakte addiert werden, die im HIGH-Zustand. Wenn Sie beispielsweise 3 auswählen, liegen die Kontakte 1 und 2 auf der gemeinsamen Spannung. Die Werte zwischen null und neun können als solche in der Tabelle dargestellt werden.

Schritt 3:

Inzwischen sollte Ihnen klar sein, dass es leicht wäre, den Wert eines Schalters abzulesen – und Sie haben Recht, es ist so. Wir können 5V an den gemeinsamen, die Ausgänge an die digitalen Eingangspins unserer Arduino-Boards anschließen und dann mit digitalRead() den Wert jedes Ausgangs bestimmen. In der Skizze verwenden wir einige grundlegende Mathematik, um den BCD-Wert in eine Dezimalzahl umzuwandeln. Also machen wir das jetzt.

Aus Hardware-Sicht müssen wir noch eines berücksichtigen – der Push-Wheel-Schalter verhält sich elektrisch wie vier Schließer. Dies bedeutet, dass wir Pull-Down-Widerstände verwenden müssen, um einen klaren Unterschied zwischen High- und Low-Zuständen zu haben. Das Schema für einen Schalter ist also wie oben gezeigt.

Schritt 4:

Jetzt ist es einfach, die mit 1, 2, 4 und 8 gekennzeichneten Ausgänge mit (zum Beispiel) digitalen Pins 8, 9, 10 und 11 zu verbinden. Verbinden Sie 5V mit dem Schalter 'C'-Punkt und GND mit … GND. Als nächstes benötigen wir eine Skizze, die die Eingaben lesen und die BCD-Ausgabe in Dezimalzahlen umwandeln kann. Betrachten Sie die folgende Skizze:

/* Verwendet das numerische SAA1064-Display-Schild https://www.gravitech.us/7segmentshield.html Verwendet den seriellen Monitor, wenn Sie das SAA1064-Schild nicht haben */ #include "Wire.h" #define q1 8 #define q2 9 # definiere q4 10 #define q8 11 void setup () { Serial.begin (9600); Wire.begin(); // i2c-Bus beitreten (Adresse optional für Master) Verzögerung (500); pinMode (q1, EINGANG); // Daumenrad '1' PinMode (q2, INPUT); // Daumenrad '2' PinMode (q4, INPUT); // Daumenrad '4' PinMode (q8, INPUT); // Daumenrad '8' } void dispSAA1064(int Count) // sendet Integer 'Count' an Gravitech SAA1064 Shield { const int lookup[10] = { 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F}; int Tausender, Hunderter, Zehner, Basis; Wire.beginTransmission(0x38); Wire.write(0); Wire.write (B01000111); Wire.endTransmission(); Wire.beginTransmission(0x38); Wire.write(1); Tausende = Anzahl/1000; Hunderte = (Anzahl-(Tausende*1000))/100; Zehner = (Anzahl – ((Tausende*1000)+(Hunderte*100)))/10; Basis = Anzahl-((Tausend*1000)+(Hunderter*100)+(Zehn*10)); Wire.write(lookup[Base]); Wire.write(lookup[Tens]); Wire.write(lookup[Hunderte]); Wire.write(lookup[Tausende]); Wire.endTransmission(); Verzögerung(10); aufrechtzuerhalten. Int readSwitch () {int total = 0; Wenn (digitalRead (q1) = = HOCH) { Gesamt + = 1; aufrechtzuerhalten. Wenn (digitalRead (q2) = = HOCH) { Gesamt + = 2; aufrechtzuerhalten. Wenn (digitalRead (q4) = = HOCH) { Gesamt + = 4; aufrechtzuerhalten. Wenn (digitalRead (q8) = = HOCH) { Gesamt + = 8; } Gesamtsumme zurückgeben; aufrechtzuerhalten. Void Schleife () { dispSAA1064 (readSwitch ()); // sendet den Schalterwert an das Display-Schild Serial.println (readSwitch ()); // sendet Schalterwert an serielle Monitorbox}

Die Funktion readSwitch() ist der Schlüssel. Es berechnet den Wert des Schalters, indem es die numerische Darstellung jedes Schalterausgangs addiert und als Ergebnis die Summe zurückgibt. Für dieses Beispiel haben wir ein numerisches Display-Shield verwendet, das vom NXP SAA1064 gesteuert wird.

Schritt 5:

Die Funktion readSwitch() ist der Schlüssel. Es berechnet den Wert des Schalters, indem es die numerische Darstellung jedes Schalterausgangs addiert und als Ergebnis die Summe zurückgibt. Für dieses Beispiel haben wir ein numerisches Display-Shield verwendet, das vom NXP SAA1064 gesteuert wird.

Wenn Sie keinen haben, ist das in Ordnung – die Ergebnisse werden auch an den seriellen Monitor gesendet. Sehen wir es uns jetzt im Video in Aktion an.

Schritt 6:

Ok, es sieht nicht nach viel aus, aber wenn Sie eine numerische Eingabe benötigen, spart es viel Platz und bietet eine präzise Eingabemethode.

Da hast du es also. Würden Sie diese tatsächlich in einem Projekt verwenden? Für eine Ziffer – ja. Für vier? Wahrscheinlich nicht – vielleicht wäre es einfacher, eine 12-stellige Tastatur zu verwenden. Es gibt eine Idee…

Schritt 7: Mehrere Schalter

Jetzt werden wir untersuchen, wie man vier Ziffern liest – und dabei nicht all diese digitalen Pins verschwendet. Stattdessen verwenden wir den 16-Bit-Port-Expander-IC MCP23017 von Microchip, der über den I2C-Bus kommuniziert. Es verfügt über sechzehn digitale Ein-/Ausgangspins, mit denen wir den Status jedes Schalters lesen können.

Bevor Sie fortfahren, beachten Sie bitte, dass für diesen Artikel einige vorausgesetzte Kenntnisse erforderlich sind – der I2C-Bus (Teil eins und zwei) und der MCP23017. Wir beschreiben zuerst die Hardwareverbindungen und dann die Arduino-Skizze. Erinnern Sie sich an den Schaltplan, der für das Beispiel mit einem einzelnen Schalter verwendet wurde.

Wenn der Schalter direkt mit dem Arduino verbunden war, lesen wir den Status jedes Pins, um den Wert des Schalters zu bestimmen. Wir werden dies wiederholen, in größerem Umfang mit dem MCP23017. Betrachten Sie das Pinbelegungsdiagramm:

Schritt 8:

Wir haben 16 Pins, wodurch vier Schalter angeschlossen werden können. Die Commons für jeden Schalter sind immer noch mit 5V verbunden, und jeder Schaltkontakt hat immer noch einen 10k-Pulldown-Widerstand gegen GND. Dann verbinden wir die 1, 2, 4, 8 Pins der Ziffer eins mit GPBA0~3; Ziffer zwei 1, 2, 4, 8 bis GPA4~7; Ziffer drei 1, 2, 4, 8 zu GPB0~3 und Ziffer vier 1, 2, 4, 8 bis GPB4~7.

Wie lesen wir nun die Schalter? All diese Drähte können dazu führen, dass Sie denken, dass es schwierig ist, aber die Skizze ist ziemlich einfach. Wenn wir den Wert von GPBA und B lesen, wird für jede Bank ein Byte zurückgegeben, mit dem höchstwertigen Bit zuerst. Alle vier Bits entsprechen der Einstellung des Schalters, der mit den entsprechenden I/O-Pins verbunden ist. Wenn wir beispielsweise die Daten für beide E/A-Bänke anfordern und die Schalter auf 1 2 3 4 stehen, gibt Bank A 0010 0001 und Bank B 0100 0011 zurück.

Wir verwenden einige Bitshift-Operationen, um jeweils vier Bits in eine separate Variable zu trennen – was uns den Wert jeder Ziffer hinterlässt. Um beispielsweise den Wert von Schalter vier zu trennen, verschieben wir die Bits von Bank B >> 4. Dadurch wird der Wert von Schalter drei nach außen gedrückt und die leeren Bits auf der linken Seite werden null.

Um den Wert für Schalter drei zu trennen, verwenden wir ein zusammengesetztes bitweises & – was den Wert von Schalter drei belässt. Das Bild zeigt eine Aufschlüsselung der binären Schalterwerte – es zeigt die rohen GPIOA- und B-Byte-Werte, dann den Binärwert jeder Stelle und den Dezimalwert.

Schritt 9:

Sehen wir uns also die Demonstrationsskizze an:

/* Beispiel 40a - Lesen von vier Pushwheel-BCD-Schaltern über MCP23017, Anzeige auf SAA1064/4-stellige 7-Segment-LED-Anzeige */ // MCP23017 Pins 15~17 an GND, I2C-Busadresse ist 0x20 // SAA1064 I2C-Busadresse 0x38 # include "Wire.h" // für LED-Zifferndefinitionen int digits[16]={ 63, 6, 91, 79, 102, 109, 125, 7, 127, 111, 119, 124, 57, 94, 121, 113 }; Byte GPIOA, GPIOB, dig1, dig2, dig3, dig4; Void initSAA1064 () {//Setup 0x38 Wire.beginTransmission (0x38); Wire.write(0); Wire.write (B01000111); // 12mA Ausgang, keine Ziffernaustastung Wire.endTransmission(); aufrechtzuerhalten. Void setup () { Serial.begin (9600); Wire.begin(); // I2C-Bus starten initSAA1064(); aufrechtzuerhalten. Void loop () {// die Eingänge von Bank A lesen Wire.beginTransmission (0x20); Wire.write (0x12); Wire.endTransmission(); Wire.requestFrom(0x20, 1); GPIOA=Wire.read(); // dieses Byte enthält die Schaltdaten für die Ziffern 1 und 2 // die Eingänge von Bank B lesen Wire.beginTransmission(0x20); Wire.write (0x13); Wire.endTransmission(); Wire.requestFrom(0x20, 1); GPIOB=Wire.read(); // dieses Byte enthält die Schalterdaten für die Ziffern 3 und 4 // Extrahieren Sie den Wert für jeden Schalter // dig1 LHS, dig4 RHS dig4=GPIOB >> 4; dig3=GPIOB & B00001111; dig2=GPIOA >> 4; dig1=GPIOA & B00001111; // alle GPIO- und einzelnen Switch-Daten an den seriellen Monitor senden // zum Debuggen und aus Interesse Serial.print ("GPIOA = "); Serial.println (GPIOA, BIN); Serial.print ("GPIOB = "); Serial.println (GPIOB, BIN); Serial.println(); Serial.print ("Ziffer 1 = "); Serial.println (dig1, BIN); Serial.print ("Ziffer 2 = "); Serial.println (dig2, BIN); Serial.print ("Ziffer 3 = "); Serial.println (dig3, BIN); Serial.print ("Ziffer 4 = "); Serial.println (dig4, BIN); Serial.println(); Serial.print ("Ziffer 1 = "); Serial.println (dig1, DEC); Serial.print ("Ziffer 2 = "); Serial.println (dig2, DEC); Serial.print ("Ziffer 3 = "); Serial.println (dig3, DEC); Serial.print ("Ziffer 4 = "); Serial.println (dig4, DEC); Serial.println(); // Schaltwert über SAA1064 Wire.beginTransmission (0x38) an LED-Anzeige senden; Wire.write(1); Wire.write (Ziffern [dig4]); Wire.write (Ziffern[dig3]); Wire.write (Ziffern[dig2]); Wire.write (Ziffern[dig1]); Wire.endTransmission(); Verzögerung(10); Verzögerung (1000); }

Und für die Ungläubigen … eine Videodemonstration.

Da hast du es also. Vier Ziffern statt einer, und über den I2C-Bus, der die digitalen I/O-Pins von Arduino schont. Mit acht MCP23017 können Sie 32 Ziffern gleichzeitig lesen. Viel Spaß dabei!

Bei PMD Way können Sie sowohl BCD- als auch Dezimalschalter in verschiedenen Größen versandkostenfrei weltweit bestellen.

Dieser Beitrag von pmdway.com – alles für Macher und Elektronik-Enthusiasten, weltweit versandkostenfrei.