Ich möchte euch heute mein Keypad mit 16 Tasten vorstellen, das mit einem Arduino zusammen arbeitet. Natürlich können auch andere Microcontroller oder Entwicklungsboards verwendet werden, denn die Ansteuerung und das Auslesen basiert auf den gleichen Ablauf.Zum Auslesen und Ansteuern werden nur 6 Anschlüsse des Arduino's verwendet und 2 weitere für die Stromversorgung des Keypads. Zur Vereinfachung habe ich mir eine Library, speziell für den Arduino, geschrieben. Somit kann man mit nur wenig Quellcode das Keypad auslesen.

Ich werde die Funktionsweise, Aufbau der Platine, und die Programmierung des Arduino's erläutern.

Step 1: Funktionsweise Erläutern

Zunächst beschäftigen wir uns mit den 16 Tasten auf der rechten Seite des Schaltplanes.

Die Tastatur ist recht simple aufgebaut und funktioniert wie eine Matrix bzw. Koordinatensystem.
Jede Taste ist mit einer Spalten und Zeile verbunden. Um nun eine Taste zu ermitteln benötigen wird lediglich die
x-Koordinate (Spalte) und y-Koordinate (Zeile).

Beispiel:
S10 (Switch10) - Spalte 2 und Zeile 3

Wir wissen jetzt wie wir eine Taste ermitteln können und müssen nun einen Algorithmus entwerfen.

Die Anschlüssen bzw. Ausgänge des Keypads- Spalte 1; 2; 3; 4 unten rechts im Schaltbild- werden an dem Arduino angeschlossen. Nun könnte man einfach an jeder Zeile Spannung anlegen. Wenn nun aus einer der 4 Ausgänge Spannung entnommen wird, wird eine Taste gedrückt. Man weiß nun aus welcher Spalte eine Taste gedrückt wurde aber nicht in welcher Zeile, doch wir brauchen auch die Zeile für die Ermittlung des Tasters.

Um dieses Problem zu lösen, werden die Zeilen von der Spannung gelöst und direkt am Arduino angeschlossen. Jede Zeile bekommt einen eigenen Ausgang vom Arduino.
Der Ardunio soll jede Zeile kurz mit Spannung versorgen und die Spalten bei jeder einzelne Zeile auf ein Signal überprüfen. Durch diesen Ablauf können wir den Taster bestimmen, da wir wissen bei welcher Zeile Spannung anliegt und bei welcher Spalte ein Signal empfangen wurde.

>>Signal=5V oder 0V

Dieser Ablauf wird in einen PAP Model noch einmal Dargestellt.

Wir benötigen bis jetzt 8 Anschlüsse des Arduinos um eine Taste zu ermitteln. Um weitere Anschlüsse einzusparen, wird die Ansteuerung der 4 Zeilen komprimiert. Mithilfe des Binärsystems ist dies möglich.
Im Binärsystem kann man mit nur 2 Stellen vier verschiedene Zahlen darstellen, sprich 00 01 10 11 = 0 1 2 3.
Diese 4 verschiedene Zahlen werden uns bei der Ansteuerung der 4 Zeilen behilflich sein. Im Schaltbild auf der linken Seite sehen wir eine Logikschaltung, die dieses tut.

Logikschaltung!

Wir sehen im Schaltbild, 2 Invertierer und 4 AND-Gatter. Jede Zeile wird einen Ausgang der 4 AND-Gatter zugeordnet und verbunden.

Wie funktioniert ein AND-Gatter?
Ein AND-Gatter hat immer mindestens 2 Eingänge und 1 Ausgang. Damit der Ausgang auf 5V schaltet, müssen alle Eingänge auf 5V geschaltet werden.

Wertetabelle:
Eingang 2 --- Eingang 1 --- Ausgang
-----0-----------------1----------------0------

-----1-----------------0----------------0------

-----1-----------------1----------------1------

----------------0= 0V -- 1= 5V--------------

Wie funktioniert ein Invertiere?
Ein Invertiere ist sozusagen eine Schaltung, die immer das Gegenteil vom Eingang ausgibt.

Wertetabelle:
Eingang 1 --- Ausgang
----0----------------1------
----1----------------0------
-----0= 0V -- 1= 5V------

Wenn wir jetzt die Zeile 1 mit Spannung versorgen möchten, dann muss am Eingang A und Eingang B 0V angelegt werden. Da die Eingänge vom 1. AND-Gatter invertiert werden, schaltet der Ausgang auf 5V.
Beim 2.AND-Gatter liegt bei dem 1.Eingang 0V an und beim 2.Eingang 5V, da dieser invertiert wird. Beim Ausgang liegen also 0V an. Dies ist bei den anderen beiden AND-Gatter auch der Fall, somit wird nur die 1.Zeile mit Spannung versorgt.

Wir haben es geschafft und benötigen lediglich nur noch 6 Anschlüsse des Arduinos.
Am Eingang A und B wird das Binärsystem abgespielt, das bis zur Dezimalzahl 3 zählt und nach 3 wieder bei 0 startet.

Die 4 Widerstände im unteren Bereich des Schalplanes, dienen dazu das der Eingang des Ardunios stätig definiert ist. Denn wenn keine Taste gedrückt wird, weiß der Arduino nicht ob eine Spannung anliegt oder nicht. Es treten somit ungewollte Fehler auf. Die Widerstände sollten auf jeden Fall im Kilobereich liegen, da die Eingänge maximal 40mA vertragen und auch der Stromverbrauch wird kleiner.

Step 2: Aufbau Der Platine

Für das Keypad werden folgende Bauelemente benötigt:

1 Streifenplatine (100x160)
16 Taster 4 Widerstände (>4,7k)
2 CD4073 (3x AND-Gatter)
1 74HCT04 (6x Invertiere)
Stiftleiste (90 Grad gekrümmt Optimal)
Silberdraht 0,3mm²

Arduino Uno/Nano (oder andere Microcontroller/ Entwicklungsboards)

Meine Tastatur wurde wie ein Zahlenfeld angeordnet mit Zusatzbuttons am Rand. Oben links findet ihr den Anschluss für den Arduino und der Betriebsspannung, die bei 5V liegt. Über dem Tastenfeld sind 3 Fassungen für die Chips und 4 Pulldown-Widerstände platziert. Die Verbindung zum Arduino wird mit einer Buchsenleiste realisiert.

Ihr könnt aber eure Tastatur anordnen wie ihr möchtet. Es gibt auch fertige Keypads für den Arduino nur nicht mit der Besonderheit, der 4 AND-Gatter um 2 weitere Anschlüsse einzusparen. Diese kann man aber ganz einfach dazu schalten.

Step 3: Programmierung Des Arduino

Die Programmierung gestalltet sich nach dem PAP Model,was beim 1.Schrittgezeigt wurde, einfach.

for(int i=0; i<=3;i++)

boolean eingang_a=bitRead(i,0); //Die bits der Zahl i werden der Stelle 0 und 1 ausgelesen und in
boolean eingang_b=bitRead(i,1); //Variablen initialisiert

digitalWrite(2,eingang_a); //Die Ausgänge werden auf HIGH oder LOW gesetzt
digitalWrite(3,eingang_b); //Dadurch wird jede Zeile einmal mit Spannung versorgt

//Spalte 1

//Wenn die 1.Zeile mit Spannung versorgt wird und von der 1.Spalte Spannung entnommen wird, ist der Rückgabewert 1 von Typ String
if(eingang_a== 0 && eingang_b== 0 && digitalRead(spalte_1)==HIGH){
return "1"; }

//Wenn die 2.Zeile mit Spannung versorgt wird und von der 1.Spalte
Spannung entnommen wird, ist der Rückgabewert 4
else if(eingang_a== 1 && eingang_b== 0 && digitalRead(spalte_1)==HIGH){
return "4"; }

//Wenn die 3.Zeile mit Spannung versorgt wird und von der 1.Spalte
Spannung entnommen wird, ist der Rückgabewert 7
else if(eingang_a== 0 && eingang_b== 1 && digitalRead(spalte_1)==HIGH){
return "7"; }

//Wenn die 4.Zeile mit Spannung versorgt wird und von der 1.Spalte
Spannung entnommen wird, ist der Rückgabewert Sonderzeichen
else if(eingang_a== 1 && eingang_b== 1 && digitalRead(spalte_1)==HIGH){
return "Sonderzeichen"; }

Dieses Verfahren wird bei den restlichen Zeilen und Spalten auch Durchgeführt. Es wird nur die Spalte zur Auslesung verändert, bei der If-Verzweigung >>digitalRead(spalte_x)<<.

Lkeypad.h Library

Damit man nicht jedes Mal 100 Zeilen Code schreiben muss um die Tastatur zu verwenden, schrieb ich eine eigene Library. In dieser Library ist der gleiche Alogirthmus zu finden. Wie man diese verwendet und mit einbindet, wird im oberen Bild beschrieben.