Arbetar med 1602 grafisk display i arduino. LCD WH1602B från Winstar. LCD-skärmkontroll via I2C-buss
Hade anlänt Arduino Nano, anlände ett kit som innehåller en brödbräda och en LCD-skärm. Displayen på tavlan säger - 1602A, nedan - QAPASS. Jag började skulptera den första enheten, och naturligtvis ville jag visa information på skärmen och inte blinka lysdioder.
Google hjälpte till, berättade för mig att detta är en teckenvisning; Om du inte förvränger det, är ASCII-tecken troligen tillgängliga - siffror, latin, några av de grundläggande tecknen.
Följande material hjälpte till att starta displayen: Drivning av en teckentyp LCD från en PC-skrivarport; Hur man ansluter Arduino med en tecken LCD ; Pwm Servo Driver Motor Control PDF.
Displayen är ganska vanlig, och sköldar har redan uppfunnits för det - det finns alternativ med SPI, som och/eller med I2C, och Internet är fullt av recept för dessa fall. Men jag hade bara den ursprungliga 16x2-skärmen och Arduino som jag ville fästa den på.
Displayen har ett driftläge och dataöverföring i nibbles, 4 bitar vardera, medan bussens lågordningsbitar inte används. Att ansluta bara hälften av databussen beskrivs på många ställen, och jag kom inte på hur jag skulle koppla in displayen och arbeta med den över 8 rader. Jag är ganska nöjd med hur det fungerar.
Bra beskrivning av displayer av denna typ Jag hittade den här - http://greathard.ucoz.com/44780_rus.pdf. Och här (http://arduino.ru/forum/programmirovanie/lcd-i2c-partizanit#comment-40748) är ett exempel på att specificera en teckengenerator.
Förbindelse
Min display kom med olödda kontakter. Från början ville jag löda kabeln, klippa 16 trådar med duponter och rengöra dem. Och så grävde jag runt i valen och hittade en DuPont-kam för att löda på brädan. Därifrån bröt jag av 16 kontakter och lödde fast dem.Min skärm såg ut ungefär så här (innan kontakterna löddes):
Först kopplade jag stift 15 (A) till +5V, 16 (K) till jord, och såg till att bakgrundsbelysningen fungerade. Generellt sett är det korrekt att ansluta katoden till jord genom ett 220 Ohm motstånd, vilket jag då gjorde.
Sedan kopplade jag ihop jord (1) och ström (2). Arduino kan drivas från USB, från en stabiliserad spänning på 5V och från en ostabiliserad 6-12V, den högsta spänningen väljs automatiskt. Nu drivs Arduino från USB, och jag undrade var jag skulle få tag i 5 volt. Det visade sig att 5V sitter på Arduino-stiftet, där externt stabiliserat 5V är anslutet. Eller rättare sagt, det blev 4,7V, men det räckte för mig.
Efter att ha anslutit strömmen, om allt är bra, lyser den översta raden med solida rektanglar av bekantskap.
Sedan ansluter vi kontrastpotentiometern (stift 3 V0). Vi kastar en av potentiometerns extrema terminaler till marken, den andra till +5V, den mellersta till stift 3 på skärmen. En potentiometer på 10K rekommenderas. Jag hade 50K från whale, jag använde den först. Justeringen var bara på en kant, det var nödvändigt att fånga den önskade kontrasten mycket subtilt. Sedan hittade jag en liknande på 5K i en annan val och installerade den. Inställningen sträckte sig från en kant till ett halvt varv. Tydligen kan du ta en ännu mindre potentiometer. 10K rekommenderas förmodligen så att kretsen förbrukar mindre. Ja, jag var tvungen att löda lite, jag lödde ledningar med duponter till terminalerna på potentiometrarna.
Provskiss
Vi tar testskissen från exemplen från Arduino Studio - "C:\Program Files (x86)\Arduino\libraries\LiquidCrystal\ex amples\HelloWorld\HelloWorld.ino", behöver bara ändra kontakterna till våra - LiquidCrystal lcd( 7, 6, 5, 4, 3, 2);Den här skissen innehåller i princip även en beskrivning av vad som ska kopplas var. Du kan ansluta den som anges där, då behöver du inte ändra något alls.
// inkludera bibliotekskoden: #include
Det visar sig ungefär så här: 
Förresten, skärmen som kom i mina händer fungerar inte utan bakgrundsbelysning. Jag menar, det fungerar, men man kan knappt se någonting.
1602A Visa kontakter
| # Kontakt | namn | Hur man ansluter |
|---|---|---|
| 1 | VSS | GND |
| 2 | VDD | +5V |
| 3 | V0 | Kontrast - till mittterminalen på potentiometern |
| 4 | RS (Registrera välj) | D7 Arduino |
| 5 | R/W (läs eller skriv) | GND |
| 6 | E (Aktivera signal) | D6 Arduino |
| 7-14 | D0-D7 | D0-D3 - inte ansluten; D4-D7 - ansluten till stift D5-D2 på Arduino |
| 15 | A | Bakgrundsbelysningsanod, ansluten till +5V |
| 16 | K | Bakgrundsbelysningskatod, ansluten till jord via ett 220 Ohm motstånd |
Artikeln talar om hur man korrekt ansluter en LCD till Arduino, allt du behöver veta om att ansluta LCD 1602 och LCD i2c täcks.
LCD-skärmar i 1602 storlekar, skapade på basis av HD44780-kontrollern, är fortfarande en av de mest prisvärda, enkla och efterfrågade för att utveckla alla typer av elektroniska enheter.
Det är inte förvånande att de kan ses både i enkla enheter monterade bokstavligen på knäet och i mer seriösa industriella, till exempel kaffemaskiner. Det är med denna display som de mest populära Arduino-relaterade modulerna och sköldarna sätts ihop, till exempel LCD I2C-modul och LCD Keypad Shield.
I följande steg kommer vi att berätta i detalj med bilder hur du ansluter LCD-skärmen till Arduino och visar nödvändig information på skärmen.
Steg 2. LCD 1602 för Arduino
1602-skärmarna finns i två olika utföranden:
- gul bakgrundsbelysning med svarta bokstäver
- eller (detta händer mycket oftare) blå bakgrundsbelysning med vita.
Storleken på skärmarna på HD44780-kontrollern varierar mycket, men de styrs på samma sätt. De vanligaste måtten är 16 gånger 02 (det vill säga 16 tecken på två rader) eller 20 gånger 04. Själva tecknen har en upplösning på 5 gånger 8 pixlar.
De flesta skärmar stöder inte kyrilliska (med undantag för CTK-märkta skärmar). Men detta problem är delvis lösbart, och artikeln beskriver ytterligare i detalj hur man gör detta.
Skärmen har en 16-stiftskontakt för anslutning. Stiften är markerade på baksidan av brädan, det är som följer:
- 1 (VSS) – negativ strömförsörjning för regulatorn.
- 2 (VDD) – positiv strömförsörjning för regulatorn.
- 3 (VO) – inställningar för kontrastkontroll.
- 4 (RS) – registerval.
- 5 (R/W) – läsning och skrivning, i synnerhet skrivning när den är ansluten till jord.
- 6 (E) – aktivering (aktivera).
- 7–10 (DB0-DB3) – lågordningsbitar från åttabitarsgränssnittet.
- 11–14 (DB4-DB7) – de viktigaste bitarna från gränssnittet
- 15 (A) – positiv anod för strömförsörjning för bakgrundsbelysning.
- 16 (K) – negativ katod för strömförsörjning för bakgrundsbelysning.
Steg 3. Anslut LCD-skärmen
Innan du ansluter skärmen och överför information till den är det värt att kontrollera dess funktionalitet. Lägg först spänning på VSS- och VDD-styrenheten, slå på bakgrundsbelysningen (A, K) och justera sedan kontrasten.
För sådana inställningar är en 10 kOhm potentiometer lämplig, dess form är inte viktig. +5V och GND tillförs de yttre benen, och benet i mitten är anslutet till VO-stiftet.
När ström tillförs kretsen måste du uppnå den nödvändiga kontrasten; om den justeras felaktigt kommer bilden på skärmen inte att synas. För att justera kontrasten måste du "leka" med potentiometern. När kretsen är korrekt monterad och kontrasten är korrekt justerad, ska den övre raden på skärmen fyllas med rektanglar.
För att få displayen att fungera används ett speciellt bibliotek inbyggt i Arduino IDE-miljön, LiquidCrystal.h, som jag kommer att skriva om nedan. Den kan fungera i 8-bitars och 4-bitarsläge. I det första alternativet används endast de minst signifikanta och mest signifikanta bitarna ( BB0-DB7), i den andra – bara de yngre ( BB4-DB7).
Men att använda 8-bitarsläge i den här skärmen är fel beslut; det finns nästan ingen hastighetsfördel, eftersom dess uppdateringsfrekvens alltid är mindre än 10 gånger per sekund. För att visa text måste du ansluta stiften DB7, DB6, DB5, DB4, E och RS till styrenhetens stift. De kan kopplas till alla Arduino-stift, huvudsaken är att ställa in rätt sekvens i koden.
Om den önskade symbolen ännu inte finns i styrenhetens minne, kan du definiera den manuellt (upp till sju symboler totalt). Cellen i bildskärmarna har en förlängning på fem gånger åtta pixlar. Uppgiften med att skapa en symbol är att skriva en bitmask och placera dem på platser där prickarna ska lysa och nollor där de inte ska. Anslutningsschemat som diskuteras ovan är inte alltid bra, eftersom minst sex digitala utgångar används på Arduino.
Steg 4. Bypass-schema
Låt oss undersöka ett alternativ för att komma runt detta och klara oss med bara två. Vi behöver en extra omvandlarmodul för LCD till IIC/I2C. Hur den är lödd till displayen och ansluten till Arduino kan ses på bilderna nedan.
Men detta anslutningsalternativ fungerar bara med ett speciellt bibliotek, LiquidCrystal_I2C1602V1, som dock är lätt att hitta på Internet och installera, varefter du kan använda det utan problem.
Steg 4: LiquidCrystal.h Library
LiquidCrystal.h-biblioteket kan laddas ner från bibliotekssektionen på vår webbplats på denna sida eller från den officiella resursen arduino.cc. Men du kan också ladda ner från länkarna nedan:
Steg 5. Skiss (programkod)
När du har laddat ner arkivet, byt ut LiquidCrystal-mappen i biblioteksmappen i din Arduino-installationskatalog.
Du kan se en exempelskiss på:
Arkiv -> Exempel -> LiquidCrystal -> HelloWorld_SPI
Eller, om du har en meny på engelska:
Arkiv -> Exempel -> LiquidCrystal -> HelloWorld_SPI
Detta avslutar vår nästa lektion. Vi önskar er kvalitetsprojekt!
LCD skärm– en frekvent gäst i Arduino-projekt. Men i komplexa kretsar kan vi ha problemet med brist på Arduino-portar på grund av behovet av att ansluta en skärm som har många, många stift. Lösningen i denna situation kan vara I2C/IIC En adapter som ansluter en nästan standard Arduino 1602-sköld till Uno-, Nano- eller Mega-kort med endast 4 stift. I den här artikeln ska vi titta på hur du kan ansluta en LCD-skärm med ett I2C-gränssnitt, vilka bibliotek du kan använda, skriva en kort exempelskiss och titta på vanliga fel.
LCD-skärm LCD 1602är bra val att mata ut teckensträngar i olika projekt. Det är billigt, det finns olika modifieringar med olika bakgrundsbelysningsfärger, du kan enkelt ladda ner färdiga bibliotek för Arduino-skisser. Men den största nackdelen med denna skärm är det faktum att skärmen har 16 digitala stift, varav minst 6 krävs. Att använda denna LCD-skärm utan i2c lägger därför till allvarliga begränsningar för Arduino Uno eller Nano-kort. Om det inte finns tillräckligt med kontakter måste du köpa ett Arduino Mega-kort eller spara kontakter, bland annat genom att ansluta skärmen via i2c.
Kort beskrivning av LCD 1602-stift
Låt oss ta en närmare titt på LCD1602-stiften:
Var och en av stiften har sitt eget syfte:
- Jord GND;
- Strömförsörjning 5 V;
- Ställa in monitorns kontrast;
- Kommando, data;
- Skriva och läsa data;
- Gör det möjligt;
7-14. Datalinjer;
- Plus bakgrundsbelysning;
- Minus bakgrundsbelysningen.
Displayspecifikationer:
- Teckenvisningstyp, det är möjligt att ladda symboler;
- Led-lampor;
- Styrenhet HD44780;
- Matningsspänning 5V;
- Format 16x2 tecken;
- Drifttemperaturområde från -20C till +70C, lagringstemperaturområde från -30C till +80C;
- Betraktningsvinkel 180 grader.
Anslutningsschema för LCD till Arduino-kort utan i2C
Standardschemat för att ansluta en monitor direkt till en Arduino mikrokontroller utan I2C är som följer.
På grund av det stora antalet anslutna kontakter kan det hända att det inte finns tillräckligt med utrymme för att ansluta de nödvändiga elementen. Genom att använda I2C reduceras antalet ledningar till 4 och upptagna stift till 2.
Var kan man köpa LCD-skärmar och sköldar till Arduino
LCD-skärm 1602 (och version 2004) är ganska populär, så du kan enkelt hitta den både i inhemska onlinebutiker och på utländska webbplatser. Här är några länkar till de mest tillgängliga alternativen:
 LCD1602+I2C Blue Screen Module, Arduino-kompatibel
|
 En enkel LCD1602-skärm (grön bakgrundsbelysning) billigare än 80 rubel
|
 Stor LCD2004-skärm med I2C HD44780 för Arduino (blått och grönt bakgrundsbelysning)
|
 1602-skärm med IIC-adapter och blå bakgrundsbelysning
|
 En annan version av LCD1602 med en lödd I2C-modul
|
 Port IIC/I2C/TWI/SPI-adaptermodul för 1602-sköld, kompatibel med Arduino
|
 RGB bakgrundsbelyst display! LCD 16×2 + knappsats +Buzzer Shield för Arduino
|
 Shield för Arduino med knappar och skärm LCD1602 LCD 1602
|
 LCD-skärm för 3D-skrivare (Smart Controller för RAMPS 1.4, Text LCD 20×4), SD- och MicroSD-kortläsarmodul
|
Beskrivning av I2C-protokollet
Innan vi diskuterar att ansluta skärmen till Arduino via en i2c-adapter, låt oss kort prata om själva i2C-protokollet.
I2C/IIC(Inter-Integrated Circuit) är ett protokoll som ursprungligen skapades för kommunikation integrerade kretsar inuti elektronisk anordning. Utvecklingen tillhör Philips. i2c-protokollet bygger på användningen av en 8-bitars buss, som behövs för att kommunicera block i styrelektronik, och ett adresseringssystem, tack vare vilket du kan kommunicera över samma ledningar med flera enheter. Vi överför helt enkelt data till en eller annan enhet och lägger till identifieraren för det önskade elementet till datapaketen.
Mest enkel krets I2C kan innehålla en masterenhet (oftast en Arduino-mikrokontroller) och flera slavar (till exempel en LCD-skärm). Varje enhet har en adress i intervallet från 7 till 127. Det bör inte finnas två enheter med samma adress i samma krets.
Arduino-kortet stöder i2c i hårdvara. Du kan använda stift A4 och A5 för att ansluta enheter med detta protokoll.
Det finns flera fördelar med I2C-drift:
- Driften kräver endast 2 linjer - SDA (datalinje) och SCL (synkroniseringslinje).
- Anslutning av ett stort antal ledande enheter.
- Minskad utvecklingstid.
- Endast en mikrokontroller krävs för att styra hela uppsättningen enheter.
- Det möjliga antalet mikrokretsar anslutna till en buss begränsas endast av den maximala kapaciteten.
- Hög grad av datasäkerhet tack vare ett speciellt överspänningsskyddsfilter inbyggt i kretsarna.
- En enkel procedur för att diagnostisera nya fel och snabbt felsöka fel.
- Bussen är redan integrerad i själva Arduino, så det finns inget behov av att utveckla ett extra bussgränssnitt.
Brister:
- Det finns en kapacitiv gräns på linjen - 400 pF.
- Svårt att programmera en I2C-styrenhet om det finns flera olika enheter på bussen.
- Med ett stort antal enheter blir det svårt att isolera ett fel om en av dem av misstag blir låg.
i2c-modul för LCD 1602 Arduino
Det snabbaste och bekvämaste sättet att använda en i2c-skärm i Arduino är att köpa en färdig skärm med inbyggt protokollstöd. Men det finns inte särskilt många av dessa skärmar och de är inte billiga. Men ett stort antal olika standardskärmar har redan producerats. Därför är det mest prisvärda och populära alternativet idag att köpa och använda en separat I2C-modul - en adapter som ser ut så här:
På ena sidan av modulen ser vi i2c-stift - jord, ström och 2 för dataöverföring. På den andra adaptern ser vi externa strömkontakter. Och naturligtvis har kortet många stift med vilka modulen löds fast till standardskärmstiften.
i2c-utgångar används för att ansluta till Arduino-kortet. Vid behov ansluter vi extern ström för bakgrundsbelysning. Med den inbyggda trimmern kan vi ställa in anpassade kontrastvärden J
På marknaden kan du hitta LCD 1602-moduler med redan lödda adaptrar, deras användning är förenklad så mycket som möjligt. Om du köpte en separat adapter måste du först löda den till modulen.
Ansluter LCD-skärmen till Arduino via I2C
För att ansluta behöver du själva Arduino-kortet, en display, en breadboard, anslutningskablar och en potentiometer.
Om du använder en speciell separat i2c-adapter måste du först löda den till skärmmodulen. Det är svårt att göra ett misstag där, du kan följa detta schema.
En LCD-skärm med i2c-stöd är ansluten till kortet med hjälp av fyra ledningar - två ledningar för data, två ledningar för ström.
- GND-stiftet ansluts till GND på kortet.
- VCC-stiftet är på 5V.
- SCL ansluts till stift A5.
- SDA är ansluten till stift A.
Och det är allt! Inga nät av trådar, som är mycket lätta att trassla in i. Samtidigt kan vi helt enkelt anförtro all komplexitet med att implementera i2C-protokollet till bibliotek.
Bibliotek för att arbeta med i2c LCD-skärm
För att interagera med Arduino och LCD 1602 via I2C-bussen behöver du minst två bibliotek:
- Wire.h-biblioteket för att arbeta med I2C ingår redan i standarden Arduino program ID.
- LiquidCrystal_I2C.h-biblioteket, som innehåller en mängd olika kommandon för att styra monitorn via I2C-bussen och låter dig göra skissen enklare och kortare. Du måste ytterligare installera biblioteket Efter att ha anslutit skärmen måste du ytterligare installera LiquidCrystal_I2C.h-biblioteket
Efter att ha kopplat alla nödvändiga bibliotek till skissen skapar vi ett objekt och kan använda alla dess funktioner. För att testa, låt oss ladda följande standardexempelskiss.
#omfatta
Beskrivning av funktioner och metoder för LiquidCrystal_I2C-biblioteket:
- home() och clear() - den första funktionen låter dig gå tillbaka markören till början av skärmen, den andra gör detsamma, men tar samtidigt bort allt som fanns på skärmen innan.
- write(ch) – låter dig skriva ut ett enda tecken ch på skärmen.
- cursor() och noCursor() – visar/döljer markören på skärmen.
- blink() och noBlink() – markören blinkar/blinkar inte (om dess visning var aktiverad tidigare).
- display() och noDisplay() – låter dig ansluta/inaktivera displayen.
- scrollDisplayLeft() och scrollDisplayRight() – rullar skärmen ett tecken åt vänster/höger.
- autoscroll() och noAutoscroll() – låter dig aktivera/avaktivera autoscroll-läget. I det här läget skrivs varje ny karaktär på samma plats och ersätter det som tidigare skrivits på skärmen.
- leftToRight() och rightToLeft() – Ställer in riktningen för den visade texten – vänster till höger eller höger till vänster.
- createChar(ch, bitmapp) – skapar ett tecken med koden ch (0 – 7), med hjälp av en uppsättning bitmappsbitmappar för att skapa svarta och vita punkter.
Alternativt bibliotek för att arbeta med i2c-skärm
I vissa fall kan fel uppstå när det angivna biblioteket används med enheter utrustade med PCF8574-kontroller. I det här fallet kan LiquidCrystal_PCF8574.h-biblioteket föreslås som ett alternativ. Den utökar LiquidCrystal_I2C, så det borde inte vara några problem att använda den.
Problem med att ansluta i2c lcd-skärm
Om du inte ser något meddelande på displayen efter att ha laddat upp skissen, prova följande steg.
Först kan du öka eller minska skärmens kontrast. Ofta är tecken helt enkelt inte synliga på grund av kontrast- och bakgrundsbelysningsläget.
Om detta inte hjälper, kontrollera då om kontakterna är korrekt anslutna och om bakgrundsbelysningen är ansluten. Om du använde en separat i2c-adapter, kontrollera igen kvaliteten på lödningen av kontakterna.
En annan vanlig orsak till att text saknas på skärmen kan vara en felaktig i2c-adress. Försök först att ändra enhetens adress i skissen från 0x27 0x20 eller till 0x3F. Olika tillverkare kan ha olika standardadresser programmerade. Om detta inte hjälper kan du köra i2c-skannerskissen, som skannar alla anslutna enheter och bestämmer deras adress med brute force. Ett exempel på en i2c-skannerskiss.
Om skärmen fortfarande inte fungerar, försök att lossa adaptern och ansluta LCD-skärmen som vanligt.
Slutsats
I den här artikeln tittade vi på huvudproblemen med att använda en LCD-skärm i komplexa Arduino-projekt, när vi behöver spara gratis pins på tavlan. En enkel och billig i2c-adapter gör att du kan ansluta en 1602 LCD-skärm som bara tar upp 2 analoga stift. I många situationer kan detta vara mycket viktigt. Priset för bekvämlighet är behovet av att använda en extra modul - en omvandlare och ett bibliotek. Enligt vår åsikt är detta inte ett högt pris att betala för bekvämlighet och vi rekommenderar starkt att du använder den här funktionen i projekt.
Vad är en integrerad del av ett stort antal elektroniska enheter? Naturligtvis sätt för indikation och grafisk utdata av data. Det är alltid bekvämare och trevligare för användaren när resultatet av "smartboxen" kan ses visuellt. Därför kommer vi idag att ansluta en display till STM32 för att visa text och siffror. Hjälten i våra experiment kommer att vara en ganska populär display från Winstar. Ett viktigt förtydligande framkom förresten i kommentarerna att metodiken i princip är densamma för alla skärmar utifrån HD44780. Tack till JekaKey för det viktiga tillägget)
Först måste displayen anslutas till styrenheten. Ladda ner databladet och leta efter WH1602 pinout. Titta här:
Som du vet, display WH1602 har 16 stift. Låt oss titta på var och en separat...
Pins Vss, Vdd och K måste anslutas till jord och ström, det vill säga precis som anges i tabellen, det finns inga överraskningar och inget att diskutera)
Stift nummer 3 används för att justera kontrasten - om vi applicerar +5V där ser vi absolut ingenting, och om vi kortsluter stiftet till jord kommer vi att beundra två rader med svarta rutor 😉 Naturligtvis passar detta inte oss , så vi måste hänga en potentiometer (motstånd) där med variabelt motstånd) för att justera kontrasten. Bästa synlighet av tecken tillhandahålls av en spänning på 0,5-0,7 V vid denna displaystift.
RS-stiftet är redan ett stift som vi själva kommer att styra med hjälp av en mikrokontroller. En låg spänningsnivå (0) på detta stift betyder att ett kommando nu följer, en hög nivå (1) betyder att det nu kommer att finnas data som ska skrivas till displayminnet.
Pin R/W - det är tydligt här, antingen läser vi data (visa upptagen flagga, till exempel), i det här fallet finns det 1 på denna pin, eller så skriver vi kommandot/data till displayen, då har vi 0 här.
DB7 – DB0 – databuss, och det säger allt)
Stift E är den så kallade Enable-signalen. Det är vad han behövs för. För att arbeta med displayen - registrera data eller utfärda ett kommando - måste vi ge en positiv puls till denna stift. Det vill säga, proceduren kommer att se ut så här:
- På stift RS, R/W, DB7 - DB0 - de nödvändiga signalerna som motsvarar vårt kommando.
- Vi levererar en till stift E.
- Zhdems (enligt databladet - minst 150 ns)
- Vi tillämpar en låg nivå (0) på stift E.
Du måste sätta 4,2 V på A/Vee-benet för att driva skärmens bakgrundsbelysning.
Så här sker kommunikation med WH1602-skärmen.
Vi har listat ut att ansluta WH1602, men innan vi går vidare till exemplet, låt oss titta på vilka kommandon vår display i allmänhet förstår. För att göra detta går vi in i databladet och hittar en intressant tabell:
Alla kommandon och signaler som ska finnas på motsvarande stift på WH1602 för varje specifikt kommando beskrivs här. Vi vill till exempel rensa displayen, vi tittar på tabellen och här är kommandot vi behöver! Rensa display!
Vi tillämpar nollor på stiften RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 och en till stift DB0. Klart! Vad händer härnäst? Det stämmer, en på stift E, vänta sedan ett tag och sänk E till noll igen. Det är allt, displayen rensas 😉 Precis innan du kör nästa kommando måste du pausa, vilket anges i databladet för varje kommando. Det skulle vara mer effektivt att polla upptagetflaggan; så snart den återställs till 0 kan du fortsätta arbeta. Det finns också ett speciellt kommando för att läsa denna flagga, så allt är klart med denna) Låt oss gå vidare...
Och i själva verket är allt med teorin, du kan redan försöka skriva något. För att göra det enklare att arbeta med displayen gjorde jag ett litet bibliotek, nu ska vi se hur det kan användas. Först, ladda ner
Vi får 2 filer till vårt förfogande, MT_WH1602.c och MT_WH1602.h. Vi river av den andra, här måste vi välja stiften och den styrenhet som används.
Förresten, min skärm är ansluten så här:
RS-PC2
R/W – PB10
E–PB14
DB7–PD2
DB6–PC12
DB5–PA8
DB4–PA10
DB3–PA15
DB2–PD11
DB1–PA3
DB0–PA5
Öppna filen MT_WH1602.h:
| #define PLATTFORM (STM32F10x) |
Välj sedan mikrokontrollerstiften som skärmen är ansluten till. Låt oss först ställa in vilka portar vi använder. När jag ansluter använder jag GPIOA, GPIOB, GPIOC och GPIOD, vi skriver:
På samma sätt för andra mikrokontrollerben.
Vi är klara med installationen, låt oss fortsätta) För att anropa kommandona som ges i början av artikeln, innehåller MT_WH1602.c-filen följande funktioner (de är namngivna efter namnen på kommandona, så jag tror att allt är klart) :
| void MT_WH1602_ClearDisplay(void ) ; void MT_WH1602_ReturnHome(void ) ; void MT_WH1602_EntryModeSet (bool ID-adress, 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-adress) ; void MT_WH1602_SetDDRAMAddress (uint8_t-adress) ; bool MT_WH1602_ReadBusy(void) ; void MT_WH1602_WriteData(uint8_t data) ; |
För vissa kommandon måste vi skicka parametrar till funktionen, till exempel:
| void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit); |
Låt oss titta på kommandotabellen:
Vi ser att kommandot Display ON/OFF inte bara slår på/stänger av displayen, utan även aktiverar/avaktiverar markören och markörblinkningen. I databladet är dessa kommandobitar betecknade som D, C och B, och vi skickar dem som parametrar till funktionen. Om vi behöver slå på displayen och markören, men inaktivera markörblinkningen, anropar vi kommandot enligt följande:
MT_WH1602_DisplayOnOff(1, 1, 0);
I allmänhet är allt enkelt 😉
Kort sagt, vi skapar nytt projekt, lägg till ett bibliotek för att arbeta med WH1602-skärmen, skapa en tom .c-fil och börja fylla den med kod:
| // Inkludera biblioteksfilen#inkludera "MT_WH1602.h" /*******************************************************************/ int main(void) ( // Ring initieringsfunktionen, vi kan inte klara oss utan den =)() ; // Nu måste vi göra den initiala skärmkonfigurationen // Dokumentation och Internet rekommenderar att du gör detta ;) 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) ; // Till exempel tog jag de första fördröjningsvärdena som kom att tänka på) // I allmänhet måste du kontrollera displayens upptagetflagga // Låt oss nu visa något, som namnet på vår webbplats 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) ; medan (1 ) ( __NOP() ; ) ) /*******************************************************************/ |
Klart, låt oss kolla) 
Som du kan se fungerar allt korrekt)
Förresten, jag tappade på något sätt frågan om vad jag skulle skriva på displayen för att visa den eller den karaktären. Här är plattan från databladet: 
Så för att bestämma vilket värde som ska skrivas in i displayminnet måste du ta siffrorna som är skrivna överst och till vänster i den här tabellen för en specifik symbol. Till exempel symbolen "A". Låt oss se - den här symbolen motsvarar kolumn 0100 (0x4) och rad 0001 (0x1). Det visar sig att för att visa symbolen "A" måste du skriva värdet 0x41 i displayen.
Det var det nu =) Vi har löst anslutningen och driften av WH1602-skärmen, så vi ses snart!
P.S. När jag arbetade med biblioteket testade jag inte funktionen att läsa upptagetflaggan, så om något plötsligt inte fungerar som det ska, skriv så kommer vi att reda ut det)
Ibland står vi inför problemet med att mata ut olika information från Arduino till omvärlden. Ofta är det omöjligt, obekvämt och olönsamt att använda en serieport.
En teckendisplay är ett av de enklaste och billigaste sätten att visa information eftersom den har en egen mikrokontroller som lagrar de kodade tecknen. Detta system förenklar användningen av dessa displayer, men begränsar samtidigt deras användning till endast utdata textinformation, till skillnad från grafiska displayer.
I exemplet kommer vi att titta på Winstar wh1602l1-skärmen, en av de vanligaste skärmarna på hd44780-kontrollern. Dessutom kan du ansluta LCD 2004 och andra liknande.
De första två siffrorna anger antalet tecken per rad och den andra antalet rader, så den valda displayen har 2 rader med 16 tecken.
Denna anslutningsmetod innebär att man ockuperar minst 6 portar på Arduino-mikrokontrollern. Vid behov kan du ansluta 1602-textdisplayen via I2C-gränssnittet (2 portar).
Av de ytterligare element vi behöver variabelt motstånd, för att kontrollera kontrasten. I övrigt ansluts allt enligt diagrammet, enligt databladet och de valda Arduino-utgångarna i programmet.
Pin 15 och 16 på displayen är ansvariga för bakgrundsbelysningen; den kan stängas av eller ljusstyrkan kan justeras automatiskt när du ansluter ett fotomotstånd till Arduino som en ljusstyrkesensor.
I vårt exempel kommer vi att läsa data från serieporten och visa dem på displayen:
#omfatta
Du kan komplicera koden och mata ut realtidsklockan DS1307 på Arduino till din LCD1602.
Låt oss nu titta närmare på alla funktioner i biblioteket Flytande kristall:
Det första och viktigaste är att med det här biblioteket kan du inte visa ryska bokstäver, även om displayen har dessa tecken i minnet. Detta problem kan lösas antingen av andra bibliotek eller genom att skriva värden med hexadecimal kod.
lcd.print();- den enklaste och mest använda, används för att visa information.
lcd. klar(); - används för att rengöra displayen.
lcd.setCursor(x, y); - placerar markören på en specifik plats.
X – byte av position i linjen
Y – linjebyte
Till exempel, lcd.setCursor(0, 0); detta är den övre vänstra cellen.
lcd.home(); - placerar markören i position 0, 0
lcd.home(); = lcd.setCursor(0, 0);
lcd. scrollDisplayLeft(); - skift vänster
lcd. scrollDisplayRight(); - skift höger
Lcd.createChar(namn, array); - skapa din egen skylt.
Gradtecknet ser till exempel ut så här:
Celc = (B00111, B00101, B00111, B00000, B00000, B00000, B00000, B00000);
