- Vereiste materialen
- 16X2 LCD-weergavemodule
- Schakelschema en aansluitingen
- ARM7-LPC2148 programmeren
Display is het noodzakelijke onderdeel van een machine, of het nu een huishoudelijk apparaat of industriële machines is. Het display toont niet alleen de besturingsopties om de machine te bedienen, maar toont ook de status en uitvoer van de taak die door die machine wordt uitgevoerd. Er zijn veel soorten displays die in de elektronica worden gebruikt, zoals een 7-segment display, LCD display, TFT touchscreen display, LED display etc. 16x2 LCD display is de meest eenvoudige en wordt ook gebruikt in sommige kleine elektronica apparatuur, we hebben er veel aan gedaan projecten met 16x2 LCD inclusief de basisinterface met andere microcontrollers:
- LCD-interface met 8051 Microcontroller
- Interfacing LCD met ATmega32 Microcontroller
- LCD-interface met PIC-microcontroller
- 16x2 LCD-interface met Arduino
- 16x2 LCD-interface met Raspberry Pi met Python
In deze zelfstudie zullen we zien hoe u een 16x2 LCD-scherm verbindt met de ARM7-LPC2148-microcontroller en een eenvoudig welkomstbericht weergeeft. Als je nieuw bent met ARM7, begin dan met de basisprincipes van ARM7 LPC2148 en leer hoe het kan worden geprogrammeerd met Keil uVision
Vereiste materialen
Hardware
- ARM7-LPC2148 Microcontroller-kaart
- LCD (16X2)
- Potentiometer
- 5V spanningsregelaar IC
- Breadboard
- Verbindingsdraden
- 9V batterij
- Micro USB-kabel
Software
- Keil uVision 5
- Magische Flash-tool
Voordat we aan het project beginnen, moeten we enkele dingen weten over de LCD-werkingsmodi en over de LCD Hex-codes.
16X2 LCD-weergavemodule
Een 16x2 LCD zegt dat het 16 kolommen en 2 rijen heeft. Dit LCD-scherm heeft 16 pinnen. Onderstaande afbeelding en tabel toont de pinnamen van het LCD-scherm en zijn functies.
|
NAAM |
FUNCTIE |
|
VSS |
Aardingspen |
|
VDD |
+ 5V invoerpin |
|
VEE |
Contrastafstelpen |
|
RS |
Registreren Selecteer |
|
R / W |
Pin lezen / schrijven |
|
E. |
Pin inschakelen |
|
D0-D7 |
Datapinnen (8 pinnen) |
|
LED EEN |
Anodespeld (+ 5V) |
|
LED K |
Kathodepen (GND) |
Het LCD-scherm kan in twee verschillende modi werken, namelijk de 4-bit modus en de 8-bit modus. In de 4-bits modus sturen we de gegevens nibble door te knabbelen, eerst bovenste nibble en vervolgens onderste nibble. Voor degenen onder u die niet weten wat een nibble is: een nibble is een groep van vier bits, dus de onderste vier bits (D0-D3) van een byte vormen de onderste nibble, terwijl de bovenste vier bits (D4-D7) van een byte vormen de hogere nibble. Hierdoor kunnen we 8 bit data versturen.
Terwijl we in de 8-bit-modus de 8-bit-gegevens rechtstreeks in één keer kunnen verzenden, omdat we alle 8 datalijnen gebruiken.
Hier in dit project zullen we de meest gebruikte modus gebruiken, namelijk de 4-bits modus. In de vier bit-modus kunnen we 4 pinnen van de microcontroller opslaan en ook de bedradingsoverhead verminderen.
16x2 gebruikt ook HEX-code om een commando te nemen, er zijn veel hex-commando's voor LCD, zoals het verplaatsen van de cursor, het selecteren van de modus, het verschuiven van het besturingselement naar de tweede regel enz. Om meer te weten over de 16X2 LCD-displaymodule en hex-commando's, volg de link.
Schakelschema en aansluitingen
Onderstaande tabel toont de circuitverbindingen tussen LCD en ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Registreer selecteren) |
|
P0.6 |
E (inschakelen) |
|
P0.12 |
D4 (gegevenspin 4) |
|
P0.13 |
D5 (gegevenspin 5) |
|
P0.14 |
D6 (gegevenspin 6) |
|
P0.15 |
D7 (gegevenspin 7) |
Aansluitingen van spanningsregelaar met LCD & ARM7 Stick
Onderstaande tabel toont de verbindingen tussen ARM7 & LCD met spanningsregelaar.
|
Spanningsregelaar IC |
Pin-functie |
LCD & ARM-7 LPC2148 |
|
1. linker pin |
+ Ve van batterij 9V Input |
NC |
|
2. middelste pin |
- Ve van de batterij |
VSS, R / W, K of LCD GND van ARM7 |
|
3. juiste pin |
Gereguleerde + 5V-uitgang |
VDD, A van LCD + 5V van ARM7 |
Potentiometer met LCD
Een potentiometer wordt gebruikt om het contrast van het LCD-scherm te variëren. Een pot heeft drie pinnen, Linker pin (1) is verbonden met + 5V en midden (2) met VEE of V0 van LCD-module en rechter pin (3) is verbonden met GND. We kunnen het contrast aanpassen door aan de knop te draaien.
Jumper-instellingen
Een jumperpin is aanwezig in ARM7-Stick, zodat we de code kunnen voeden en uploaden via USB of door een 5V DC-ingang alleen voor stroom te gebruiken. U kunt de onderstaande afbeeldingen zien.
Onderstaande afbeelding laat zien dat de jumper zich in de DC-positie bevindt. Dat betekent dat we het bord moeten voeden met een externe 5V-voeding.
En deze afbeelding laat zien dat de jumper is aangesloten in de USB-modus. Hier wordt de stroom en de code geleverd via de micro-usb-poort.
OPMERKING: hier in deze tutorial hebben we code geüpload met behulp van USB door de jumper in te stellen op USB en vervolgens de jumper in DC-modus te wijzigen om LPC2148 van stroom te voorzien vanaf 5v-ingang van de regelaar. Je kunt dit bekijken in de video aan het einde.
Het laatste circuit voor het koppelen van 16x2 LCD-schermen met ARM7 Microcontroller ziet er als volgt uit:
ARM7-LPC2148 programmeren
Om ARM7-LPC2148 te programmeren, hebben we de tool uVision & Flash Magic nodig. We gebruiken een USB-kabel om de ARM7 Stick te programmeren via een micro-USB-poort. We schrijven code met Keil en maken een hex-bestand en vervolgens wordt het HEX-bestand met Flash Magic naar de ARM7-stick geflitst. Om meer te weten over het installeren van keil uVision en Flash Magic en hoe u ze kunt gebruiken, volgt u de link Aan de slag met ARM7 LPC2148 Microcontroller en programmeert u deze met Keil uVision.
De volledige code voor het verbinden van LCD met ARM 7 wordt gegeven aan het einde van deze tutorial, hier leggen we enkele delen ervan uit.
Allereerst moeten we de vereiste header-bestanden opnemen
# omvatten
Het initialiseren van de LCD-module is een zeer belangrijke stap. Hier gebruiken we bepaalde HEX-codes, die eigenlijk commando's zijn, om het LCD-scherm te vertellen over de werkingsmodus (4-bit), type LCD (16x2), startregel enz.
void LCD_INITILIZE (void) // Functie om de LCD klaar te maken { IO0DIR = 0x0000FFF0; // Stelt pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 in als OUTPUT delay_ms (20); LCD_SEND (0x02); // Initialiseer lcd in 4-bits modus LCD_SEND (0x28); // 2 regels (16X2) LCD_SEND (0x0C); // Weergave op cursor uit LCD_SEND (0x06); // Auto increment cursor LCD_SEND (0x01); // Display duidelijk LCD_SEND (0x80); // Eerste regel eerste positie }
Voor de 4-bits modus hebben we verschillende soorten schrijffuncties voor de pinnen, dat wil zeggen door gebruik te maken van bovenste en onderste nibble. Eens kijken, hoe het wordt gedaan
void LCD_SEND (char commando) // Functie om hex-commando's te sturen nibble by nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Stuur bovenste nibble van commando IO0SET = 0x00000040; // HIGH IO0CLR = 0x00000030 inschakelen ; // RS & RW LOW maken delay_ms (5); IO0CLR = 0x00000040; // LAGE delay_ms (5) inschakelen ; IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commando & 0x0F) << 12)); // Stuur onderste knabbel van commando IO0SET = 0x00000040; // HOOG INSCHAKELEN IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // LAAG INSCHAKELEN delay_ms (5); }
Knabbel Logica verzenden
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commando & 0x0F) << 12)); // Stuur onderste knabbel van commando IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commando & 0xF0) << 8)); // Stuur de bovenste opdracht
Bovenstaande twee uitspraken spelen een belangrijke rol in dit programma. Eerste commando stuurt onderste knabbel en tweede stuurt de bovenste knabbel. Dat heeft geen invloed op de andere pinnen die we doen. Laten we eens kijken hoe het gebeurt voordat we eerst deze logica leren kennen
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
We gebruiken dus een maskeerconcept en logische shift-operatie zonder de andere pinnen te beïnvloeden. Betekent dat alleen de pinnen (P0.12-P0.15) worden gebruikt en geen andere pinnen zoals P0.4, P0.6 worden beïnvloed. Het zal worden gedaan door de gegevens in vier bits te verschuiven en de bovenste knabbel in plaats van de onderste knabbel te maken en de bovenste knabbel te maskeren. En dan maken we de onderste bits nul (0XF0) en ORed met de nibble-gegevens om de bovenste nibble-gegevens aan de uitgang te krijgen.
Een soortgelijk proces wordt gebruikt voor lagere nibble-gegevens, maar hier hoeven we de gegevens niet te verschuiven.
Tijdens het schrijven van gegevens naar de uitgang, dat wil zeggen in de command mode RS dient laag te zijn en uit te voeren mogelijk te maken moet hoog zijn, en in de data mode RS moet hoog zijn en uit te voeren mogelijk te maken moet hoog zijn.
Voor het verzenden van de stringgegevens die aan de uitgang moeten worden afgedrukt, wordt hetzelfde principe gebruikt nibble by nibble. Belangrijke stap hier is REGISTER SELECT (RS) moet HOOG zijn voor de datamodus.
void LCD_DISPLAY (char * msg) // Functie om de verzonden tekens een voor een af te drukken { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Stuurt bovenste nibble IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH om gegevens af te drukken IO0CLR = 0x00000020; // RW LAAG Schrijfmodus vertraging ms (2); IO0CLR = 0x00000040; // EN = 0, RS en RW ongewijzigd (dwz RS = 1, RW = 0) vertraging ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Stuurt lagere nibble IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; vertraging ms (2); IO0CLR = 0x00000040; vertraging ms (5); i ++; }
De volledige video over codering en demonstratie wordt hieronder gegeven.