64-Tasten-Prototyping-Tastaturmatrix für Arduino

Notwendige Werkzeuge und Maschinen

Lötkolben (generisch)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Update:Ich habe den Code verbessert, siehe "Update" am Ende.

Ich arbeite derzeit an einem Projekt, das eine integrierte Tastatur haben wird, was ein Problem darstellte:Wie baue ich eine Tastatur in den Prototyp des Entwicklungsboards ein? Ich kann keine USB-Tastatur oder eine vorhandene Arduino-basierte Tastatur verwenden, da die Tastatur im eigentlichen Projekt direkt mit dem Mikrocontroller verbunden ist, der alle anderen Funktionen übernimmt. Also habe ich diese grundlegende PCB-basierte 64-Tasten-Prototyping-Tastaturmatrix entworfen.

Diese Leiterplatte enthält keine ICs (integrierte Schaltkreise). Die Zeilen und Spalten der Tastaturmatrix werden direkt mit den Stiftleisten verbunden, sodass die Tastatur an einen Arduino oder einen anderen Mikrocontroller angeschlossen werden kann. Es ist perfekt für das Prototyping Ihrer Projekte mit integrierter Tastatur.

Ich habe detaillierten, stark kommentierten Code eingefügt, damit dies mit jedem Arduino-kompatiblen Entwicklungsboard funktioniert, das über genügend I/O-Pins verfügt – 11 Pins sind erforderlich. Die Tastatur verfügt über 64 Tasten, einschließlich Modifikatoren für Shift, Caps, Strg, Alt, Fn und "Special". Es gibt auch sechs zusätzliche Tasten, die Sie nach Belieben verwenden können. Die Funktionen jeder einzelnen Taste können individuell definiert werden, einschließlich der Funktion jeder Taste, wenn ein Modifikator aktiv ist. Das ist meiner Meinung nach signifikant nützlicher als vorhandener Tastaturcode, der Ihre Möglichkeiten zur Anpassung des Tastenverhaltens stark einschränkt.

Der bereitgestellte Code druckt Text an Serial. Dies kann leicht geändert werden, wenn der Text woanders hingehört.

Ein Hinweis zur Programmgröße:

Der von mir bereitgestellte Code ist ziemlich groß, da er keinerlei vorhandene Bibliotheken verwendet. Ich habe diesen Code komplett von Grund auf neu geschrieben, um die erforderliche Anpassbarkeit zu ermöglichen. Auf einem Arduino UNO werden 9100 Byte (28%) des Programmspeicherplatzes verwendet und globale Variablen verwenden 394 Byte (19%) des dynamischen Speichers.

Mein Code könnte wahrscheinlich effizienter sein und dort sind Bibliotheken und Skizzen für Tastaturen sicherlich kleiner, aber dies ist die einzige Möglichkeit, die ich mir vorstellen kann, um mit jedem Modifikator über jede Taste vollständige Flexibilität zu bieten. Es berücksichtigt auch die reale Tastaturnutzung. Wenn mein Code beispielsweise bei aktivierter Feststelltaste die Umschalttaste drückt, wird ein Kleinbuchstabe angezeigt, wie es sollte. Wenn Sie die FN-Taste gedrückt halten, während Sie ESC drücken, wird standardmäßig nichts bewirkt. Dieses Verhalten ist jedoch vollständig anpassbar, sodass Sie es nach Belieben ändern können.

Zubehör:

• Die benutzerdefinierte Leiterplatte
• 6x6x5mm taktile Taster (x64)
• 1N4148 Schaltdioden (x64)
• 1x8-Stiftleisten, weiblich oder männlich (x2)
• 74HC595 Schieberegister
• Überbrückungsdrähte
• Breadboard
• Arduino Uno oder jedes Arduino-kompatible Mikrocontroller-Entwicklungsboard

Schritt 1:So funktioniert eine Tastaturmatrix

Warum ist eine Tastaturmatrix notwendig?

Diese Tastatur hat 64 Tasten. Wenn Sie jede einzelne dieser Tasten direkt mit Ihrem Entwicklungsboard verbinden würden, würden Sie 64 I/O-Pins benötigen. Das ist viel Pins und mehr als die meisten Entwicklungsboards zur Verfügung haben. Um dies auf eine viel vernünftigere Zahl zu bringen, können wir eine Tastaturmatrix verwenden, die nur eine Anzahl von Pins benötigt, die der Quadratwurzel (aufgerundet) der Anzahl der Tasten entspricht.

Eine Tastaturmatrix ist so aufgebaut, dass jeder Tastenschalter in einer Reihe verbunden ist und jeder Tastenschalter in einer Spalte verbunden ist. Wenn wir sehen wollen, welche Tasten gedrückt werden, "aktivieren" wir die erste Zeile und überprüfen dann jede Spalte. Wenn eine bestimmte Spalte aktiv ist, wissen wir, dass die Taste in dieser Spalte und Zeile 1 gedrückt wurde. Wir deaktivieren dann Zeile 1 und aktivieren Zeile 2, dann überprüfen wir alle Spalten erneut. Nachdem alle Reihen aktiviert wurden, fangen wir einfach wieder bei der ersten Reihe an.

So scannen wir die Tastaturmatrix:

Da wir mit einem Mikrocontroller arbeiten, bedeutet "aktivieren", dass diese Zeile entweder auf LOW oder HIGH gesetzt wird. In diesem Fall setzen wir die Zeile auf LOW, weil wir die eingebauten Pullup-Widerstände des Mikrocontrollers verwenden an unseren Spalteneingangspins. Ohne Pullup- oder Pulldown-Widerstand reagiert ein Eingangspin aufgrund der Schnittstelle unvorhersehbar, wodurch falsche Tastendrücke registriert werden.

Der im Arduino UNO verwendete Mikrocontroller ATmega328P hat keine eingebauten Pulldown-Widerstände, sondern nur Pullup-Widerstände. Also verwenden wir diese. Die Pullup-Widerstände verbinden jeden Eingangspin mit 5V, um sicherzustellen, dass sie immer HIGH lesen, bis eine Taste gedrückt wird.

Alle Zeilen sind normalerweise auch auf HIGH gesetzt, was verhindert, dass die Spaltenpins mit den Zeilenpins verbunden werden, egal ob eine Taste gedrückt wurde oder nicht. Aber wenn wir bereit sind, eine Zeile zu überprüfen, können wir diese Zeile auf LOW setzen . Wenn eine Taste in dieser Reihe gedrückt wird, wird dadurch ein Pfad bereitgestellt, über den der Eingangspin auf Masse gezogen wird – was dazu führt, dass diese Spalte jetzt als LOW angezeigt wird .

Um es zusammenzufassen:Wir setzen eine Zeile auf LOW und prüfen dann, welche Spaltenpins jetzt LOW lesen. Diese entsprechen gedrückten Tasten. Dieser Vorgang geschieht sehr schnell, sodass wir die gesamte Tastatur viele Male pro Sekunde scannen können. Mein Code begrenzt dies auf 200 Mal pro Sekunde, was die Leistung, das Prellen und sicherstellt, dass jeder Tastendruck erfasst wird.

Dioden, Ghosting und N-Key-Rollover:

Die Dioden im Stromkreis sollen unbeabsichtigte Tastendrücke verhindern, wenn bestimmte Tastenkombinationen gedrückt werden. Dioden lassen Strom nur in eine Richtung fließen, was Geisterbilder verhindert. Wenn wir keine Dioden verwenden, könnte das Drücken bestimmter Tasten dazu führen, dass eine andere nicht gedrückte Taste registriert wird, da Strom durch die benachbarten Schalter fließt. Dies wird in der vereinfachten Grafik gezeigt, in der das Drücken von drei benachbarten Tasten dazu führt, dass die Taste in der vierten Ecke registriert wird, auch wenn sie nicht gedrückt wird. Die Dioden verhindern dies und ermöglichen "n-key rollover", was bedeutet, dass wir ohne Probleme beliebig viele Tasten in jeder gewünschten Kombination drücken können.

Pins speichern mit einem Schieberegister:

Die Klugen unter Ihnen haben wahrscheinlich bemerkt, dass ich gesagt habe, dass eine Tastaturmatrix eine Anzahl von Pins erfordert, die der Quadratwurzel der Anzahl der Tasten entspricht, aber dass ich auch sagte, dass mein Tastaturdesign nur 11 Pins benötigt. Es sollten 16 sein, oder? Nein, weil wir ein 74HC595-Schieberegister verwenden. Mit diesem Schieberegister können wir nur drei der I / O-Pins des Arduino verwenden, um bis zu acht Ausgangspins zu steuern. Mit diesen drei Pins können wir ein Byte (acht Bits) an das Schieberegister senden, das seine acht Ausgangspins entweder auf HIGH oder LOW setzt. Durch die Verwendung des Schieberegisters für die Ausgangsreihenpins sparen wir 5 ganze I/O-Pins!

"Warum also nicht auch ein Schieberegister für die Eingangspins verwenden?" du fragst. Die einfachste Antwort ist, dass die Eingabe eine andere Art von Schieberegister erfordert und ich diesen Typ nicht zur Hand hatte. Die Verwendung eines Schieberegisters für die Eingabe verkompliziert jedoch auch das Lesen der Spalten und kann zu Problemen mit Rauschen und "Bouncen" führen. Es genügt zu sagen, dass es Kopfschmerzen sind, die ich in diesem Fall nicht übernehmen musste.

Schritt 2:PCB-Design

Schaltplan

Nachdem Sie nun verstanden haben, wie eine Tastaturmatrix funktioniert, sollte mein PCB-Design unkompliziert sein. Ich entwarf die Platine in KiCAD (sorry Eagle-Richter) und begann mit dem Schaltplan. Ich habe einfach ein Schaltflächensymbol und ein Diodensymbol platziert, diese dann kopiert und eingefügt, bis ich mein Raster von 64 Tasten hatte. Dann habe ich zwei 1x8-Stiftleistensymbole hinzugefügt, eines für die Zeilen und eines für die Spalten. Eine Seite der Schaltflächen wurde in Spalten und die andere Seite der Schaltflächen in Reihen verbunden.

Der nächste Schritt bestand darin, jedem dieser Schaltplansymbole PCB-Footprints zuzuweisen. In der mitgelieferten Footprint-Bibliothek von KiCAD waren die notwendigen Footprints integriert. Wenn Sie Ihre eigenen PCBs entwerfen, müssen Sie sehr vorsichtig sein, um die richtigen Footprints zu wählen, da diese tatsächlich auf Ihrer PCB landen. Es gibt viele Komponenten, die sehr ähnliche Grundrisse haben, aber mit leicht unterschiedlichen Steigungen oder was auch immer. Stellen Sie sicher, dass Sie diejenigen auswählen, die Ihren realen Komponenten entsprechen.

Fußabdrücke und Pin-Nummern

Achten Sie besonders auf die Pin-Nummern. KiCAD hat ein seltsames Problem, bei dem die Pinnummern des Schaltplans der Diodensymbole nicht mit den Pinnummern des Footprints übereinstimmen. Dies führt dazu, dass Dioden rückwärts gerichtet sind, was angesichts ihrer Polarität ein ernstes Problem darstellt. Ich habe diesen Fehler nicht bemerkt und musste die erste Charge von Leiterplatten, die ich bestellt hatte, wegwerfen. Um dieses Problem bei der zweiten Revision zu beheben, musste ich einen benutzerdefinierten Dioden-Footprint mit vertauschten Pin-Nummern erstellen.

PCB-Layout

Nachdem der Schaltplan fertig und die Footprints zugewiesen waren, ging ich zum eigentlichen PCB-Layout über. Der Platinenumriss wurde in Autodesk Fusion 360 erstellt, als DXF exportiert und dann auf der Edge Cuts-Ebene in KiCAD importiert. Der überwiegende Teil der Arbeit danach bestand darin, die Tasten einfach so anzuordnen, dass sie ein Layout ähnlich einer normalen Tastatur hatten.

Dann wurden alle Spuren geroutet. Da das tatsächliche Tastenlayout nicht mit der ordentlichen Matrix im Schaltplan übereinstimmt, wurde dieser Teil etwas unordentlich und ich musste an einigen Stellen auf Vias zurückgreifen. Mit Vias können Sie eine Leiterbahn von einer Schicht zu einer anderen leiten, was sehr hilfreich ist, wenn Sie eine 2-Schicht-Platine mit vielen überlappenden Leiterbahnen verwenden. Schließlich habe ich gefüllte Regionen hinzugefügt, weil es eine gute Praxis ist.

PCB-Herstellung

Mit dem entworfenen Board habe ich einfach alle Ebenen geplottet und sie einem Zip-Ordner hinzugefügt. Dieser Ordner wird hier bereitgestellt und kann direkt zu einem PCB-Fertigungsservice wie JLCPCB hochgeladen werden.

Hier ist der Link zu den PCB-Gerber-Dateien:https://drive.google.com/file/d/10YriLLtghV0Sb84Wm...

Schritt 3:Leiterplattenbestückung

Dies ist der einfachste, aber mühsamste Schritt im gesamten Projekt. Löten Sie einfach alle Komponenten an Ort und Stelle. Sie sind alle Durchsteckkomponenten und einfach zu löten. Achten Sie besonders auf die Ausrichtung der Dioden. Die Markierung auf den Dioden sollte mit den Markierungen auf der Platine übereinstimmen.

Meiner Erfahrung nach war es am einfachsten, die Platine mit einer dritten Hand festzuhalten und alle Dioden zuerst einzusetzen. Dann drehen Sie die Platine um und löten Sie sie alle, dann klemmen Sie die Leitungen ab. Dann alle Knöpfe platzieren und diese verlöten. Dann die Stiftleisten anlöten. Sie können entweder weibliche oder männliche Stiftleisten verwenden, es liegt ganz bei Ihnen. Wenn Sie einen männlichen Kopf verwenden und dann darunter legen der Platine, der Abstand ist richtig, um sie direkt in ein Steckbrett zu stecken.

Schritt 4:Verbinden Sie die Tastatur mit Ihrem Arduino

Die Verkabelung sieht kompliziert aus, aber so schlimm ist es wirklich nicht, wenn man darauf achtet, wohin alles führt.

Acht Überbrückungsdrähte gehen vom Spaltenkopf direkt in die folgenden Arduino-Pins:

• Spalte 1> A0
• Spalte 2> A1
• Spalte 3> A2
• Spalte 4> A3
• Spalte 5> A4
• Spalte 6> A5
• Spalte 7> 5
• Spalte 8> 6

Als nächstes platzieren Sie das Schieberegister 74HC595 auf Ihrem Steckbrett, das den mittleren Bruch überspannt. Beachten Sie die Ausrichtung des Chips! Der Punkt zeigt Pin 1 an

Sehen Sie sich den Schaltplan an, um zu sehen, wo die 5V- und Masseanschlüsse verlaufen. Das Schieberegister hat zwei Pins, die mit 5V verbunden sind, und zwei Pins, die mit Masse verbunden sind.

Es werden nur drei Drähte benötigt, um das Schieberegister mit dem Arduino zu verbinden. Sie sind:

• Shift (Uhr) 11> 4
• Shift (Latch) 12> 3
• Schicht (Daten) 14 > 2

Aus irgendeinem albernen Grund sind die Ausgangspins des Schieberegisters nicht intuitiv angeordnet. Achten Sie besonders auf das Pinbelegungsdiagramm des Schieberegisters, wenn Sie diese mit Ihren Reihenpins verbinden. Sie sind:

• Reihe 1> Shift (Q0) 15
• Zeile 2> Schicht (Q1) 1
• Reihe 3> Schicht (Q2) 2
• Reihe 4> Schicht (Q3) 3
• Reihe 5> Schicht (Q4) 4
• Reihe 6> Schicht (Q5) 5
• Schicht 7> Schicht (Q6) 6
• Schicht 8> Schicht (Q7) 7

An den Arduino 0- oder 1-Pins ist nichts angeschlossen, da diese auch für den seriellen Port verwendet werden und Konflikte verursachen.

Schritt 5:Flashen Sie den Arduino-Code

Flashen Sie Ihr Arduino mit dem hier bereitgestellten Code. Daran ist nichts besonderes, laden Sie einfach den Code hoch, wie Sie es bei jedem anderen Arduino-Projekt tun würden.

Alles im Code enthält detaillierte Kommentare, die Sie durchlesen können, daher werde ich hier nicht ins Detail gehen. Grundsätzlich sind die Pins als Ein- und Ausgänge eingerichtet. Die Hauptschleife enthält lediglich eine Timerfunktion. Alle 5 ms ruft es die Funktion zum Scannen der Tastatur auf. Diese Funktion ruft eine separate Funktion auf, um das Schieberegister zu setzen, bevor die Spalten überprüft werden. Gedrückte Tasten drucken ihren Wert auf Serial.

Wenn Sie ändern möchten, was beim Drücken einer Taste gedruckt wird, ändern Sie einfach die Serial.print("_"); in der if-Anweisung, die der Bedingung entspricht. Sie können beispielsweise festlegen, was gedruckt wird, wenn Sie FN gedrückt halten und N drücken. Das gleiche gilt für jede andere Taste mit jedem Modifikator.

Viele Schlüssel tun in diesem Code überhaupt nichts, da er nur auf Serial gedruckt wird. Das bedeutet, dass die Rücktaste keine Wirkung hat, da Sie nicht aus dem Serial-Monitor löschen können – diese Daten wurden bereits empfangen. Es steht Ihnen jedoch frei, dies zu ändern, wenn Sie möchten.

Verwenden der Tastatur mit Ihren eigenen Projekten

Es ist schön, in Serie zu drucken, aber das ist nicht wirklich der Sinn dieser Tastatur. Der Zweck dieser Tastatur ist das Prototyping komplexerer Projekte. Deshalb ist es einfach, die Funktionalität zu ändern. Wenn Sie beispielsweise den eingegebenen Text auf einen OLED-Bildschirm drucken möchten, können Sie einfach jeden Serial.print( mit display.print( oder was auch immer Ihr spezielles Display erfordert. Alle ersetzen . der Arduino-IDE Werkzeug ist großartig, um alle in einem schnellen Schritt zu ersetzen.

Danke fürs Lesen und ich hoffe, dass diese Tastatur Ihnen bei Ihren Projekten hilft!

30.01.21 Aktualisierung:

​Dieser neue Code wurde komplett neu geschrieben und bietet eine bessere Leistung als der ursprüngliche Code. Dies geschah hauptsächlich, um ein Problem mit meinem Algorithmus zu beheben, der verhinderte, dass jedes Mal, wenn eine Taste gedrückt wurde, Zeichen eingegeben wurden. Der Originalcode wurde überprüft, um sicherzustellen, dass ein bestimmter Schlüssel nicht der letzte war Taste gedrückt werden. Dies führte zu einem Problem, wenn 2 oder mehr Tasten gedrückt wurden, wodurch etwas wie "fgfgfgfgfgfgfgfgfgfg" eingegeben wurde. Dies verhinderte auch, dass Sie sehr schnell dieselbe Taste immer wieder eingeben, z. B. wenn Sie die beiden ms in das Wort "bummer" eingeben.

Der neue Code löst beide Probleme und ist zudem eleganter. Anstatt die zuletzt gedrückte Taste zu verfolgen, überprüfen wir den Zustand der gesamten Tastatur und vergleichen ihn mit dem gesamten Tastaturzustand in der letzten Schleife. Dadurch kann die Schleife viel schneller ablaufen und Sie können auch sehr schnell denselben Schlüssel immer wieder eingeben. Die Leistung wird dramatisch verbessert. Alle Zeichen befinden sich auch oben in Arrays, sodass Sie sie leicht finden und ändern können. Für jeden Modifikator gibt es unabhängige Arrays. Der Code ist auch viel kürzer.

Der einzige Nachteil dieses neuen Ansatzes besteht darin, dass er mehr dynamischen Speicher verwendet, obwohl er deutlich weniger Programmspeicherplatz beansprucht. Auf einem Arduino Uno verwendet es jetzt:3532 Byte (10 %) des Programmspeicherplatzes und 605 Byte (29 %) des dynamischen Speichers.

Als zusätzlichen Bonus funktioniert dieser Code genauso gut auf schnellen Mikrocontrollern wie dem ARM Cortex-M4. Der Intervall-Timer zur Überprüfung der Tastatur wird in Mikrosekunden angegeben, sodass er auf jedem Board gleich ausgeführt wird. Sie können auch ganz einfach einstellen, wie oft die Tastatur überprüft wird. Standardmäßig wird alle 500 Mikrosekunden eine Schleife ausgeführt. Es dauert 8 Schleifen, um die Tastatur zu überprüfen, insgesamt 4000 Mikrosekunden (4 Millisekunden oder 250 Mal pro Sekunde). Es kann jedoch länger dauern, wenn das Mikro nicht schnell genug ist, um den Code so schnell auszuführen.

Code

• ProtoKeyboardV1.1-Shifted.ino
• ProtoKeyboardV1-Bits.ino

ProtoKeyboardV1.1-Shifted.inoArduino

Keine Vorschau (nur Download).

ProtoKeyboardV1-Bits.inoArduino

/* Sketch for Prototyping Keyboard V1.2 * von Cameron Coward 30.01.21 * * Getestet auf Arduino Uno. Erfordert eine benutzerdefinierte Leiterplatte * und ein 74HC595-Schieberegister. * * Weitere Informationen:https://www.hackster.io/cameroncoward/64-key-prototyping-keyboard-matrix-for-arduino-4c9531 */const int rowData =2; // Schieberegister Datenpin für rowsconst Int rowLatch =3; // Schieberegister Latch-Pin für rowsconst int rowClock =4; // Schieberegister Clock-Pin für Zeilen // Dies sind unsere Spalten-Eingangspins. Pin 0 und Pin 1 werden nicht verwendet, // weil sie Probleme verursachen (vermutlich weil sie TX und RX sind) const int colA =A0; const int colB =A1; const int colC =A2; const int colD =A3;const int colE =A4;const int colF =A5;const int colG =5;const int colH =6;// shiftRow ist das erforderliche Schieberegister-Byte für jede Zeile, rowState enthält gedrückte Tasten für jede rowconst byte shiftRow[] ={B01111111, B10111111, B11011111, B11101111, B11110111, B11111011, B11111101, B11111110};byte rowState[] ={B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B0000RowState ] ={B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000}; // ASCII-Codes für Tasten ohne gedrückte Modifikatoren. Modifikatoren sind NULL (0),// da wir diese separat prüfen und ihre Werte nicht ausgegeben werden sollten.const char key[] ={ 0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 91, 93, 92, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 59, 39, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Tasten mit gedrückter Umschalttaste UND Großbuchstaben ist aktivconst char capsShiftKey[] ={ 0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 123, 125, 124, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 58, 22, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Tasten mit gedrückter Umschalttaste.const char shiftKey[] ={ 0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 123, 125, 124, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 58, 22, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Tasten mit gedrückter Strg-Taste.const char ctrlKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Tasten mit spcl gedrückt.const char spclKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Tasten mit gedrücktem Alt.const char altKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Tasten mit gedrückter fn.const char fnKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // ASCII-Codes für Schlüssel mit Großbuchstaben ist aktivconst char capsKey[] ={ 0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0 , 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 91, 93, 92, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 59 , 39, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0 };long vorherigeKeyboardMicros =0; // speichert das letzte Mal, dass die Tastatur überprüft wurde // die folgenden Variablen sind lang, da die Zeit, gemessen in Millisekunden, // schnell eine größere Zahl wird, als in einer int.long gespeichert werden kann keyboardInterval =500; // Intervall, in dem die Tastatur überprüft werden soll (Mikrosekunden)int rowToCheck =0; // Wir überprüfen eine Zeile pro Schleife von checkKeyboard(), dies kombiniert mit keyboardInterval // gibt dem ShiftRegister Zeit, zwischen den Zeilen vollständig zu aktualisieren checksbool caps =false; // ist die Feststelltaste aktiviert?bool shift =false; // ist entweder die linke oder rechte Umschalttaste gedrückt?bool capsShift =false; // sind Shift UND Caps aktiv?bool ctrl =false; // ist die Strg-Taste gedrückt?bool spcl =false; // ist die spcl-Taste gedrückt?bool alt =false; // ist die Alt-Taste gedrückt?bool fn =false; // ist die Funktionstaste gedrückt?void setup () { Serial.begin (9600); // alle Spaltenpins als Eingänge mit internen Pullup-Widerständen einrichten pinMode (colA, INPUT_PULLUP); pinMode (colB, INPUT_PULLUP); pinMode (colC, INPUT_PULLUP); pinMode (colD, INPUT_PULLUP); pinMode (colE, INPUT_PULLUP); pinMode (colF, INPUT_PULLUP); pinMode(colG, INPUT_PULLUP); pinMode(colH, INPUT_PULLUP); // die zur Steuerung des 74HC595-Schieberegisters benötigten Ausgänge pinMode (rowLatch, OUTPUT); pinMode (rowClock, AUSGANG); pinMode (rowData, AUSGANG); updateShiftRegister(B11111111); // Stellen Sie sicher, dass das Schieberegister überhaupt beginnt HIGH}void loop () { mainTimer ();}void mainTimer () { unsigned long currentMicros =micros (); // Wie viele Mikrosekunden hat das Arduino gelaufen? if(currentMicros - previousKeyboardMicros> keyboardInterval) { // wenn die verstrichene Zeit seit der letzten Überprüfung das Intervall überschreitet // speichern Sie die letzte Überprüfung der Tastatur previousKeyboardMicros =currentMicros; checkKeyboard(); // Überprüfen Sie alle Schlüssel und drucken Sie die Ergebnisse nach seriell aus.}}void updateShiftRegister (byte row) { // Diese Funktion setzt das Schieberegister entsprechend dem Byte, das ihm übergeben wurde DigitalWrite (rowLatch, LOW); // Latch auf Low setzen, damit wir ein ganzes Byte auf einmal schreiben können shiftOut(rowData, rowClock, MSBFIRST, row); // schreibe dieses Byte digitalWrite (rowLatch, HIGH); // Latch wieder auf High setzen, damit das Schieberegister bis zur nächsten Änderung stabil bleibt}void checkKeyboard() { // setze das Schieberegister auf den Byte-Wert der aktuellen Zeile aus dem Byte-Array shiftRow[] updateShiftRegister(shiftRow[rowToCheck]); // Jede Spalte überprüfen if (digitalRead (colA) ==LOW) { bitSet (rowState [rowToCheck], 0); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 0); aufrechtzuerhalten. Wenn (digitalRead (colB) ==LOW) { bitSet (rowState [rowToCheck], 1); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 1); aufrechtzuerhalten. Wenn (digitalRead (colC) ==LOW) { bitSet (rowState [rowToCheck], 2); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 2); aufrechtzuerhalten. Wenn (digitalRead (colD) ==LOW) { bitSet (rowState [rowToCheck], 3); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 3); aufrechtzuerhalten. Wenn (digitalRead (colE) ==LOW) { bitSet (rowState [rowToCheck], 4); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 4); aufrechtzuerhalten. Wenn (digitalRead (colF) ==LOW) { bitSet (rowState [rowToCheck], 5); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 5); aufrechtzuerhalten. Wenn (digitalRead (colG) ==LOW) { bitSet (rowState [rowToCheck], 6); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 6); aufrechtzuerhalten. Wenn (digitalRead (colH) ==LOW) { bitSet (rowState [rowToCheck], 7); aufrechtzuerhalten. Else { bitClear (rowState [rowToCheck], 7); } // setze alle Schieberegisterpins auf HIGH, dies hält die Werte vom "Bluten" zur nächsten Schleife updateShiftRegister (B11111111); rowToCheck =rowToCheck + 1; // zur nächsten Zeile iterieren // nach Prüfung der 8. Zeile die Zustände prüfen (Tasten drücken) und dann mit der 1. Zeile von vorne beginnen if (rowToCheck> 7 ) { checkPressedKeys(); rowToCheck =0; }}void checkPressedKeys () { // prüfen, ob eine der Umschalttasten gedrückt ist if (bitRead (rowState [5], 1) | bitRead (rowState [6], 4)) { shift =true; aufrechtzuerhalten. Sonst { shift =false; } // prüfen, ob eine der Strg-Tasten gedrückt ist if (bitRead(rowState[6], 5) | bitRead(rowState[7], 3)) { ctrl =true; aufrechtzuerhalten. Sonst { ctrl =false; } // prüfen, ob eine der spcl-Tasten gedrückt ist if (bitRead(rowState[6], 6) | bitRead(rowState[7], 2)) { spcl =true; aufrechtzuerhalten. Sonst { spcl =false; } // prüfen, ob eine der Alt-Tasten gedrückt ist if (bitRead(rowState[6], 7) | bitRead(rowState[7], 1)) { alt =true; aufrechtzuerhalten. Sonst { alt =falsch; } // prüfen, ob die FN-Taste gedrückt ist if (bitRead(rowState[7], 4)) {fn =true; aufrechtzuerhalten. Sonst { fn =falsch; } // überprüfen, ob Caps aktiv ist und Shift gedrückt ist if (shift ==true &&caps ==true) { capsShift =true; aufrechtzuerhalten. Sonst { capsShift =false; } for (int i =8; i>=0; i--) { // durch jede Zeile iterieren for (int j =7; j>=0; j--) { // durch jedes Bit in dieser Zeile iterieren bool newBit =bitRead(rowState[i], j); // den Zustand dieses Bits prüfen bool prevBit =bitRead(prevRowState[i], j); // Überprüfen Sie den vorherigen Zustand dieses Bits if ((newBit ==1) &&(prevBit ==0)) { // erlaubt nur das Drücken der Taste, wenn sich der Zustand auf true geändert hat int thisChar =(i * 8) + j; // berechnen, welche Position im char-Array ausgewählt werden soll if (capsShift ==true) { processKey(capsShiftKey[thisChar]); aufrechtzuerhalten. Sonst if (shift ==true) { processKey (shiftKey[thisChar]); aufrechtzuerhalten. Sonst if (ctrl ==true) { processKey (ctrlKey[thisChar]); aufrechtzuerhalten. Sonst if (alt ==true) { processKey (altKey[thisChar]); aufrechtzuerhalten. Sonst if (spcl ==true) { processKey (spclKey[thisChar]); aufrechtzuerhalten. Sonst if (fn ==true) { processKey (fnKey [thisChar]); aufrechtzuerhalten. Sonst if (caps ==true) { processKey (capsKey[thisChar]); } Else { processKey(key[thisChar]); } } if (newBit ==1) { bitSet (prevRowState[i], j); // Vorherigen Bitzustand auf true setzen, wenn eine Taste gedrückt wird} else { bitClear(prevRowState[i], j); // den vorherigen Bitzustand auf false setzen, wenn die Taste nicht gedrückt wird, damit sie erneut gedrückt werden kann } } }}void processKey(char ReceivedKey) { if (receivedKey ==7) { // Auf Sonderfunktionen auf die gleiche Weise prüfen as caps (neue "else if"-Anweisungen hinzufügen) caps =!caps; } sonst {Serial.print (receivedKey); // wenn char keiner speziellen Funktion entspricht, einfach dieses char ausgeben }}

Kundenspezifische Teile und Gehäuse

Schaltpläne