Display är den nödvändiga delen av en maskin oavsett om det är hushållsapparater eller industriella maskiner. Displayen visar inte bara kontrollalternativen för att manövrera maskinen utan visar också status och utdata för den uppgift som utförs av maskinen. Det finns många typer av skärmar som används i elektronik som 7-segmentsdisplay, LCD-display, TFT-pekskärmsdisplay, LED-skärm etc. 16x2 LCD-display är den mest grundläggande och används även i vissa små elektronikutrustningar, vi har gjort mycket av projekt som använder 16x2 LCD inklusive grundläggande gränssnitt med andra mikrokontroller:
- LCD-gränssnitt med 8051 mikrokontroller
- Gränssnitts LCD med ATmega32 Microcontroller
- LCD-gränssnitt med PIC Microcontroller
- Gränssnitt 16x2 LCD med Arduino
- 16x2 LCD-gränssnitt med Raspberry Pi med Python
I denna handledning kommer vi att se hur man gränssnitt en 16x2 LCD med ARM7-LPC2148 mikrokontroller och visar ett enkelt välkomstmeddelande. Om du är ny med ARM7, börja med grunderna i ARM7 LPC2148 och lär dig hur den kan programmeras med Keil uVision
Material som krävs
Hårdvara
- ARM7-LPC2148 Microcontroller-kort
- LCD (16X2)
- Potentiometer
- 5V spänningsregulator IC
- Bakbord
- Anslutande ledningar
- 9V batteri
- Micro USB-kabel
programvara
- Keil uVision 5
- Magic Flash Tool
Innan vi går in i projektet måste vi veta några saker om LCD-driftsätten och om LCD Hex-koder.
16X2 LCD-skärmmodul
En 16X2 LCD säger att den har 16 kolumner och 2 rader. Denna LCD-skärm har 16 stift. Nedanstående bild och tabell visar stiftnamnen på LCD-skärmen och dess funktioner.
|
NAMN |
FUNGERA |
|
VSS |
Markstift |
|
VDD |
+ 5V ingångsstift |
|
VEE |
Kontrastjusteringsstift |
|
RS |
Registrera Välj |
|
R / W |
Läs / skriv stift |
|
E |
Aktivera stift |
|
D0-D7 |
Data Pins (8 Pins) |
|
LED A |
Anodstift (+ 5V) |
|
LED K |
Katodstift (GND) |
LCD-skärmen kan fungera i två olika lägen, nämligen 4-bitarsläget och 8-bitarsläget. I 4-bitarsläge skickar vi datan nibble för nibble, först övre nibble och sedan nedre nibble. För de av er som inte vet vad en nibble är: en nibble är en grupp på fyra bitar, så de nedre fyra bitarna (D0-D3) i en byte bildar den nedre nibben medan de övre fyra bitarna (D4-D7) av en byte bildar det högre knapret. Detta gör att vi kan skicka 8-bitars data.
Medan vi i 8-bitarsläge kan vi skicka 8-bitarsdata direkt i ett slag eftersom vi använder alla de 8 datalinjerna.
Här i det här projektet kommer vi att använda det vanligaste läget som är 4-bitars läge. I fyrbitsläge kan vi spara fyra stift av mikrokontroller och också minska ledningsnätet.
16x2 använder också HEX-kod för att ta valfritt kommando, det finns många hex-kommandon för LCD som att flytta markören, välja läge, flytta kontrollen till andra raden etc. För att veta mer om 16X2 LCD Display Module och hex-kommandon, följ länken.
Kretsschema och anslutningar
Nedanstående tabell visar kretsanslutningarna mellan LCD och ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Registrera Välj) |
|
P0.6 |
E (Aktivera) |
|
P0.12 |
D4 (datapinne 4) |
|
P0.13 |
D5 (datapinne 5) |
|
P0.14 |
D6 (datapinne 6) |
|
P0.15 |
D7 (datapinne 7) |
Anslutningar av spänningsregulator med LCD & ARM7 Stick
Nedanstående tabell visar anslutningarna mellan ARM7 och LCD med spänningsregulator.
|
Spänningsregulator IC |
Pin-funktion |
LCD & ARM-7 LPC2148 |
|
1. vänster stift |
+ Ve från batteri 9V ingång |
NC |
|
2.Centre Pin |
- Ve från batteriet |
VSS, R / W, K på LCD GND av ARM7 |
|
3. höger stift |
Reglerad + 5V utgång |
VDD, A av LCD + 5V av ARM7 |
Potentiometer med LCD
En potentiometer används för att variera kontrasten på LCD-skärmen. En kruka har tre stift, vänster stift (1) är ansluten till + 5V och mitt (2) till VEE eller V0 på LCD-modulen och höger stift (3) är ansluten till GND. Vi kan justera kontrasten genom att vrida på ratten.
Bygelinställningar
En bygelstift finns i ARM7-Stick så att vi kan driva och ladda upp kod med USB eller med en 5V DC-ingång endast för ström. Du kan se bilderna nedan.
Bilden nedan visar att bygeln är i DC-läge. Det betyder att vi måste driva kortet från extern 5V-matning.
Och den här bilden visar att bygeln är ansluten i USB-läge. Här tillhandahålls strömmen och koden via mikro-USB-port.
OBS: Här i denna handledning har vi laddat upp koden genom att använda USB genom att ställa in bygel till USB och sedan byta bygel till DC-läge för att driva LPC2148 från 5v-ingången på regulatorn. Du kan kolla in detta i videon som ges i slutet.
Den sista kretsen för gränssnitt 16x2 LCD med ARM7 Microcontroller kommer att se ut så här:
Programmering ARM7-LPC2148
För att programmera ARM7-LPC2148 behöver vi keil uVision & Flash Magic-verktyget. Vi använder USB-kabel för att programmera ARM7 Stick via mikro-USB-port. Vi skriver kod med Keil och skapar en hex-fil och sedan blinkar HEX-filen till ARM7-stick med Flash Magic. Om du vill veta mer om installation av Keil uVision och Flash Magic och hur du använder dem följer du länken Komma igång med ARM7 LPC2148 Microcontroller och programmerar den med Keil uVision.
Den kompletta koden för gränssnitt mellan LCD och ARM 7 ges i slutet av denna handledning, här förklarar vi några delar av den.
Först och främst måste vi inkludera de nödvändiga rubrikfilerna
#omfatta
Initiera LCD-modulen är ett mycket viktigt steg. Här använder vi vissa HEX-koder, som faktiskt är kommandon, för att berätta LCD-skärmen om driftsätt (4-bit), typ av LCD (16x2), startlinje etc.
ogiltig LCD_INITILIZE (ogiltig) // Funktion för att göra klar LCD-skärmen { IO0DIR = 0x0000FFF0; // Ställer in stift P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 som OUTPUT delay_ms (20); LCD_SEND (0x02); // Initiera lcd i 4-bitars driftsätt LCD_SEND (0x28); // 2 rader (16X2) LCD_SEND (0x0C); // Visa på markören av LCD_SEND (0x06); // Autoinkrement- markör LCD_SEND (0x01); // Visa tydlig LCD_SEND (0x80); // Första raden första position }
För 4-bitars läge har vi olika typer av skrivfunktioner för stiften, det vill säga med hjälp av övre och nedre nibble. Låt oss se hur det görs
ogiltig LCD_SEND (char-kommando) // Funktion för att skicka hex-kommandon nibble med nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Skicka övre nibble av kommandot IO0SET = 0x00000040; // Att aktivera HIGH IO0CLR = 0x00000030; // Gör RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // Att aktivera LÅG fördröjning_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((kommando & 0x0F) << 12)); // Skicka lägre nibble av kommandot IO0SET = 0x00000040; // AKTIVERA HÖG IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // AKTIVER LÅG fördröjning_ms (5); }
Nibble Sending Logic
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((kommando & 0x0F) << 12)); // Skicka kommandot IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((kommando & 0xF0) << 8)); // Skicka övre kommandon
Ovan två uttalanden spelar en viktig roll i detta program. Första kommandot skickar nedre knapret och andra skickar det övre knapret. Det är utan att påverka de andra stiften vi gör. Låt oss se hur det händer innan det först lär känna den här logiken
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Så vi använder ett maskeringskoncept och logisk skiftoperation utan att påverka de andra stiften. Det betyder att endast stiften (P0.12-P0.15) används och inga andra stift som P0.4, P0.6 påverkas. Det kommer att göras genom att flytta data i fyra bitar och göra den övre knapret på platsen för den nedre knabbet och maskera den övre knapret. Och sedan gör vi de nedre bitarna noll (0XF0) och ORed med nibble-data för att få de övre nibble-data vid utgången.
Liknande process används för data med lägre nibble men här behöver vi inte flytta data.
När du skriver data till produktionen, det vill säga i kommandoläget RS ska vara låg och att verkställa det möjligt måste vara hög och i datamod RS ska vara hög och att verkställa det möjligt måste vara hög.
Nu för att skicka strängdata som ska skrivas ut vid utgången används samma princip nibble by nibble. Viktigt steg här är REGISTER SELECT (RS) måste vara HIGH för dataläge.
ogiltig LCD_DISPLAY (char * msg) // Funktion för att skriva ut de tecken som skickas en efter en { uint8_t i = 0; medan (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Skickar övre nibble IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH för att skriva ut data IO0CLR = 0x00000020; // RW LOW Skrivfördröjning ms (2); IO0CLR = 0x00000040; // EN = 0, RS och RW oförändrade (dvs. RS = 1, RW = 0) fördröjning ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Skickar lägre nibble IO0SET = 0x00000050; // RS & EN HÖG IO0CLR = 0x00000020; fördröjning ms (2); IO0CLR = 0x00000040; fördröjning ms (5); i ++; }
Komplett kodnings- och demonstrationsvideo ges nedan.