Display er den nødvendige delen av en maskin, enten det er husholdningsapparater eller industrielle maskiner. Displayet viser ikke bare kontrollalternativene for å betjene maskinen, men viser også status og utdata for oppgaven som maskinen utfører. Det er mange typer skjermer som brukes i elektronikk som 7-segment display, LCD-skjerm, TFT berøringsskjerm, LED-skjerm osv. 16x2 LCD-skjerm er den mest grunnleggende og også brukt skjerm i litt lite elektronikkutstyr, vi har gjort mye av prosjekter som bruker 16x2 LCD inkludert grunnleggende grensesnitt med andre mikrokontrollere:
- LCD-grensesnitt med 8051 mikrokontroller
- Grensesnitt LCD med ATmega32 Microcontroller
- LCD-grensesnitt med PIC-mikrokontroller
- Grensesnitt 16x2 LCD med Arduino
- 16x2 LCD-grensesnitt med Raspberry Pi ved hjelp av Python
I denne opplæringen vil vi se hvordan du kan grensesnitt en 16x2 LCD med ARM7-LPC2148 mikrokontroller og vise en enkel velkomstmelding. Hvis du er ny med ARM7, så start med det grunnleggende om ARM7 LPC2148 og lær hvordan det kan programmeres ved hjelp av Keil uVision
Nødvendig materiale
Maskinvare
- ARM7-LPC2148 mikrokontrollerkort
- LCD (16X2)
- Potensiometer
- 5V spenningsregulator IC
- Brettbrett
- Koble ledninger
- 9V batteri
- Micro USB-kabel
Programvare
- Keil uVision 5
- Magic Flash Tool
Før vi går inn i prosjektet, må vi vite få ting om LCD-modusene og om LCD Hex-kodene.
16X2 LCD-skjermmodul
En 16X2 LCD sier at den har 16 kolonner og 2 rader. Denne LCD-skjermen har 16 pinner. Nedenfor ser du bildet og tabellen på PIN-navnene på LCD-skjermen og funksjonene.
|
NAVN |
FUNKSJON |
|
VSS |
Bakkenål |
|
VDD |
+ 5V inngangsstift |
|
VEE |
Kontrastjusteringsstift |
|
RS |
Registrer Velg |
|
R / W |
Les / skriv pin |
|
E |
Aktiver pin |
|
D0-D7 |
Data Pins (8 Pins) |
|
LED A |
Anodepinne (+ 5V) |
|
LED K |
Katodepinne (GND) |
LCD-skjermen kan fungere i to forskjellige moduser, nemlig 4-bit-modus og 8-bit-modus. I 4-bits modus sender vi datanabber for napp, først øvre nibble og deretter nedre nibble. For de av dere som ikke vet hva en nippel er: en nibble er en gruppe på fire biter, så de nedre fire bitene (D0-D3) i en byte danner den nedre nibben mens de øvre fire bitene (D4-D7) av en byte danner det høyere knabbet. Dette gjør at vi kan sende 8-biters data.
Mens vi i 8-biters modus kan sende 8-biters data direkte i ett slag, siden vi bruker alle de 8 datalinjene.
Her i dette prosjektet vil vi bruke den mest brukte modusen som er 4-bit modus. I firebitsmodus kan vi lagre 4 pinner med mikrocontroller og også redusere ledningskostnadene.
16x2 bruker også HEX-kode for å ta en hvilken som helst kommando, det er mange hex-kommandoer for LCD som å flytte markøren, velge modus, flytte kontrollen til andre linje osv. For å vite mer om 16X2 LCD Display Module og hex-kommandoer, følg lenken.
Kretsdiagram og tilkoblinger
Tabellen nedenfor viser kretsforbindelsene mellom LCD og ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Register Select) |
|
P0.6 |
E (Aktiver) |
|
P0.12 |
D4 (datapinne 4) |
|
P0.13 |
D5 (datapinne 5) |
|
P0.14 |
D6 (datapinne 6) |
|
P0.15 |
D7 (datapinne 7) |
Tilkoblinger av spenningsregulator med LCD og ARM7 Stick
Tabellen nedenfor viser forbindelsene mellom ARM7 og LCD med spenningsregulator.
|
Spenningsregulator IC |
Pin-funksjon |
LCD & ARM-7 LPC2148 |
|
1. venstre pin |
+ Ve fra batteri 9V inngang |
NC |
|
2. sentrum pin |
- Ve fra batteri |
VSS, R / W, K på LCD GND av ARM7 |
|
3. høyre pin |
Regulert + 5V utgang |
VDD, A av LCD + 5V av ARM7 |
Potensiometer med LCD
Et potensiometer brukes til å variere kontrasten på LCD-skjermen. En pott har tre pinner, venstre pinne (1) er koblet til + 5V og midt (2) til VEE eller V0 på LCD-modulen og høyre pinne (3) er koblet til GND. Vi kan justere kontrasten ved å vri på knotten.
Jumperinnstillinger
En jumperpinne er tilstede i ARM7-Stick, slik at vi kan drive og laste opp kode ved hjelp av USB eller ved å bruke en 5V DC-inngang kun for strøm. Du kan se bildene nedenfor.
Bildet nedenfor viser at genseren er i DC-posisjon. Det betyr at vi må strømforsyne kortet fra ekstern 5V-forsyning.
Og dette bildet viser at genseren er koblet til i USB-modus. Her får du strøm og kode via mikro-usb-port.
MERKNAD: Her i denne opplæringen har vi lastet opp kode ved å bruke USB ved å sette jumper til USB og deretter byttet jumper til DC-modus for å drive LPC2148 fra 5v-inngangen til regulatoren. Du kan sjekke ut dette i videoen gitt på slutten.
Den siste kretsen for grensesnitt 16x2 LCD med ARM7 Microcontroller vil se slik ut:
Programmering ARM7-LPC2148
For å programmere ARM7-LPC2148 trenger vi keil uVision & Flash Magic verktøy. Vi bruker USB-kabel til å programmere ARM7 Stick via mikro-USB-port. Vi skriver kode ved hjelp av Keil og lager en hex-fil, og deretter blinkes HEX-filen til ARM7-pinne ved hjelp av Flash Magic. Hvis du vil vite mer om å installere keil uVision og Flash Magic og hvordan du bruker dem, kan du følge lenken Komme i gang med ARM7 LPC2148 Microcontroller og programmere den ved hjelp av Keil uVision.
Den komplette koden for grensesnitt LCD med ARM 7 er gitt på slutten av denne opplæringen, her forklarer vi noen få deler av den.
Først og fremst må vi inkludere de nødvendige headerfilene
#inkludere
Initialisering av LCD-modulen er et veldig viktig trinn. Her bruker vi visse HEX-koder, som egentlig er kommandoer, for å fortelle LCD-skjermen om driftsmåte (4-bit), type LCD (16x2), startlinje osv.
ugyldig LCD_INITILIZE (ugyldig) // Funksjon for å gjøre klar LCD-skjermen { IO0DIR = 0x0000FFF0; // Setter pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15as OUTPUT delay_ms (20); LCD_SEND (0x02); // Initier lcd i 4-biters modus LCD_SEND (0x28); // 2 linjer (16X2) LCD_SEND (0x0C); // Vis på markøren av LCD_SEND (0x06); // Automatisk økningsmarkør LCD_SEND (0x01); // Vis klar LCD_SEND (0x80); // Første linje førsteplass }
For 4-bit-modus har vi en annen type skrivefunksjon for pinnene, det vil si ved å bruke øvre og nedre nippel. La oss se hvordan det gjøres
ugyldig LCD_SEND (char-kommando) // Funksjon for å sende heksekommandoer nibble av nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Send øvre nibble av kommando IO0SET = 0x00000040; // Making Enable HIGH IO0CLR = 0x00000030; // Gjør RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // Gjør aktivering LAV forsinkelse_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((kommando & 0x0F) << 12)); // Send lavere nibble av kommando IO0SET = 0x00000040; // AKTIVER HØY IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // AKTIVER LAV forsinkelse_ms (5); }
Nibble Sending Logic
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((kommando & 0x0F) << 12)); // Send lavere nibble av kommando IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((kommando & 0xF0) << 8)); // Send øvre nibble av kommandoen
Over to uttalelser spiller en viktig rolle i dette programmet. Første kommando sender nedre knabb og andre sender øvre knabb. Det er uten å påvirke de andre pinnene vi gjør. La oss se hvordan det skjer før det blir kjent med denne logikken først
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Så vi bruker et maskeringskonsept og logisk skiftoperasjon uten å påvirke de andre pinnene. Betyr at bare pinnene (P0.12-P0.15) brukes, og ingen andre pinner som P0.4, P0.6 påvirkes. Det vil bli gjort ved å forskyve dataene i fire biter og lage den øvre nissen i stedet for den nedre nissen og maske den øvre nissen. Og så lager vi de nedre bitene null (0XF0) og ORed med nibble-dataene for å få de øvre nibble-dataene ved utgangen.
Lignende prosess brukes for data med lavere nibble, men her trenger vi ikke å flytte dataene.
Mens du skriver data for utdata, det vil si at i kommandomodus skal RS være LAV og for å utføre aktivering må være HØY, og i datamodus skal RS være HØY og for å utføre aktivering må være HØY.
Nå for å sende strengdataene som skal skrives ut, brukes det samme prinsippet nibble for nibble. Viktig trinn her er at REGISTER VALG (RS) må være HØY for datamodus.
ugyldig LCD_DISPLAY (char * msg) // Funksjon for å skrive ut tegnene som sendes en etter en { uint8_t i = 0; mens (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Sender Upper nibble IO0SET = 0x00000050; // RS HIGH & AKTIVER HIGH for å skrive ut data IO0CLR = 0x00000020; // RW LOW Skrivemodusforsinkelse ms (2); IO0CLR = 0x00000040; // EN = 0, RS og RW uendret (dvs. RS = 1, RW = 0) forsinkelse ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Sender nedre knabb IO0SET = 0x00000050; // RS & EN HØY IO0CLR = 0x00000020; forsinkelse ms (2); IO0CLR = 0x00000040; forsinkelse ms (5); i ++; }
Komplett kodings- og demonstrasjonsvideo er gitt nedenfor.