Tastenfeld (Keypad) verwenden: 4x4-Codeschloss mit Arduino

Ein Keypad (Tastenfeld) ist ein günstiges Eingabegerät, ähnlich den Tasten eines Telefons, mit dem du Zahlen oder Buchstaben in dein Projekt eingibst. Codeschlösser für Türen, Tresore, Taschenrechner, Alarmpanels und Menüsysteme entstehen mit Keypads. Am verbreitetsten sind dünne Folientastaturen mit Klebeseite im Format 4x4 (16 Tasten) und 3x4 (12 Tasten).

Wie funktioniert ein Keypad? Die Zeilen-Spalten-Matrix

Hätte jede der 16 Tasten einen eigenen Pin, bräuchtest du 16 Pins. Ein Keypad ordnet die Tasten stattdessen als Matrix an: 4 Zeilen und 4 Spalten, jede Taste sitzt an einem Kreuzungspunkt und verbindet beim Drücken diese Zeile mit dieser Spalte. Der Arduino setzt die Zeilen nacheinander auf LOW und liest die Spalten; welche Spalte LOW ist, während eine bestimmte Zeile LOW ist, verrät die gedrückte Taste. Weil diese Abfrage hunderte Male pro Sekunde läuft, reichen 8 Pins für 16 Tasten.

Pinbelegung und Anschluss des Keypads

Mit den Tasten zu dir sind die Pins des Flachbandkabels von links nach rechts meist R1, R2, R3, R4, C1, C2, C3, C4: die ersten vier Zeilen, die letzten vier Spalten. Zusätzliche Widerstände sind nicht nötig; die Bibliothek nutzt für die Spalten die internen Pull-up-Widerstände des Arduino.

Tasten mit der Bibliothek Keypad lesen

Suche im Bibliotheksverwalter nach Keypad und installiere die Bibliothek von Mark Stanley und Alexander Brevig. Der folgende Code gibt jede gedrückte Taste im seriellen Monitor aus:

1#include <Keypad.h>
2
3const byte ROWS = 4, COLS = 4;
4char keys[ROWS][COLS] = {
5  {'1', '2', '3', 'A'},
6  {'4', '5', '6', 'B'},
7  {'7', '8', '9', 'C'},
8  {'*', '0', '#', 'D'}
9};
10byte rowPins[ROWS] = {9, 8, 7, 6};     // R1–R4
11byte colPins[COLS] = {5, 4, 3, 2};     // C1–C4
12Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
13
14void setup() {
15  Serial.begin(9600);
16}
17
18void loop() {
19  char key = keypad.getKey();          // tuş yoksa 0 döner / returns 0 if no key
20  if (key) {
21    Serial.println(key);
22  }
23}

getKey() blockiert dein Programm nicht: Ist gerade keine Taste gedrückt, gibt es sofort 0 zurück, sodass du in loop() weitere Aufgaben erledigen kannst. Die Bibliothek entprellt die Tasten selbst und meldet jeden Druck nur einmal. Willst du warten, bis eine Taste gedrückt wird, nutze waitForKey().

Ein Codeschloss bauen

Jetzt sammeln wir die gedrückten Tasten in einem Text und vergleichen sie mit einem gespeicherten Code. Die Taste * löscht die Eingabe, # bestätigt sie. Stimmt der Code, öffnet ein Servomotor das Schloss für 3 Sekunden. Zum Servoanschluss siehe Was ist ein Servomotor?

1#include <Keypad.h>
2#include <Servo.h>
3
4const byte ROWS = 4, COLS = 4;
5char keys[ROWS][COLS] = {
6  {'1', '2', '3', 'A'},
7  {'4', '5', '6', 'B'},
8  {'7', '8', '9', 'C'},
9  {'*', '0', '#', 'D'}
10};
11byte rowPins[ROWS] = {9, 8, 7, 6};
12byte colPins[COLS] = {5, 4, 3, 2};
13Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
14
15Servo lock;
16const String PASSWORD = "1234";
17String input = "";
18
19void setup() {
20  Serial.begin(9600);
21  lock.attach(10);
22  lock.write(0);                        // kilitli / locked
23}
24
25void loop() {
26  char key = keypad.getKey();
27  if (!key) return;
28  if (key == '*') {                     // temizle / clear
29    input = "";
30  } else if (key == '#') {              // onayla / confirm
31    if (input == PASSWORD) {
32      Serial.println("Doğru, açılıyor / correct, opening");
33      lock.write(90);
34      delay(3000);
35      lock.write(0);
36    } else {
37      Serial.println("Yanlış şifre / wrong code");
38    }
39    input = "";
40  } else if (input.length() < 8) {
41    input += key;
42    Serial.print('*');                  // tuşu gizle / hide the key
43  }
44}

Zusammen mit einem LCD verwenden

Ein Display macht die Codeeingabe viel übersichtlicher. Ein I2C-LCD belegt nur A4 und A5 und kommt den 8 Digitalpins des Keypads nicht in die Quere. Bei jedem Tastendruck schreibst du einen Stern in die untere Zeile und zeigst nach dem Bestätigen oben "Offen" oder "Falsch" an. Anschluss und Befehle des Displays erklärt I2C-LCD-Display verwenden.

Weniger Pins: I2C- und Analog-Keypads

Ein Keypad belegt allein 8 der 20 Pins des Uno. Reichen die Pins nicht, gibt es zwei Lösungen: Ein I2C-Keypad-Adapter mit PCF8574 reduziert das Tastenfeld auf zwei Leitungen und teilt sich den Bus mit dem LCD. Bei Analog-Keypads erzeugt jede Taste einen anderen Widerstand, und das ganze Tastenfeld wird über einen einzigen Analogpin gelesen; das spart Kabel, erkennt aber keine zwei gleichzeitig gedrückten Tasten.

Keypad mit ESP32 und Raspberry Pi Pico

Die Bibliothek Keypad läuft auch auf dem ESP32. Da die Zeilenpins als Ausgänge und die Spaltenpins als Eingänge mit Pull-up dienen, meide GPIO 34–39, die nichts ausgeben können und keine Pull-ups haben; nimm etwa 13, 12, 14 und 27 für die Zeilen und 26, 25, 33 und 32 für die Spalten. Am Pico schreibst du die Abfrage mit MicroPython in wenigen Zeilen selbst:

1from machine import Pin
2import time
3
4KEYS = ["123A", "456B", "789C", "*0#D"]
5rows = [Pin(n, Pin.OUT, value=1) for n in (2, 3, 4, 5)]        # R1–R4
6cols = [Pin(n, Pin.IN, Pin.PULL_UP) for n in (6, 7, 8, 9)]     # C1–C4
7
8def scan():
9    for r, row in enumerate(rows):
10        row.value(0)                         # bu satırı etkinleştir / activate this row
11        for c, col in enumerate(cols):
12            if col.value() == 0:             # tuş basılı / key pressed
13                row.value(1)
14                return KEYS[r][c]
15        row.value(1)
16    return None
17
18last = None
19while True:
20    key = scan()
21    if key and key != last:                  # her basışı bir kez yaz / print each press once
22        print(key)
23    last = key
24    time.sleep_ms(50)

Projektideen mit dem Keypad

• Codetresor: eine Box, die sich nach Codeeingabe öffnet – mit Servomotor, LCD und Buzzer.
• Taschenrechner: die Tasten A–D als Grundrechenarten nutzen und das Ergebnis auf einem LCD zeigen.
• Farbwähler: die Farbe einer RGB-LED je nach eingegebener Zahl ändern.
• Alarmpanel: eine Alarmanlage mit PIR-Sensor per Code scharf und unscharf schalten.
• Zahlenratespiel: die Zahl des Arduino mit den Hinweisen "größer" und "kleiner" erraten.
• Shortcut-Tastatur: mit einem Arduino Leonardo jede Taste zu einem Tastenkürzel am Computer machen.

Typische Fehler und ihre Lösungen

• Eine andere Taste als die gedrückte wird gelesen: Zeilen und Spalten sind vertauscht; dreh die Reihenfolge der Arrays rowPins und colPins um.
• Gar keine Taste wird gelesen: Das Flachbandkabel steckt um einen Pin versetzt oder die Zeilen- und Spaltenpins weichen vom Code ab.
• Einige Tasten funktionieren nie: Ein Zeilen- oder Spaltenkabel hat Wackelkontakt; fallen alle Tasten einer Zeile oder Spalte aus, ist das das Zeichen.
• Pins 0 und 1 verwenden: Diese Pins dienen der seriellen USB-Kommunikation; mit angeschlossenem Keypad kann das Hochladen fehlschlagen.
• Am ESP32 wirken manche Spalten dauernd gedrückt: Es werden GPIO 34–39 ohne Pull-up genutzt; weich auf andere Pins aus.
• Wiederholung bei langem Drücken erwartet: getKey() meldet jeden Druck einmal; um gehaltene Tasten zu erkennen, nutze den HOLD-Zustand der Bibliothek.

Ein Keypad besteht im Grunde aus Tastern in Matrixanordnung; das Prinzip der Taster findest du in Taster an den Arduino anschließen. In der BlueGrays-App findest du Projekte zu 3x4- und 4x4-Keypads, eine Code-App mit LCD, einen intelligenten elektronischen Tresor, einen I2C-Taschenrechner und die Steuerung einer RGB-LED per Keypad mit Schaltplänen und Code.