Arduino mit einem Keypad betreiben
Ein Kleincomputer wird sinnvoll erweitert
Um Daten in den Arduino einzugeben, bietet sich ein Keypad an. Doch ist dessen Betrieb sowie der Anschluss an diesen Kleincomputer nicht ohne Weiteres zu verstehen. Hier hilft unser Ratgeber weiter.
Ein Keypad ist immer dann nötig, wenn man am Arduino beispielsweise einen Code eingeben, die Uhrzeit einstellen oder einen Aktionswert eintippen möchte. Eingabe-Peripherie, wie sie Keypads sind, erweitern die Möglichkeiten eines Kleincomputers, sodass deren Betrieb eigentlich ein Muss darstellt.
Um die Funktion eines Keypads zu verstehen, bietet es sich an, deren Funktion vor dem Einbau zu ergründen. Dies ist insbesondere deswegen sinnvoll, da die Anschlussbelegung des angebrachten Steckers nicht so ohne weiteres ersichtlich ist. Mit einem Multimeter mit der Funktion Durchgangsprüfung lassen sich diesbezüglich offene Fragen rasch klären.
Dazu ist zunächst das Multimeter auf die schon erwähnte Funktion Durchgangsprüfung einzustellen. Bei Bedarf ist in der jeweiligen Bedienungsanleitung nachsehen, wie diese Funktion aktiviert wird.
Solange sich die Messspitzen nicht berühren, wird ein entsprechendes Bild angezeigt, das wie folgt aussehen kann:
Sobald die Messpitzen sich berühren, ertönt ein Piepton und in der Anzeige wird ein Wert angezeigt, der unter 300 Ohm liegt. Auf diese Weise können auch Personen den Stromdurchgang erkennen, deren Gehör den Piepton nicht mehr registriert.
Nun kann das Keypad über eine zweckmäßige Vorrichtung dahingehend erkundet werden, auf welche Weise die Tasten verschaltet sind. Dazu ist jede Taste zu betätigen und darauf zu achten, ob ein Durchgangssignal am Multimeter ausgegeben wird.
Nachfolgendes Bild zeigt, wie das Schema der Verdrahtung eines Keypad aussieht und welche Kombinationen der Prüfeingänge am Stecker eine Verbindung besitzen.
Keypads sind unter Umständen nachlässig produziert worden und liefern kein sauberes 1/0-Signal. Manchmal kommt es vor, dass zwar ein Tastendruck erkannt wird, jedoch nach Loslassen der Taste nicht sofort ein sauberes 0-Signal zum Arduino kommt. Dieser Effekt ist ohne Hilfsmittel nicht zu erkennen, was oft eine langwierige, frustrierende Fehlersuche zum Resultat hat.
Die Prüfung, ob ein Keypad korrekt arbeitet, kann wie oben bereits beschrieben mit einem Multimeter vorgenommen werden. Wenn per Durchgangsprüfung festgestellt wird, dass auch beim Drücken einer benachbarten Taste ein schwaches Durchgangssignal ausgegeben wird, so kann davon ausgegangen werden, dass entweder das Keypad defekt ist oder aber die Verdrahtung zwischen Keypad und Arduino nicht sauber ausgeführt wurde. Daher ist darauf zu achten, beim Versuchsaufbau akkurat zu arbeiten.
Zudem sei vor dem Versuch gewarnt, ein Keypad vollständig mit einem selbst programmierten Sketch zum Laufen zu bringen, da hier, anders als bei einem Betrieb mit einer mechanischen Tasterlösung rätselhafte Fehler, wie etwa nur zögerliches Rückschalten von einem High in einen Low-Pegel zu beobachten sind. Im Internet ist davon die Rede, dass daran beispielsweise elektrostatische Entladungen schuld seien.
Wie dem auch sei. Jedenfalls sind diese Probleme auf einen Schlag getilgt, wenn zum Ansteuern eines Keypads auf die Bibliothek Keypad.h zurückgegriffen wird. Die Entwickler haben hier wohl einen Weg gefunden, einen sicheren Betrieb eines Keypads in jedem Fall sicherzustellen.
Das Nutzen von Bibliotheken ist nicht nur nervenschonend, sondern zudem mit allerlei Annehmlichkeiten gepflastert. So kann beispielsweise die LCD-Anzeige problemlos an den Analogeingängen betrieben werden, ohne dass diese zwingend im Sketch als digitale Ein- oder Ausgänge deklariert werden müssen. Es genügt, die Anschlüsse der LCD-Anzeige in beliebige freie Pins einzustecken und diese im Sketch mit dem Befehl LiquidCrystal lcd() zu initialisieren, beispielsweise so: LiquidCrystal lcd(A5, A4, A3, A2, A1, A0).
In dieser Reihenfolge sind die Anschlüsse RS, E, D4, D5, D6 und D7 des LCD-Displays an den Analogeingängen des Arduinos angeschlossen. Einzig der Anschluss D15 des LCD-Display verbleibt am Digital-Pin D9, da an diesem ein PWM-Signal für die Hintergrundbeleuchtung der LCD-Anzeige ausgegeben werden kann.
Nach der erfolgten Nutzung der Analoganschlüsse für die LCD-Anzeige ist nun Platz, um das Keypad an den Digitaleingängen anzuschließen. Außer bei den digitalen Pins 0 und 1 darf es innerhalb der digitalen Pins 2 bis 13 frei angeschlossen werden. Wichtig ist nur, dass danach im Sketch diejenigen Pins benannt werden, die für das Keypad genutzt werden.
Hier ein Vorschlag:
Folgender Sketch ermöglicht die Überprüfung des Keypads auf korrekte Funktion:
/**************************************************************
Testprogramm zur Ansteuerung eines 16x2 LCD-Displays sowie eines Keypads
Besonderheit: Die Analogeingänge werden zu Digitaleingängen umprogrammiert und genutzt,
um Platz für den Anschluss des Keypads zu bekommen
Nötige Bibliotheken: LiquidCrystal.h und Keypad.h
**************************************************************/
// LCD Library einbinden
#include <LiquidCrystal.h>
#include <Keypad.h>
// LCD Pins festlegen
// Anschlüsse: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(A5, A4, A3, A2, A1, A0);
// Variablendeeklaration
int Zeichen; // Einzelnes Zeichen des Keypads
//Definieren der Zeilen und Spalten
const byte COLS = 3; //Spalten
const byte ROWS = 4; //Zeilen
//Definieren der Pins, über welche das Keypad mit dem Microcontroller verbunden wurde.
byte COL_PINS[COLS] = { 2, 3, 4 }; //Spalten=Keypad-Pin 1=D2, 2=D3, 3=D4
byte ROW_PINS[ROWS] = { 5, 6, 7, 8 }; //Zeilen=Keypad-Pin 4=D5, 5=D6, 6=D7, 7=D8
//Aufbau der Tastatur als mehrdimensionales Array abbilden.
//Es ist darauf zu achten das die Tastatur gedreht abgebildet ist.
const char KEYS[ROWS][COLS]={
{'#','0','*'},
{'9','8','7'},
{'6','5','4'},
{'3','2','1'}
};
// keypad initialisieren
Keypad (keypad) = Keypad(makeKeymap(KEYS), ROW_PINS, COL_PINS, ROWS, COLS);
void setup()
{
// PWM-Signal für LED Hintergrundbeleuchtung
analogWrite(9, 150);
// LCD Ausgabe
lcd.begin(16, 2);
lcd.setCursor(3, 0);
lcd.print("Hallo Welt!");
lcd.setCursor(0, 1);
lcd.print("CNT:");
}
void loop()
{
//Lesen, ob eine Taste gedrückt wurde
char key = keypad.getKey();
if (key == '1')
{
lcd.setCursor(11, 1);
lcd.print("1");
}
if (key == '2')
{
lcd.setCursor(11, 1);
lcd.print("2");
}
if (key == '3')
{
lcd.setCursor(11, 1);
lcd.print("3");
}
if (key == '4')
{
lcd.setCursor(11, 1);
lcd.print("4");
}
if (key == '5')
{
lcd.setCursor(11, 1);
lcd.print("5");
}
if (key == '6')
{
lcd.setCursor(11, 1);
lcd.print("6");
}
if (key == '7')
{
lcd.setCursor(11, 1);
lcd.print("7");
}
if (key == '8')
{
lcd.setCursor(11, 1);
lcd.print("8");
}
if (key == '9')
{
lcd.setCursor(11, 1);
lcd.print("9");
}
if (key == '*')
{
lcd.setCursor(11, 1);
lcd.print("*");
}
if (key == '0')
{
lcd.setCursor(11, 1);
lcd.print("0");
}
if (key == '#')
{
lcd.setCursor(11, 1);
lcd.print(" "); // Anzeige an Cursorposition löschen
}
lcd.setCursor(5, 1);
lcd.print(millis() / 1000);
}
Dieses Programm funktioniert einwandfrei, wie die Zeichen auf der LCD-Anzeige zeigen, die an Cursorposition 11,1 nach der Betätigung einer Taste erscheinen.
