Arbeider med 1602 grafisk display i arduino. LCD WH1602B fra Winstar. LCD-skjermkontroll via I2C-buss
Hadde ankommet Arduino Nano, kom et sett med brødbrett og LCD-skjerm. Displayet på tavlen sier - 1602A, under - QAPASS. Jeg begynte å skulpturere den første enheten, og selvfølgelig ønsket jeg å vise informasjon på skjermen, og ikke blinke lysdioder.
Google hjalp meg, fortalte meg at dette er en karaktervisning; Hvis du ikke forvrenger det, er det mest sannsynlig at ASCII-tegn er tilgjengelige - tall, latin, noen av de grunnleggende tegnene.
Følgende materialer hjalp til med å starte skjermen: Kjøre en LCD-skjerm fra en PC-skriverport; Hvordan koble Arduino til en karakter LCD ; Pwm Servo Driver Motor Control PDF.
Displayet er ganske vanlig, og skjold er allerede oppfunnet for det - det er alternativer med SPI, som og/eller med I2C, og Internett er fullt av oppskrifter for disse tilfellene. Men jeg hadde bare den originale 16x2-skjermen og Arduinoen som jeg ønsket å feste den til.
Displayet har en driftsmodus og dataoverføring i nibbles, 4 bits hver, mens lavordensbitene til bussen ikke brukes. Å koble til kun halvparten av databussen er beskrevet mange steder, og jeg fant ikke ut hvordan jeg skulle koble til skjermen og jobbe med den over 8 linjer. Jeg er ganske fornøyd med hvordan det fungerer.
God beskrivelse av skjermer av denne typen Jeg fant den her - http://greathard.ucoz.com/44780_rus.pdf. Og her (http://arduino.ru/forum/programmirovanie/lcd-i2c-partizanit#comment-40748) er et eksempel på å spesifisere en tegngenerator.
Forbindelse
Skjermen min kom med uloddede kontakter. Fra begynnelsen ønsket jeg å lodde kabelen, kutte 16 ledninger med duponter og renset dem. Og så gravde jeg rundt i hvalen og fant en DuPont-kam for lodding til brettet. Derfra brøt jeg av 16 kontakter og loddet dem.Skjermen min så omtrent slik ut (før loddet kontaktene):
Først koblet jeg pinne 15 (A) til +5V, 16 (K) til jord, og sørget for at bakgrunnsbelysningen fungerte. Generelt er det riktig å koble katoden til jord gjennom en 220 Ohm motstand, som jeg da gjorde.
Deretter koblet jeg til jord (1) og strøm (2). Arduino kan drives fra USB, fra en stabilisert spenning på 5V og fra en ustabilisert 6-12V, den høyeste spenningen velges automatisk. Nå drives Arduino fra USB, og jeg lurte på hvor jeg skulle få tak i 5 volt. Det viste seg at 5V er på Arduino-pinnen, hvor ekstern stabilisert 5V er tilkoblet. Eller rettere sagt, det viste seg å være 4,7V, men det var nok for meg.
Etter å ha koblet til strømmen, hvis alt er i orden, lyser den øverste raden opp med solide rektangler av fortrolighet.
Deretter kobler vi til kontrastpotensiometeret (pin 3 V0). Vi kaster en av de ekstreme terminalene til potensiometeret til bakken, den andre til +5V, den midterste til pin 3 på skjermen. Et 10K potensiometer anbefales. Jeg hadde 50K fra hval, jeg brukte den først. Justeringen var bare på den ene kanten; det var nødvendig å fange ønsket kontrast veldig subtilt. Så fant jeg en lignende på 5K i en annen hval og installerte den. Innstillingen strakte seg fra en kant til en halv omgang. Tilsynelatende kan du ta et enda mindre potensiometer. 10K anbefales nok slik at kretsen bruker mindre. Ja, jeg måtte lodde litt; jeg loddet ledninger med duponter til terminalene på potensiometrene.
Testskisse
Vi tar testskissen fra eksemplene fra Arduino Studio - "C:\Program Files (x86)\Arduino\libraries\LiquidCrystal\ex amples\HelloWorld\HelloWorld.ino", trenger bare å endre kontaktene til våre - LiquidCrystal lcd( 7, 6, 5, 4, 3, 2);I prinsippet inneholder denne skissen også en beskrivelse av hva som skal kobles hvor. Du kan koble den til som angitt der, da trenger du ikke å endre noe i det hele tatt.
// inkluderer bibliotekkoden: #include
Det viser seg noe slikt: 
Forresten, skjermen som kom i hendene mine fungerer ikke uten bakgrunnsbelysning. Jeg mener, det fungerer, men du kan nesten ikke se noe.
1602A Vis kontakter
| # kontakt | Navn | Hvordan koble til |
|---|---|---|
| 1 | VSS | GND |
| 2 | VDD | +5V |
| 3 | V0 | Kontrast - til midtterminalen på potensiometeret |
| 4 | RS (Registrer velg) | D7 Arduino |
| 5 | R/W (les eller skriv) | GND |
| 6 | E (Aktiver signal) | D6 Arduino |
| 7-14 | D0-D7 | D0-D3 - ikke tilkoblet; D4-D7 - koblet til pinnene D5-D2 på Arduino |
| 15 | EN | Baklysanode, koblet til +5V |
| 16 | K | Bakgrunnsbelysningskatode, koblet til jord via en 220 Ohm motstand |
Artikkelen snakker om hvordan du kobler en LCD til Arduino riktig, alt du trenger å vite om å koble til LCD 1602 og LCD i2c er dekket.
LCD-skjermer i 1602 størrelser, laget på grunnlag av HD44780-kontrolleren, er i dag fortsatt en av de rimeligste, enkle og etterspurte for utvikling av alle slags elektroniske enheter.
Det er ikke overraskende at de kan sees både i enkle enheter montert bokstavelig talt på kneet, og i mer seriøse industrielle, for eksempel kaffemaskiner. Det er med denne skjermen at de mest populære Arduino-relaterte modulene og skjoldene settes sammen, for eksempel LCD I2C-modul og LCD Keypad Shield.
I de følgende trinnene vil vi fortelle deg i detalj med bilder hvordan du kobler LCD-skjermen til Arduino og viser nødvendig informasjon på skjermen.
Trinn 2. LCD 1602 for Arduino
1602-skjermene kommer i to forskjellige design:
- gul bakgrunnsbelysning med svarte bokstaver
- eller (dette skjer mye oftere) blått bakgrunnsbelysning med hvite.
Størrelsen på skjermene på HD44780-kontrolleren varierer veldig, men de styres på samme måte. De vanligste dimensjonene er 16 x 02 (det vil si 16 tegn på to linjer) eller 20 x 04. Tegnene i seg selv har en oppløsning på 5 x 8 piksler.
De fleste skjermer støtter ikke kyrillisk (med unntak av CTK-merkede skjermer). Men dette problemet er delvis løst, og artikkelen beskriver videre i detalj hvordan du gjør dette.
Skjermen har en 16-PIN-kontakt for tilkobling. Pinnene er merket på baksiden av brettet, det er som følger:
- 1 (VSS) – negativ strømforsyning for kontrolleren.
- 2 (VDD) – positiv strømforsyning for kontrolleren.
- 3 (VO) – kontrastkontrollinnstillinger.
- 4 (RS) – registervalg.
- 5 (R/W) – lesing og skriving, spesielt skriving når den er koblet til jord.
- 6 (E) – aktivering (aktivering).
- 7–10 (DB0-DB3) – lavordensbiter fra åttebitsgrensesnittet.
- 11–14 (DB4-DB7) – de viktigste bitene fra grensesnittet
- 15 (A) – positiv anode for strømforsyning med bakgrunnsbelysning.
- 16 (K) – negativ katode for strømforsyning for bakgrunnsbelysning.
Trinn 3. Koble til LCD-skjermen
Før du kobler til skjermen og overfører informasjon til den, er det verdt å sjekke funksjonaliteten. Sett først spenning på VSS- og VDD-kontrolleren, slå på bakgrunnsbelysningen (A, K), og juster deretter kontrasten.
For slike innstillinger er et 10 kOhm potensiometer egnet, formen er ikke viktig. +5V og GND tilføres de ytre bena, og benet i midten kobles til VO-pinnen.
Når strøm tilføres kretsen, må du oppnå den nødvendige kontrasten; hvis den er feiljustert, vil ikke bildet på skjermen være synlig. For å justere kontrasten, må du "leke" med potensiometeret. Når kretsen er satt sammen riktig og kontrasten er justert riktig, skal den øverste linjen på skjermen fylles med rektangler.
For å få skjermen til å fungere brukes et spesielt bibliotek innebygd i Arduino IDE-miljøet, LiquidCrystal.h, som jeg skal skrive om nedenfor. Den kan fungere i 8-biters og 4-biters modus. I det første alternativet brukes bare de minst signifikante og mest signifikante bitene ( BB0-DB7), i den andre – bare de yngre ( BB4-DB7).
Men å bruke 8-bits modus i denne skjermen er feil avgjørelse; det er nesten ingen hastighetsfordeler, siden oppdateringsfrekvensen alltid er mindre enn 10 ganger per sekund. For å vise tekst må du koble pinnene DB7, DB6, DB5, DB4, E og RS til kontrollerpinnene. De kan kobles til alle Arduino-pinner, det viktigste er å sette riktig rekkefølge i koden.
Hvis det nødvendige symbolet ennå ikke er i kontrollerens minne, kan du definere det manuelt (opptil syv symboler totalt). Cellen i skjermene som vurderes har en forlengelse på fem ganger åtte piksler. Oppgaven med å lage et symbol er å skrive en bitmaske og plassere dem på steder der prikkene skal lyse, og nuller der de ikke skal. Koblingsdiagrammet som er diskutert ovenfor er ikke alltid bra, siden minst seks digitale utganger brukes på Arduino.
Trinn 4. Bypass-ordning
La oss utforske et alternativ for å komme rundt dette og klare oss med bare to. Vi trenger en ekstra omformermodul for LCD til IIC/I2C. Hvordan den er loddet til skjermen og koblet til Arduino kan ses på bildene nedenfor.
Men dette tilkoblingsalternativet fungerer bare med et spesielt bibliotek, LiquidCrystal_I2C1602V1, som imidlertid er lett å finne på Internett og installere, hvoretter du kan bruke det uten problemer.
Trinn 4: LiquidCrystal.h bibliotek
LiquidCrystal.h-biblioteket kan lastes ned fra biblioteksdelen på nettstedet vårt på denne siden eller fra den offisielle ressursen arduino.cc. Men du kan også laste ned fra lenkene nedenfor:
Trinn 5. Skisse (programkode)
Når du har lastet ned arkivet, erstatter du LiquidCrystal-mappen i biblioteksmappen i Arduino-installasjonskatalogen.
Du kan se en prøveskisse på:
Fil -> Eksempler -> LiquidCrystal -> HelloWorld_SPI
Eller, hvis du har en meny på engelsk:
Fil -> Eksempler -> LiquidCrystal -> HelloWorld_SPI
Dette avslutter vår neste leksjon. Vi ønsker deg kvalitetsprosjekter!
LCD-skjerm– en hyppig gjest i Arduino-prosjekter. Men i komplekse kretser kan vi ha problemet med mangel på Arduino-porter på grunn av behovet for å koble til et skjold som har mange, mange pinner. Løsningen i denne situasjonen kan være I2C/IIC En adapter som kobler et nesten standard Arduino 1602-skjold til Uno-, Nano- eller Mega-kort med kun 4 pinner. I denne artikkelen skal vi se på hvordan du kan koble til en LCD-skjerm med et I2C-grensesnitt, hvilke biblioteker du kan bruke, skrive en kort eksempelskisse og se på vanlige feil.
LCD-skjerm LCD 1602 er godt valgå skrive ut tegnstrenger i ulike prosjekter. Det er billig, det er forskjellige modifikasjoner med forskjellige bakgrunnsbelysningsfarger, du kan enkelt laste ned ferdige biblioteker for Arduino-skisser. Men den største ulempen med denne skjermen er det faktum at skjermen har 16 digitale pinner, hvorav det kreves minimum 6. Derfor legger bruk av denne LCD-skjermen uten i2c til alvorlige begrensninger for Arduino Uno eller Nano-kort. Hvis det ikke er nok kontakter, må du kjøpe et Arduino Mega-brett eller lagre kontakter, inkludert ved å koble til skjermen via i2c.
Kort beskrivelse av LCD 1602 pins
La oss se nærmere på LCD1602-pinnene:
Hver av pinnene har sitt eget formål:
- Ground GND;
- Strømforsyning 5 V;
- Stille inn skjermens kontrast;
- Kommando, data;
- Skrive og lese data;
- Muliggjøre;
7-14. Data linjer;
- Pluss bakgrunnsbelysning;
- Minus bakgrunnsbelysningen.
Visningsspesifikasjoner:
- Tegnvisningstype, det er mulig å laste inn symboler;
- LED lys;
- Kontroller HD44780;
- Forsyningsspenning 5V;
- Format 16x2 tegn;
- Driftstemperaturområde fra -20C til +70C, lagringstemperaturområde fra -30C til +80C;
- Synsvinkel 180 grader.
Tilkoblingsskjema av LCD til Arduino-kort uten i2C
Standarddiagrammet for å koble en skjerm direkte til en Arduino mikrokontroller uten I2C er som følger.
På grunn av det store antallet tilkoblede kontakter kan det hende at det ikke er nok plass til å koble til de nødvendige elementene. Bruk av I2C reduserer antall ledninger til 4 og okkuperte pinner til 2.
Hvor kan du kjøpe LCD-skjermer og skjold for Arduino
LCD-skjerm 1602 (og versjon 2004) er ganske populær, så du kan enkelt finne den både i innenlandske nettbutikker og på utenlandske nettsteder. Her er noen linker til de mest tilgjengelige alternativene:
 LCD1602+I2C Blue Screen Module, Arduino-kompatibel
|
 En enkel LCD1602-skjerm (grønn bakgrunnsbelysning) billigere enn 80 rubler
|
 Stor LCD2004-skjerm med I2C HD44780 for Arduino (blått og grønt bakgrunnsbelysning)
|
 1602-skjerm med IIC-adapter og blått bakgrunnsbelysning
|
 En annen versjon av LCD1602 med en loddet I2C-modul
|
 Port IIC/I2C/TWI/SPI adaptermodul for 1602 skjold, kompatibel med Arduino
|
 RGB bakgrunnsbelyst skjerm! LCD 16×2 + tastatur + Buzzer Shield for Arduino
|
 Skjold for Arduino med knapper og skjerm LCD1602 LCD 1602
|
 LCD-skjerm for 3D-skriver (smartkontroller for RAMPS 1.4, Text LCD 20×4), SD- og MicroSD-kortlesermodul
|
Beskrivelse av I2C-protokollen
Før vi diskuterer å koble skjermen til Arduino via en i2c-adapter, la oss kort snakke om selve i2C-protokollen.
I2C/IIC(Inter-Integrated Circuit) er en protokoll som opprinnelig ble laget for kommunikasjon integrerte kretser innsiden elektronisk apparat. Utviklingen tilhører Philips. i2c-protokollen er basert på bruk av en 8-bits buss, som er nødvendig for å kommunisere blokker i kontrollelektronikk, og et adresseringssystem, takket være det kan du kommunisere over de samme ledningene med flere enheter. Vi overfører ganske enkelt data til en eller annen enhet, og legger til identifikatoren til det ønskede elementet til datapakkene.
Det meste enkel krets I2C kan inneholde én masterenhet (oftest en Arduino-mikrokontroller) og flere slaver (for eksempel en LCD-skjerm). Hver enhet har en adresse i området fra 7 til 127. Det skal ikke være to enheter med samme adresse i samme krets.
Arduino-kortet støtter i2c i maskinvare. Du kan bruke pinnene A4 og A5 for å koble til enheter som bruker denne protokollen.
Det er flere fordeler med I2C-drift:
- Drift krever kun 2 linjer - SDA (datalinje) og SCL (synkroniseringslinje).
- Koble til et stort antall ledende enheter.
- Redusert utviklingstid.
- Bare én mikrokontroller er nødvendig for å kontrollere hele settet med enheter.
- Det mulige antallet mikrokretser koblet til en buss begrenses kun av maksimal kapasitet.
- Høy grad av datasikkerhet på grunn av et spesielt overspenningsdempingsfilter innebygd i kretsene.
- En enkel prosedyre for å diagnostisere nye feil og raskt feilsøke feil.
- Bussen er allerede integrert i selve Arduino, så det er ikke nødvendig å utvikle et ekstra bussgrensesnitt.
Feil:
- Det er en kapasitiv grense på linjen - 400 pF.
- Vanskelig å programmere en I2C-kontroller hvis det er flere forskjellige enheter på bussen.
- Med et stort antall enheter blir det vanskelig å isolere en feil hvis en av dem feilaktig går lavt.
i2c-modul for LCD 1602 Arduino
Den raskeste og mest praktiske måten å bruke en i2c-skjerm på i Arduino er å kjøpe en ferdig skjerm med innebygd protokollstøtte. Men det er ikke veldig mange av disse skjermene og de er ikke billige. Men et stort antall forskjellige standardskjermer er allerede produsert. Derfor er det rimeligste og mest populære alternativet i dag å kjøpe og bruke en separat I2C-modul - en adapter som ser slik ut:
På den ene siden av modulen ser vi i2c-pinner - jord, strøm og 2 for dataoverføring. På den andre adapteren ser vi eksterne strømkontakter. Og selvfølgelig har brettet mange pinner som modulen er loddet til standard skjermpinnene med.
i2c-utganger brukes til å koble til Arduino-kortet. Om nødvendig kobler vi til ekstern strøm for bakgrunnsbelysning. Med den innebygde trimmeren kan vi stille inn tilpassede kontrastverdier J
På markedet kan du finne LCD 1602-moduler med allerede loddede adaptere; deres bruk er forenklet så mye som mulig. Hvis du har kjøpt en separat adapter, må du først lodde den til modulen.
Koble LCD-skjermen til Arduino via I2C
For å koble til trenger du selve Arduino-kortet, en skjerm, et brødbrett, tilkoblingsledninger og et potensiometer.
Hvis du bruker en spesiell separat i2c-adapter, må du først lodde den til skjermmodulen. Det er vanskelig å gjøre feil der, du kan følge denne ordningen.
En LCD-skjerm med i2c-støtte er koblet til brettet ved hjelp av fire ledninger - to ledninger for data, to ledninger for strøm.
- GND-pinnen kobles til GND på brettet.
- VCC-pinnen er på 5V.
- SCL kobles til pinne A5.
- SDA er koblet til pinne A.
Og det er alt! Ingen ledninger, som er veldig lett å vikle seg inn i. Samtidig kan vi ganske enkelt overlate all kompleksiteten ved å implementere i2C-protokollen til biblioteker.
Biblioteker for arbeid med i2c LCD-skjerm
For å samhandle med Arduino og LCD 1602 via I2C-bussen trenger du minst to biblioteker:
- Wire.h-biblioteket for arbeid med I2C er allerede inkludert i standarden Arduino-program IDE.
- LiquidCrystal_I2C.h-biblioteket, som inkluderer et bredt utvalg av kommandoer for å kontrollere skjermen via I2C-bussen og lar deg gjøre skissen enklere og kortere. Du må installere biblioteket i tillegg Etter at du har koblet til skjermen, må du i tillegg installere LiquidCrystal_I2C.h-biblioteket
Etter å ha koblet alle nødvendige biblioteker til skissen, lager vi et objekt og kan bruke alle funksjonene. For testing, la oss laste inn følgende standard eksempelskisse.
#inkludere
Beskrivelse av funksjoner og metoder for LiquidCrystal_I2C-biblioteket:
- home() og clear() - den første funksjonen lar deg returnere markøren til begynnelsen av skjermen, den andre gjør det samme, men sletter samtidig alt som var på skjermen før.
- write(ch) – lar deg skrive ut et enkelt tegn ch til skjermen.
- cursor() og noCursor() – viser/skjuler markøren på skjermen.
- blink() og noBlink() – markøren blinker/blinker ikke (hvis visningen var aktivert før).
- display() og noDisplay() – lar deg koble til/deaktivere skjermen.
- scrollDisplayLeft() og scrollDisplayRight() – ruller skjermen ett tegn til venstre/høyre.
- autoscroll() og noAutoscroll() – lar deg aktivere/deaktivere autoscroll-modus. I denne modusen skrives hver nye karakter på samme sted, og fortrenger det som tidligere ble skrevet på skjermen.
- leftToRight() og rightToLeft() – Stille inn retningen til den viste teksten – venstre til høyre eller høyre til venstre.
- createChar(ch, bitmap) – lager et tegn med kode ch (0 – 7), ved å bruke en rekke punktgrafikk-bitmaps for å lage svarte og hvite punkter.
Alternativt bibliotek for arbeid med i2c-skjerm
I noen tilfeller kan det oppstå feil ved bruk av det spesifiserte biblioteket med enheter utstyrt med PCF8574-kontrollere. I dette tilfellet kan LiquidCrystal_PCF8574.h-biblioteket foreslås som et alternativ. Den utvider LiquidCrystal_I2C, så det skal ikke være noen problemer med å bruke den.
Problemer med å koble til i2c lcd-skjerm
Hvis du ikke ser noen melding på skjermen etter å ha lastet opp skissen, prøv følgende trinn.
Først kan du øke eller redusere skjermens kontrast. Ofte er tegn rett og slett ikke synlige på grunn av kontrast- og bakgrunnsbelysningsmodus.
Hvis dette ikke hjelper, sjekk om kontaktene er riktig tilkoblet og om bakgrunnsbelysningen er tilkoblet. Hvis du brukte en separat i2c-adapter, sjekk igjen kvaliteten på loddingen til kontaktene.
En annen vanlig årsak til manglende tekst på skjermen kan være feil i2c-adresse. Prøv først å endre enhetsadressen i skissen fra 0x27 0x20 eller til 0x3F. Ulike produsenter kan ha forskjellige standardadresser programmert. Hvis dette ikke hjelper, kan du kjøre i2c-skannerskissen, som skanner alle tilkoblede enheter og bestemmer adressen deres ved hjelp av brute force. Et eksempel på en i2c skannerskisse.
Hvis skjermen fortsatt ikke fungerer, prøv å løse ut adapteren og koble til LCD-skjermen som vanlig.
Konklusjon
I denne artikkelen så vi på hovedproblemene ved bruk av en LCD-skjerm i komplekse Arduino-prosjekter, når vi trenger å lagre gratis pins på brettet. En enkel og rimelig i2c-adapter lar deg koble til en 1602 LCD-skjerm som bare tar opp 2 analoge pinner. I mange situasjoner kan dette være svært viktig. Prisen for bekvemmelighet er behovet for å bruke en tilleggsmodul - en omformer og et bibliotek. Etter vår mening er dette ikke en høy pris å betale for enkelhets skyld, og vi anbefaler på det sterkeste å bruke denne funksjonen i prosjekter.
Hva er en integrert del av et stort antall elektroniske enheter? Selvfølgelig, midler for indikasjon og grafisk utdata av data. Det er alltid mer praktisk og behagelig for brukeren når resultatet av "smartboksen" kan sees visuelt. Derfor vil vi i dag koble en skjerm til STM32 for å vise tekst og tall. Helten i eksperimentene våre vil være en ganske populær skjerm fra Winstar. For øvrig dukket det opp en viktig presisering i kommentarene om at metodikken i utgangspunktet er lik for alle visninger basert på HD44780. Takk til JekaKey for det viktige tillegget)
Først må skjermen kobles til kontrolleren. Last ned dataarket og se etter WH1602 pinout. Se her:
Som du vet, skjerm WH1602 har 16 pinner. La oss se på hver enkelt...
Pins Vss, Vdd og K må kobles til jord og strøm, det vil si nøyaktig som angitt i tabellen, det er ingen overraskelser og ingenting å diskutere)
Pinne nummer 3 brukes til å justere kontrasten - hvis vi legger på +5V der, ser vi absolutt ingenting, og hvis vi kortslutter pinnen til jord, vil vi beundre to rader med svarte firkanter 😉 Dette passer naturligvis ikke oss , så vi må henge et potensiometer (motstand) der med variabel motstand) for å justere kontrasten. Den beste synlighet av tegn er gitt av en spenning på 0,5-0,7 V på denne skjermpinnen.
RS-pinnen er allerede en pinne som vi selv skal styre ved hjelp av en mikrokontroller. Et lavt spenningsnivå (0) på denne pinnen betyr at en kommando nå vil følge, et høyt nivå (1) betyr at det nå vil være data som skal skrives til skjermminnet.
Pin R/W - det er tydelig her, enten leser vi dataene (viser opptatt flagg, for eksempel), i dette tilfellet er det 1 på denne pinnen, eller vi skriver kommandoen/dataene til displayet, så har vi 0 her.
DB7 – DB0 – databuss, og det sier alt)
Pin E er det såkalte Enable-signalet. Det er dette han trengs til. For å jobbe med skjermen - registrere data eller gi en kommando - må vi gi en positiv puls til denne pinnen. Det vil si at prosedyren vil se slik ut:
- På pinnene RS, R/W, DB7 - DB0 - de nødvendige signalene som tilsvarer vår kommando.
- Vi leverer en til pinne E.
- Zhdems (i henhold til dataarket - minst 150 ns)
- Vi bruker et lavt nivå (0) på pinne E.
Du må sette 4,2 V på A/Vee-benet for å drive skjermens bakgrunnsbelysning.
Slik skjer kommunikasjon med WH1602-skjermen.
Vi har funnet ut å koble til WH1602, men før vi går videre til eksemplet, la oss se på hvilke kommandoer skjermen vår generelt forstår. For å gjøre dette går vi inn i dataarket og finner en interessant tabell:
Alle kommandoer og signaler som skal være på de tilsvarende pinnene til WH1602 for hver spesifikke kommando er beskrevet her. For eksempel vil vi tømme skjermen, vi ser på bordet, og her er kommandoen vi trenger! Tøm skjerm!
Vi bruker nuller på pinnene RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1, og en til pinne DB0. Ferdig! Hva er det neste? Det stemmer, en på pinne E, så vent en stund og senk E til null igjen. Det er det, displayet tømmes 😉 Rett før du utfører neste kommando må du pause, angitt i dataarket for hver kommando. Det ville være mer effektivt å polle opptatt-flagget; så snart det er tilbakestilt til 0, kan du fortsette å jobbe. Det er også en spesiell kommando for å lese dette flagget, så alt er klart med dette) La oss gå videre...
Og faktisk er alt med teorien, du kan allerede prøve å skrive noe. For å gjøre arbeidet med skjermen enklere laget jeg et lite bibliotek, nå skal vi se hvordan det kan brukes. Først, last ned
Vi får 2 filer til rådighet, MT_WH1602.c og MT_WH1602.h. Vi river av den andre, her må vi velge pinnene og kontrolleren som brukes.
Skjermen min er forresten koblet slik:
RS-PC2
R/W – PB10
E–PB14
DB7–PD2
DB6–PC12
DB5–PA8
DB4–PA10
DB3–PA15
DB2–PD11
DB1–PA3
DB0–PA5
Åpne filen MT_WH1602.h:
| #define PLATTFORM (STM32F10x) |
Deretter velger du mikrokontrollerpinnene som skjermen er koblet til. Bare la oss først angi hvilke porter vi bruker. Når jeg kobler til bruker jeg GPIOA, GPIOB, GPIOC og GPIOD, vi skriver:
Tilsvarende for andre mikrokontrollerben.
Vi er ferdige med oppsettet, la oss fortsette) For å kalle kommandoene gitt i begynnelsen av artikkelen, inneholder MT_WH1602.c-filen følgende funksjoner (de er oppkalt etter navnene på kommandoene, så jeg tror alt er klart) :
| void MT_WH1602_ClearDisplay(void ) ; void MT_WH1602_ReturnHome(void ) ; void MT_WH1602_EntryModeSet (bool ID-adresse, bool shift) ; void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; void MT_WH1602_CursorOrDisplayShift (bool SCbit, bool RLbit) ; void MT_WH1602_FunctionSet (bool DLbit, bool Nbit, bool Fbit) ; void MT_WH1602_SetCGRAMAddress (uint8_t-adresse) ; void MT_WH1602_SetDDRAMAddress (uint8_t-adresse) ; bool MT_WH1602_ReadBusy(void) ; void MT_WH1602_WriteData(uint8_t data) ; |
For noen kommandoer må vi sende parametere til funksjonen, for eksempel:
| void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; |
La oss se på kommandotabellen:
Vi ser at Display ON/OFF-kommandoen ikke bare slår på/av skjermen, men også aktiverer/deaktiverer markøren og markøren som blinker. I dataarket er disse kommandobitene utpekt som D, C og B, og vi sender dem som parametere til funksjonen. Hvis vi trenger å slå på skjermen og markøren, men deaktivere markørens blinking, kaller vi kommandoen som følger:
MT_WH1602_DisplayOnOff(1, 1, 0);
Generelt er alt enkelt 😉
Kort sagt, vi skaper nytt prosjekt, legg til et bibliotek for arbeid med WH1602-skjermen, lag en tom .c-fil og begynn å fylle den med kode:
| // Inkluder bibliotekfilen#include "MT_WH1602.h" /*******************************************************************/ int main(void) ( // Kall initialiseringsfunksjonen, vi klarer oss ikke uten den =)() ; // Nå må vi gjøre den første skjermkonfigurasjonen // Dokumentasjon og Internett anbefaler å gjøre dette ;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay(1000 ) ; MT_WH1602_DisplayOnOff(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_ClearDisplay() ; MT_WH1602_Delay(2000) ; // For eksempel tok jeg de første forsinkelsesverdiene som dukket opp) // Generelt må du sjekke flagget for opptatt display // La oss nå vise noe, som navnet på nettstedet vårt MT_WH1602_WriteData(0x6D) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x6F) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x74) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x65) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x68) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x6E) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x73) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x2E) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x75) ; MT_WH1602_Delay(100) ; mens (1) ( __NOP() ; ) ) /*******************************************************************/ |
Ferdig, la oss sjekke) 
Som du kan se, fungerer alt som det skal)
Forresten, jeg mistet på en eller annen måte spørsmålet om hva jeg skulle skrive på skjermen for å vise denne eller den karakteren. Her er platen fra databladet: 
Så for å finne ut hvilken verdi du skal skrive inn i displayminnet, må du ta tallene som er skrevet øverst og til venstre i denne tabellen for et spesifikt symbol. For eksempel symbolet "A". La oss se - dette symbolet tilsvarer kolonne 0100 (0x4) og linje 0001 (0x1). Det viser seg at for å vise symbolet "A" må du skrive verdien 0x41 inn i displayet.
Det er det nå =) Vi har ordnet tilkoblingen og driften av WH1602-skjermen, så vi sees snart!
P.S. Når jeg jobbet med biblioteket, testet jeg ikke funksjonen til å lese opptatt-flagget, så hvis noe plutselig ikke fungerer som det skal, skriv, så finner vi ut av det)
Noen ganger står vi overfor problemet med å sende ut forskjellig informasjon fra Arduino til omverdenen. Ofte er det umulig, upraktisk og ulønnsomt å bruke en seriell port.
En tegnvisning er en av de enkleste og billigste måtene å vise informasjon på fordi den har sin egen mikrokontroller som lagrer de kodede tegnene. Dette systemet forenkler bruken av disse skjermene, men begrenser samtidig bruken til kun utgang tekstinformasjon, i motsetning til grafiske skjermer.
I eksemplet skal vi se på Winstar wh1602l1-skjermen, en av de vanligste skjermene på hd44780-kontrolleren. I tillegg kan du koble til LCD 2004 og andre lignende.
De to første sifrene angir antall tegn per linje, og det andre antallet linjer, så det valgte displayet har 2 linjer med 16 tegn.
Denne tilkoblingsmetoden innebærer å okkupere minst 6 porter på Arduino-mikrokontrolleren. Om nødvendig kan du koble til 1602-tekstdisplayet via I2C-grensesnittet (2 porter).
Av tilleggselementene vi trenger variabel motstand, for å kontrollere kontrasten. Ellers er alt koblet i henhold til diagrammet, i henhold til dataarket og de valgte Arduino-utgangene i programmet.
Pinne 15 og 16 på skjermen er ansvarlige for bakgrunnsbelysningen; den kan slås av eller lysstyrken kan justeres automatisk når du kobler en fotomotstand til Arduino som en lysstyrkesensor.
I vårt eksempel vil vi lese data fra serieporten og vise dem på skjermen:
#inkludere
Du kan komplisere koden og sende ut DS1307 sanntidsklokke på Arduino til LCD1602.
La oss nå se nærmere på alle funksjonene i biblioteket Flytende krystall:
Det første og viktigste er at ved å bruke dette biblioteket kan du ikke vise russiske bokstaver, selv om skjermen har disse tegnene i minnet. Dette problemet kan løses enten av andre biblioteker, eller ved å skrive verdier ved hjelp av heksadesimal kode.
lcd.print();- den enkleste og mest brukte, brukes til å vise informasjon.
lcd. klar(); - brukes til å rengjøre skjermen.
lcd.setCursor(x, y); - plasserer markøren på et bestemt sted.
X – endring av posisjon i linjen
Y – linjeskifte
For eksempel, lcd.setCursor(0, 0); dette er cellen øverst til venstre.
lcd.home(); - plasserer markøren i posisjon 0, 0
lcd.home(); = lcd.setCursor(0, 0);
lcd. scroll Display til venstre(); - skift til venstre
lcd. scrollDisplayRight(); - skift til høyre
Lcd.createChar(Navn, array); - lage ditt eget skilt.
Gradtegnet ser for eksempel slik ut:
Celc = (B00111, B00101, B00111, B00000, B00000, B00000, B00000, B00000);
