4X4-Matrixtastatur mit Bild-Mikrocontroller

Tastaturen sind weit verbreitete Eingabegeräte, die in verschiedenen Elektronik- und Embedded-Projekten verwendet werden. Sie werden verwendet, um Eingaben in Form von Zahlen und Alphabeten zu übernehmen und diese zur weiteren Verarbeitung in das System einzuspeisen. In diesem Tutorial werden wir eine 4x4-Matrixtastatur mit PIC16F877A verbinden.

Bevor wir in die Detaillogik gehen und lernen, wie man die Tastatur benutzt, müssen wir einige Dinge wissen.

Warum brauchen wir 4x4 Tastatur:

Normalerweise verwenden wir einen einzelnen E / A-Pin einer Mikrocontrollereinheit, um das digitale Signal wie einen Schaltereingang zu lesen. In einigen Anwendungen, in denen 9, 12, 16 Schlüssel für Eingabezwecke benötigt werden, werden beim Hinzufügen jedes Schlüssels zu einem Mikrocontroller-Port 16 E / A-Ports verwendet. Diese 16 E / A-Ports dienen nicht nur zum Lesen von E / A-Signalen, sondern können auch als Peripherieverbindungen verwendet werden. ADC-Unterstützungen, I2C- und SPI-Verbindungen werden auch von diesen E / A-Pins unterstützt. Da diese Pins mit den Switches / Keys verbunden sind, können wir sie nicht verwenden, sondern nur als E / A-Ports. Das macht überhaupt keinen Sinn. Wie kann man also die Anzahl der Pins reduzieren? Die Antwort lautet: Verwenden einer Hex-Tastatur oder einer Matrix-Tastatur. Wir können die Anzahl der Pins reduzieren, die 4x4-Matrixschlüssel zuordnen. Es werden 8 Pins verwendet, von denen 4 in Zeilen und 4 in Spalten verbunden sind, wodurch 8 Pins des Mikrocontrollers eingespart werden.

So funktioniert die 4x4-Matrix-Tastatur:

Im oberen Bild ist links ein Matrix-Tastaturmodul dargestellt. Rechts wird die interne Verbindung sowie die Portverbindung angezeigt. Wenn wir den Port sehen, gibt es 8 Pins, die ersten 4 von links nach rechts sind X1, X2, X3 und X4 sind die Zeilen und die letzten 4 von links nach rechts sind Y1, Y2, Y3, Y4 sind vier Spalten. Wenn wir 4 Zeilen oder die X-Seite als Ausgabe machen und sie logisch niedrig oder 0 machen und die 4 Spalten als Eingabe machen und die Tasten lesen, lesen wir den Schalter, wenn der Korrespondent Y 0 erhält.

Dasselbe passiert in der nxn- Matrix, wobei n die Zahl ist. Das können 3x3, 6x6 usw. sein.

Denken Sie jetzt nur, dass 1 gedrückt wird. Dann befindet sich die 1 in der X1-Zeile und der Y1-Spalte. Wenn X1 0 ist, ist Y1 0. Auf die gleiche Weise können wir jeden Schlüssel in der X1-Zeile erfassen, indem wir die Spalten Y1, Y2, Y3 und Y4 erfassen. Dies passiert bei jedem Schalter und wir werden die Position der Schalter in der Matrix lesen.

Jeder grüne Kreis ist der Schalter und beide sind auf die gleiche Weise miteinander verbunden.

In diesem Tutorial werden wir die Tastatur mit den folgenden Spezifikationen verbinden:

Wir werden interne Pull-up verwenden
Wir werden die Option zum Entprellen der Schlüssel hinzufügen

Wenn die Schalter nicht gedrückt werden, müssen Y1, Y2, Y3 und Y4 so hoch oder 1 eingestellt werden. Andernfalls können wir die logischen Änderungen beim Drücken des Schalters nicht erkennen. Wir konnten es jedoch nicht mit Codes oder Programmen schaffen, da diese Pins als Eingabe und nicht als Ausgabe verwendet werden. Wir werden also ein internes Betriebsregister im Mikrocontroller verwenden und diese Pins als schwachen Pull-up-fähigen Modus betreiben. Wenn Sie dies verwenden, gibt es einen logischen High-Enable-Modus, wenn er sich im Standardzustand befindet.

Wenn wir die Taste drücken, treten Spitzen oder Geräusche mit Schaltkontakten auf, und aufgrund dieses Mehrfachschalters tritt ein Druck auf, der nicht erwartet wird. Also werden wir zuerst das Drücken des Schalters erkennen, einige Millisekunden warten, erneut prüfen, ob der Schalter noch gedrückt ist oder nicht, und wenn der Schalter noch gedrückt wird, werden wir das Drücken des Schalters endgültig akzeptieren, andernfalls nicht. Dies wird als Entprellen der Schalter bezeichnet.

Wir werden dies alles in unseren Code implementieren und die Verbindung auf dem Steckbrett herstellen.

Überprüfen Sie auch, wie die 4x4-Tastatur mit anderen Mikrocontrollern verbunden wird:

Tastaturschnittstelle mit Arduino Uno
4x4 Matrix Keypad Schnittstelle mit 8051 Mikrocontroller
4x4-Tastaturschnittstelle mit ATmega32-Mikrocontroller
Raspberry Pi Digital Code Lock auf dem Steckbrett

Erforderliches Material:

Steckbrett
Pic-Kit 3 und Entwicklungsumgebung in Ihrem PC, dh MPLABX
Drähte und Stecker
Zeichen LCD 16x2
20 MHz Kristall
2 Stück 33pF Keramikscheibenkappe.
4,7k Widerstand
10k voreingestellt (variabler Widerstand)
4x4 Matrix Tastatur
Ein 5 V Adapter

Schaltplan:

Wir werden die Kristalle und den Widerstand in den zugehörigen Stiften verbinden. Außerdem werden wir das LCD im 4-Bit-Modus über PORTD anschließen. Wir haben die Hex-Tastatur oder die Matrix-Tastatur über den Port RB4 angeschlossen.

Wenn Sie PIC noch nicht kennen, beginnen Sie mit Erste Schritte mit PIC Microcontroller: Einführung in PIC und MPLABX

Programmiererklärung:

Der vollständige Code für die Verbindung der Matrix-Tastatur mit dem PIC-Mikrocontroller ist am Ende angegeben. Code ist einfach und selbsterklärend. Die Tastaturbibliothek ist nur im Code zu verstehen. Hier haben wir die Tastatur keypad.h und lcd.h verwendet, um die Tastatur und das 16x2-LCD miteinander zu verbinden. Mal sehen, was darin passiert.

In der keypad.h werden wir sehen, dass wir den xc.h- Header verwendet haben, der die Standardregisterbibliothek ist. Die Kristallfrequenz ist für die Verwendung der in der kepad.c- Datei verwendeten Verzögerung definiert. Wir haben die Tastaturanschlüsse im PORTRB- Register definiert und einzelne Pins als Zeile (X) und Spalte (Y) definiert.

Wir haben auch zwei Funktionen verwendet, eine für die Initialisierung der Tastatur, die den Port als Ausgabe und Eingabe umleitet, und einen Scan für das Drücken der Schalter, der beim Aufrufen den Status der Schalterpresse zurückgibt.

#einschließen #define _XTAL_FREQ 200000000 // Kristall Frequenz, in der Verzögerung verwendet #define X_1 RB0 #define X_2 RB1 #define x_3 RB2 #define X_4 RB3 #define Y_1 RB4 #define Y_2 RB5 #define Y_3 RB6 #define Y_4 RB7 #define Keypad_PORT PORTB #define Keypad_PORT_Direction TRISB void InitKeypad (void); char switch_press_scan (void);

In der Tastatur.c sehen wir, dass die folgende Funktion den Tastendruck zurückgibt, wenn die Tastaturscanner-Funktion nicht 'n' zurückgibt.

char switch_press_scan (void) // Schlüssel vom Benutzer abrufen { char key = 'n'; // Angenommen, während (key == 'n') keine Taste gedrückt wurde // Warten Sie, bis eine Taste gedrückt wird key = keypad_scanner (); // Scanne die Schlüssel immer wieder return key; // Wenn die Taste gedrückt wird, wird der Wert zurückgegeben. }

Unten finden Sie die Lesefunktion der Tastatur. In jedem Schritt machen wir die Zeilen X1, X2, X3 und X4 zu 0 und lesen den Status Y1, Y2, Y3 und Y4. Die Verzögerung wird für den Entprellungseffekt verwendet. Wenn der Schalter noch gedrückt wird, wird der damit verbundene Wert zurückgegeben. Wenn kein Schalter gedrückt wird, geben wir 'n' zurück.

char keypad_scanner (void) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); return '1'; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '2'; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); return '3'; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); return 'A'; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); return '4'; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '5'; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); return '6'; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); return 'B'; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); return '7'; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '8'; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); return '9'; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); return 'C'; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); Rückkehr '*'; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '0'; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); Rückkehr '#'; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); return 'D'; } return 'n'; }}

Wir werden auch den schwachen Pull-up für die letzten vier Bits einstellen und auch die Richtung der Ports als letzte 4 Eingänge und erste 4 als Ausgang einstellen . Das OPTION_REG & = 0x7F; wird verwendet, um den schwachen Pull-up-Modus an den letzten Pins einzustellen.

void InitKeypad (void) { Keypad_PORT = 0x00; // Setzen Sie die Pin-Werte des Tastaturports auf Null. Keypad_PORT_Direction = 0xF0; // Eingabe der letzten 4 Pins, Ausgabe der ersten 4 Pins OPTION_REG & = 0x7F; }}

Im Haupt-PIC-Programm (siehe unten) haben wir zuerst die Konfigurationsbits gesetzt und einige benötigte Bibliotheken aufgenommen. Dann initialisieren wir in void system_init Funktionen die Tastatur und das LCD. Und schließlich haben wir in der Hauptfunktion die Tastatur gelesen, indem wir die Funktion switch_press_scan () aufgerufen und den Wert an lcd zurückgegeben haben.

Laden Sie hier den vollständigen Code mit den Header-Dateien herunter und sehen Sie sich das Demonstrationsvideo unten an.