- Erforderliche Materialien
- 16X2 LCD-Anzeigemodul
- Schaltplan und Anschlüsse
- Programmieren von ARM7-LPC2148
Die Anzeige ist der notwendige Teil einer Maschine, unabhängig davon, ob es sich um ein Haushaltsgerät oder eine Industriemaschine handelt. Das Display zeigt nicht nur die Steuerungsoptionen für den Betrieb der Maschine an, sondern auch den Status und die Ausgabe der von dieser Maschine ausgeführten Aufgabe. Es gibt viele Arten von Displays, die in der Elektronik verwendet werden, wie 7-Segment-Displays, LCD-Displays, TFT-Touchscreen-Displays, LED-Displays usw. Das 16x2-LCD-Display ist das grundlegendste und wird auch in einigen kleinen elektronischen Geräten verwendet. Wir haben viel getan Projekte mit 16x2 LCD einschließlich der grundlegenden Schnittstelle zu anderen Mikrocontrollern:
- LCD-Schnittstelle mit 8051-Mikrocontroller
- Schnittstelle zwischen LCD und ATmega32-Mikrocontroller
- LCD-Schnittstelle mit PIC-Mikrocontroller
- 16x2 LCD mit Arduino verbinden
- 16x2 LCD-Schnittstelle mit Raspberry Pi mit Python
In diesem Tutorial erfahren Sie, wie Sie ein 16x2-LCD mit dem ARM7-LPC2148-Mikrocontroller verbinden und eine einfache Begrüßungsnachricht anzeigen. Wenn Sie mit ARM7 noch nicht vertraut sind, beginnen Sie mit den Grundlagen von ARM7 LPC2148 und erfahren Sie, wie es mit Keil uVision programmiert werden kann
Erforderliche Materialien
Hardware
- ARM7-LPC2148 Mikrocontroller-Karte
- LCD (16X2)
- Potentiometer
- 5V Spannungsregler IC
- Steckbrett
- Kabel anschließen
- 9V Batterie
- Micro-USB-Kabel
Software
- Keil uVision 5
- Magic Flash Tool
Bevor wir mit dem Projekt beginnen, müssen wir einige Dinge über die LCD-Betriebsmodi und die LCD-Hex-Codes wissen.
16X2 LCD-Anzeigemodul
Ein 16X2-LCD gibt an, 16 Spalten und 2 Zeilen zu haben. Dieses LCD hat 16 Pins. Das folgende Bild und die Tabelle zeigen die Pin-Namen des LCD-Displays und seine Funktionen.
|
NAME |
FUNKTION |
|
VSS |
Erdungsstift |
|
VDD |
+ 5V Eingangspin |
|
VEE |
Kontrastanpassungsstift |
|
RS |
Registrieren Wählen Sie |
|
R / W. |
Lese- / Schreibstift |
|
E. |
Pin aktivieren |
|
D0-D7 |
Datenstifte (8 Stifte) |
|
LED A. |
Anodenstift (+ 5V) |
|
LED K. |
Kathodenstift (GND) |
Das LCD kann in zwei verschiedenen Modi arbeiten, nämlich im 4-Bit-Modus und im 8-Bit-Modus. Im 4-Bit-Modus senden wir die Daten Nibble für Nibble, zuerst Upper Nibble und dann Lower Nibble. Für diejenigen unter Ihnen, die nicht wissen, was ein Halbbyte ist: Ein Halbbyte ist eine Gruppe von vier Bits, sodass die unteren vier Bits (D0-D3) eines Bytes das untere Halbbyte bilden, während die oberen vier Bits (D4-D7) eines Bytes bilden das höhere Halbbyte. Dies ermöglicht es uns, 8-Bit-Daten zu senden.
Während wir im 8-Bit-Modus die 8-Bit-Daten direkt in einem Strich senden können, verwenden wir alle 8 Datenleitungen.
Hier in diesem Projekt verwenden wir den am häufigsten verwendeten Modus, den 4-Bit-Modus. Im Vier-Bit-Modus können wir 4 Pins Mikrocontroller sparen und auch den Verdrahtungsaufwand reduzieren.
16x2 verwendet auch HEX-Code, um einen beliebigen Befehl zu übernehmen. Es gibt viele Hex-Befehle für LCD, mit denen Sie den Cursor bewegen, den Modus auswählen, den Regler in die zweite Zeile verschieben usw. Um mehr über das 16X2 LCD-Anzeigemodul und Hex-Befehle zu erfahren, folgen Sie dem Link.
Schaltplan und Anschlüsse
Die folgende Tabelle zeigt die Schaltungsverbindungen zwischen LCD und ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Register Select) |
|
P0.6 |
E (Aktivieren) |
|
P0.12 |
D4 (Datenstift 4) |
|
P0.13 |
D5 (Datenstift 5) |
|
P0.14 |
D6 (Datenstift 6) |
|
P0.15 |
D7 (Datenstift 7) |
Anschlüsse des Spannungsreglers mit LCD & ARM7 Stick
Die folgende Tabelle zeigt die Verbindungen zwischen ARM7 und LCD mit Spannungsregler.
|
Spannungsregler-IC |
Pin-Funktion |
LCD & ARM-7 LPC2148 |
|
1. Linker Stift |
+ Ve von Batterie 9V Eingang |
NC |
|
2.Centre Pin |
- Ve von der Batterie |
VSS, R / W, K des LCD GND von ARM7 |
|
3.Rechter Stift |
Geregelter + 5V Ausgang |
VDD, A von LCD + 5V von ARM7 |
Potentiometer mit LCD
Ein Potentiometer wird verwendet, um den Kontrast der LCD-Anzeige zu variieren. Ein Topf hat drei Stifte, der linke Stift (1) ist mit +5 V und die Mitte (2) mit VEE oder V0 des LCD-Moduls verbunden, und der rechte Stift (3) ist mit GND verbunden. Wir können den Kontrast einstellen, indem wir den Knopf drehen.
Jumper-Einstellungen
Im ARM7-Stick befindet sich ein Überbrückungsstift, mit dem wir Code über USB oder über einen 5-V-Gleichstromeingang nur zur Stromversorgung mit Strom versorgen und hochladen können. Sie können die folgenden Bilder sehen.
Das folgende Bild zeigt, dass sich der Jumper in der DC-Position befindet. Das heißt, wir müssen die Platine über eine externe 5-V-Versorgung mit Strom versorgen.
Und dieses Bild zeigt, dass der Jumper im USB-Modus angeschlossen ist. Hier werden Strom und Code über den Micro-USB-Port bereitgestellt.
HINWEIS: Hier in diesem Tutorial haben wir Code mithilfe von USB hochgeladen, indem wir den Jumper auf USB gesetzt und dann den Jumper in den DC-Modus geändert haben, um LPC2148 über den 5-V-Eingang des Reglers mit Strom zu versorgen. Sie können dies in dem Video am Ende überprüfen.
Die letzte Schaltung für die Verbindung von 16x2-LCD mit ARM7-Mikrocontroller sieht folgendermaßen aus:
Programmieren von ARM7-LPC2148
Um ARM7-LPC2148 zu programmieren, benötigen wir das keil uVision & Flash Magic Tool. Wir verwenden ein USB-Kabel, um den ARM7 Stick über einen Micro-USB-Anschluss zu programmieren. Wir schreiben Code mit Keil und erstellen eine Hex-Datei. Anschließend wird die HEX-Datei mit Flash Magic auf den ARM7-Stick geflasht. Um mehr über die Installation von keil uVision und Flash Magic und deren Verwendung zu erfahren, folgen Sie dem Link Erste Schritte mit dem ARM7 LPC2148-Mikrocontroller und programmieren Sie ihn mit Keil uVision.
Der vollständige Code für die Verbindung von LCD mit ARM 7 finden Sie am Ende dieses Tutorials. Hier werden einige Teile davon erläutert.
Zunächst müssen wir die erforderlichen Header-Dateien einfügen
#einschließen
Die Initialisierung des LCD-Moduls ist ein sehr wichtiger Schritt. Hier verwenden wir bestimmte HEX-Codes, die eigentlich Befehle sind, um das LCD über die Betriebsart (4-Bit), den LCD-Typ (16x2), die Startlinie usw. zu informieren.
void LCD_INITILIZE (void) // Funktion zum Vorbereiten des LCD { IO0DIR = 0x0000FFF0; // Setzt Pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 als OUTPUT delay_ms (20); LCD_SEND (0x02); // lcd im 4-Bit-Betriebsmodus initialisieren LCD_SEND (0x28); // 2 Zeilen (16X2) LCD_SEND (0x0C); // Anzeige am Cursor aus LCD_SEND (0x06); // Auto-Inkrement-Cursor LCD_SEND (0x01); // Anzeige löschen LCD_SEND (0x80); // Erste Zeile erste Position }
Für den 4-Bit-Modus haben wir verschiedene Arten von Schreibfunktionen für die Pins, dh die Verwendung von oberem und unterem Halbbyte. Mal sehen, wie es gemacht wird
void LCD_SEND (char-Befehl) // Funktion zum Senden von Hex-Befehlen, die durch Nibble nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((Befehl & 0xF0) << 8)); // Oberes Nibble des Befehls senden IO0SET = 0x00000040; // Aktivieren aktivieren HIGH IO0CLR = 0x00000030; // RS & RW auf LOW einstellen delay_ms (5); IO0CLR = 0x00000040; // Aktivieren LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((Befehl & 0x0F) << 12)); // Sende Lower Nibble des Befehls IO0SET = 0x00000040; // HIGH IO0CLR AKTIVIEREN = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // ENABLE LOW delay_ms (5); }}
Nibble Sending Logic
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((Befehl & 0x0F) << 12)); // Sende unteres Nibble des Befehls IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((Befehl & 0xF0) << 8)); // Oberes Nibble des Befehls senden
Die obigen zwei Aussagen spielen in diesem Programm eine wichtige Rolle. Der erste Befehl sendet das untere Halbbyte und der zweite das obere Halbbyte. Das ist ohne die anderen Pins zu beeinflussen, die wir machen. Mal sehen, wie es passiert, bevor wir zuerst diese Logik kennenlernen
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Wir verwenden also ein Maskierungskonzept und eine logische Verschiebungsoperation, ohne die anderen Pins zu beeinflussen. Bedeutet, dass nur die Stifte (P0.12-P0.15) verwendet werden und keine anderen Stifte wie P0.4, P0.6 betroffen sind. Dazu werden die Daten in vier Bits verschoben und das obere Halbbyte anstelle des unteren Halbbytes erstellt und das obere Halbbyte maskiert. Und dann setzen wir die unteren Bits auf Null (0XF0) und ODER-verknüpft mit den Nibble-Daten, um die oberen Nibble-Daten am Ausgang zu erhalten.
Ein ähnlicher Prozess wird für niedrigere Nibble-Daten verwendet, aber hier müssen wir die Daten nicht verschieben.
Während des Schreibens von Daten zur Ausgabe, dh im Befehlsmodus, sollte RS LOW sein und zum Ausführen der Freigabe muss HIGH sein, und im Datenmodus sollte RS HIGH sein und zum Ausführen der Freigabe muss HIGH sein.
Für das Senden der Zeichenfolgendaten, die am Ausgang gedruckt werden sollen, wird nun dasselbe Prinzip Nibble für Nibble verwendet. Ein wichtiger Schritt hierbei ist, dass REGISTER SELECT (RS) für den Datenmodus HIGH sein muss.
void LCD_DISPLAY (char * msg) // Funktion zum Drucken der nacheinander gesendeten Zeichen { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Sendet Upper Nibble IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH zum Drucken von Daten IO0CLR = 0x00000020; // RW LOW Schreibmodusverzögerung ms (2); IO0CLR = 0x00000040; // EN = 0, RS und RW unverändert (dh RS = 1, RW = 0) Verzögerung ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Sendet Lower Nibble IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; Verzögerung ms (2); IO0CLR = 0x00000040; Verzögerung ms (5); i ++; }}
Das vollständige Codierungs- und Demonstrationsvideo finden Sie unten.