Tutoriale Arduino: crearea unei linii rampante folosind un microcontroler. Tutoriale Arduino: Creați o linie de defilare utilizând un microcontroler 1602 Linie de defilare afișată

02.07.2020 Siguranță

Toată lumea a fost de mult obișnuită cu faptul că fiecare dispozitiv electronic are un ecran cu care oferă unei persoane toate informațiile utile. Playerul MP3 arată numele piesei care este redată, telecomanda quadcopterului afișează telemetria zborului, chiar și mașina de spălat afișează timpul până la sfârșitul spălării, iar un smartphone conține în general un întreg desktop al unui computer personal! Cel mai probabil, următorul tău dispozitiv va folosi și un dispozitiv mic de afișare 🙂 Să încercăm să facem un ceas electronic simplu! Și ca tablou de bord folosim un LCD 1602 cu caractere larg răspândit și ieftin. La fel ca în imagine: Pe lângă 16x2, un afișaj de caractere 20x4 (patru linii a câte 20 de caractere fiecare), precum și un afișaj grafic cu o rezoluție de 128x64 pixeli, este considerat destul de popular. Iată-le în imagini:

1. Conectarea caracterului LCD 1602

Ecranul 1602 are 16 pini. Ele sunt de obicei numerotate de la stânga la dreapta când te uiți la el ca în imagine. Uneori sunt semnați pini, cum ar fi: DB0, DB1, EN etc. Și uneori indică doar numărul PIN. În orice caz, lista de pini este întotdeauna aceeași: 1 - "GND", masă (minus sursa de alimentare); 2 - "Vcc", alimentare + 5V; 3 - "VEE", contrast; 4 - "RS" , selectarea registrului; 5 - "R / W", direcția de transfer de date (citire / scriere); 6 - "EN", sincronizare; 7-14 - "DB0", "DB1", .., "DB7" - magistrală de date 15 - anod de iluminare din spate (+5V); 16 - catod de iluminare din spate (masa). Liniile VEE, RS și patru linii de date DB4, DB5, DB6, DB7 sunt conectate la pinii digitali ai controlerului. Conectați linia "R / W" la "pământul" controlerului (deoarece avem nevoie doar de funcția de scriere în memoria afișajului). Nu vom conecta lumina de fundal deocamdată, presupun că vă puteți da seama cu ușurință singur cu asta 🙂 Schema de conectare a afișajului la Arduino Uno

Aspectul aspectului

Pentru orice eventualitate, tot sub formă de farfurie:

LCD 1602	1	2	4	6	11	12	13	14	15	16
Arduino Uno	GND	+ 5V	4	5	6	7	8	9	+ 5V	GND

2. Programare „Bună, lume!”

Pentru a lucra cu afișaje LCD de diferite dimensiuni și tipuri, există o bibliotecă specială în editorul Arduino IDE Cristal lichid... Pentru a include biblioteca, scrieți următoarea expresie în prima linie a programului nostru: #include În continuare, trebuie să indicăm ce pini Arduino am folosit pentru a conecta afișajul. Vom indica aceste informații la inițializarea modulului: LiquidCrystal lcd (4, 5, 6, 7, 8, 9); Aici primele două argumente sunt pinii RS și EN, iar restul de patru sunt liniile magistralei de date DB4-DB7 . În continuare, specificăm dimensiunea afișajului folosind comanda „begin”: lcd.begin (16, 2); Permiteți-mi să vă reamintesc că afișajul nostru are două rânduri, câte 16 caractere fiecare. În cele din urmă, avem nevoie de o funcție simplă „printare” pentru a afișa textul. Ieșirea care utilizează această funcție va arăta ca această expresie binecunoscută: lcd.print ("Bună ziua, lume!"); Programul complet va arăta astfel: #include LCD cristal lichid (4, 5, 6, 7, 8, 9); void setup () (lcd.begin (16, 2); lcd.print ("Bună, lume!");) void loop () () Încărcați-l pe Arduino Uno și vedeți ce se întâmplă pe afișaj. Există trei situații principale 🙂 1) Afișajul va afișa „Bună, lume!”. Așa că ai conectat totul corect, iar contrastul s-a dovedit cumva ca prin minune a fi configurat corect inițial. Ne bucurăm și trecem la capitolul următor. 2) Afișajul va afișa un rând de dreptunghiuri negre - este necesară ajustarea contrastului! De aceea am adăugat un potențiometru cu buton la circuit. O răsucim de la o margine la alta, până când pe display apare o inscripție clară. 3) Două rânduri de dreptunghiuri negre. Cel mai probabil, ai greșit ceva când te-ai conectat. Verificați toate firele de trei ori. Dacă nu găsiți o eroare, cereți pisicii să o verifice!

3. Programăm ceasul

Acum că afișajul funcționează exact, să încercăm să transformăm dispozitivul nostru simplu într-un adevărat ceas electronic. Atenţie! Pentru a afișa ora, avem nevoie de biblioteca „Timp”. Dacă nu este încă instalat, puteți descărca arhiva din link. Să-l includem: #include Apoi setăm data și ora curentă folosind funcția „setTime”: setTime (23, 59, 59, 12, 31, 2015); Aici totul este clar: ore, minute, secunde, lună, zi, an. Pentru a afișa data, folosim o mulțime de funcții:

year () - ne va returna anul;
luna () - luna;
zi () - zi;
oră () - oră;
minute () - va returna minutul;
secundă () - secundă.

Acum să fim atenți la următorul fapt. Dacă numărăm numărul de caractere dintr-o notație tipică de dată: „31/12/2015 23:59:59”, obținem 19. Și avem doar 16! Cu toate acestea, nu se încadrează într-o singură linie. O altă funcție utilă, setCursor, poate fi folosită pentru a rezolva problema. Această funcție setează cursorul în poziția dorită. De exemplu: lcd.setCursor (0,1); Plasează cursorul la începutul celei de-a doua rânduri. Cursorul este poziția caracterului de la care va începe textul cu următoarea comandă „printare”. Vom folosi această funcție pentru a afișa data pe primul rând și ora pe al doilea. Odată cu ieșirea datei și orei, totul este acum clar. Au rămas lucruri de rutină. De exemplu, după fiecare umplere a afișajului, îl vom șterge cu funcția „clear ()”: lcd.clear (); Și, de asemenea, nu are sens să afișăm datele pe afișaj mai mult de o dată pe secundă, așa că ne vom opri timp de 1000 de milisecunde între două iterații. Deci, adunând totul împreună, obținem următorul program: #include #include LCD cristal lichid (4, 5, 6, 7, 8, 9); void setup () (lcd.begin (16, 2); setTime (7,0,0,1,10,2015); // 7 am, 10 ianuarie 2015) void loop () (lcd.clear (); lcd .print (ziua ()); lcd.print ("."); lcd.print (luna ()); lcd.print ("."); lcd.print (an ()); lcd.setCursor (0 , 1); lcd.print (oră ()); lcd.print (":"); lcd.print (minut ()); lcd.print (":"); lcd.print (secunda ()); întârziere ( 1000);) Încărcați schița în Arduino Uno și urmăriți progresul ceasului! 🙂 Pentru a consolida cunoștințele acumulate, recomand să facem upgrade ceasului nostru la un ceas cu alarmă cu drepturi depline. Tot ce trebuie să faceți este să adăugați câteva butoane și un sonerie 🙂

Pentru a lucra cu afișaje grafice simbolice, vă sugerăm să utilizați biblioteca LiquidCrystal, care este inclusă în setul standard Arduino IDE și este proiectată să funcționeze pe o interfață paralelă de 8 biți (4 biți). Dacă afișajul dvs. este conectat la Arduino prin magistrala I2, atunci trebuie să instalați biblioteca LiquidCrystal_I2C (cele mai multe dintre funcții repetă funcțiile primei biblioteci).

Afișaje acceptate:

Afişa	Conectare și inițializare
LCD1602 - afișaj de caractere (16x02 caractere),	#include [ , 8 , 9 , 10 , 11 ]); void setup () ( lcd.begin (16, 2);} // Explicație: void setup () ( OBJECT.begin (NUMBER_COLUMNS, NUMBER_LINE); ) OBIECTUL LiquidCrystal (RS, E, D0, D1, D2, D3, D4, D5, D6, D7);
cu interfață I2C (albastru)	#include #include LiquidCrystal_I2C LCD (0x27 sau 0x3F, 16 , 2); void setup () ( lcd.init (); } // Explicație:
LCD1602 I2C - afișaj de caractere (16x02 caractere), cu interfață I2C (verde)	#include #include LiquidCrystal_I2C LCD (0x27 sau 0x3F, 16 , 2); void setup () ( lcd.init (); } // Explicație: OBIECTUL LiquidCrystal_I2C (ADDRESS_I2C, NUMBER_COLUMNS, NUMBER_LINE); // ADDRESS_I2C poate fi fie 0x27, fie 0x3F
LCD2004 - afișaj de caractere (20x04 caractere), cu interfata paralela (albastru)	#include LCD cristal lichid (2, 3, 4, 5, 6, 7[ , 8 , 9 , 10 , 11 ]); void setup () ( lcd.begin (20, 4);} // Explicație: OBIECTUL LiquidCrystal (RS, E, D4, D5, D6, D7); void setup () (OBJECT.begin (NUMĂR_ DE COLONI, NUMĂR_ DE RÂNDURI);) // Dacă sunt folosite 8 fire ale magistralei de date, atunci le indicăm pe toate OBIECTUL LiquidCrystal (RS, E, D0, D1, D2, D3, D4, D5, D6, D7);
LCD2004 I2C - afișaj de caractere (20x04 caractere), cu interfață I2C (albastru)	#include #include LiquidCrystal_I2C LCD (0x27 sau 0x3F, 20 , 4); void setup () ( lcd.init (); } // Explicație: OBIECTUL LiquidCrystal_I2C (ADDRESS_I2C, NUMBER_COLUMNS, NUMBER_LINE); // ADDRESS_I2C poate fi fie 0x27, fie 0x3F

# 1 Exemplu

Afișăm inscripția pe display-ul LCD1602 conectat prin magistrala I2C. Pentru a lucra cu afișajul LCD2004, trebuie să schimbați a treia linie la LiquidCrystal_I2C lcd (0x27,20,4);

#include // Conectam biblioteca pentru lucrul cu display-ul LCD prin magistrala I2C LiquidCrystal_I2C lcd (0x27,16,2); // Declarați obiectul bibliotecă, specificând parametrii de afișare (adresa I2C = 0x27, număr de coloane = 16, număr de rânduri = 2) // Dacă inscripția nu apare, înlocuiți adresa 0x27 cu 0x3F void setup () (// lcd.init (); // Inițiați lucrul cu afișajul LCD lcd.backlight (); // Porniți iluminarea de fundal a afișajului LCD lcd.setCursor (0, 0); // Setați cursorul în poziție (0 coloană, 0 rând) ) lcd.print ("LCD"); // Afișează textul "LCD", pornind de la poziția setată a cursorului lcd.setCursor (0, 1); // Setați cursorul în poziția (0 coloană, 1 linie) lcd .print ("www.iarduino.ru"); // Afișăm textul "www.iarduino.ru", începând de la poziția setată a cursorului) // // void loop () () // Codul din interiorul buclei funcția este executată în mod constant. Dar din moment ce afișăm text static, trebuie doar să-l afișăm o dată la pornire, fără a folosi codul buclă

# 2 Exemplu

Afișăm inscripția pe afișajul LCD1602 conectat printr-o magistrală paralelă pe 4 biți. Pentru a lucra cu afișajul LCD2004, trebuie să schimbați a 5-a linie la lcd.begin (20, 4);

#include // Conectați biblioteca LiquidCrystal pentru a lucra cu afișajul LCD LiquidCrystal lcd (2,3,4,5,6,7); // Declarăm obiectul bibliotecă, indicând pinii afișajului (RS, E, D4, D5, D6, D7) // Dacă sunt folosite 8 fire ale magistralei de date, atunci indicăm (RS, E, D0, D1, D2 , D3, D4, D5, D6, D7) void setup () (// lcd.begin (16, 2); // Inițiați lucrul cu afișajul LCD, specificând numărul (coloane, rânduri) lcd.setCursor (0, 0); // Setați cursorul pe poziția (coloana 0, rând 0) lcd.print ("LCD2004"); // Afișează textul "LDC1602" începând de la poziția setată a cursorului lcd.setCursor (0, 1); // Setați cursorul pe poziția (0 coloană, 1 rând) lcd.print ("www.iarduino.ru"); // Afișați textul "www.iarduino.ru", începând de la poziția setată a cursorului) // / / void loop () () // Codul din interiorul funcției de buclă este executat constant... Dar din moment ce afișăm text static, trebuie doar să-l afișăm o dată la pornire, fără a folosi codul buclă

# 3 Exemplu

Afișăm inscripția „Limba rusă” pe afișajul LCD1602 conectat prin magistrala I2C:

# 4 Exemplu

Afișăm timpul scurs după pornire pe afișajul LCD1602 conectat prin magistrala I2C:

#include // Conectăm biblioteca pentru lucrul cu magistrala I2C #include // Conectam biblioteca pentru lucrul cu display-ul LCD prin magistrala I2C LiquidCrystal_I2C lcd (0x27,16,2); // Declarați obiectul bibliotecă, specificând parametrii de afișare (adresa I2C = 0x27, număr de coloane = 16, număr de rânduri = 2) // uint8_t tim_D, tim_H, tim_M, tim_S; // Declara variabile pentru a stoca zile, ore, minute și secunde. uint32_t tim; // Declara o variabilă pentru a stoca timpul total scurs de la pornire. // Dacă inscripția nu apare, înlocuiți adresa 0x27 cu 0x3F void setup () (// lcd.init (); // Inițiați lucrul cu afișajul LCD lcd.backlight (); // Porniți iluminarea de fundal LCD) // // bucla nulă () (// // Obțineți timpul scurs de la început: // tim = millis () / 1000; // Obțineți numărul total de secunde (maximum 4 „294” 967 sec ≈ 49,7 zile) tim_S = tim% 60 ; // Obțineți secundele: restul tuturor secundelor împărțit la minut (60 sec). Tim = (tim-tim_S) / 60; // Obțineți numărul total de minute. Tim_M = tim% 60 ; // Obțineți minutele: restul tuturor minutelor pe oră (60 minute). tim = (tim-tim_M) / 60; // Obțineți numărul total de ore tim_H = tim% 24; // Obțineți orele: restul a tuturor orelor împărțit la zi (24 de ore). tim_D = (tim-tim_H) / 24; // Obțineți numărul total de zile. // Imprimați timpul scurs după începere: // dacă (milis ()% 1000<100){ // Условие выполняется в течении 100 первых миллисекунд каждой новой секунды. delay(100); lcd.setCursor(0, 0); // Устанавливаем курсор в позицию (0 столбец, 0 строка). lcd.print("Days: "); // Выводим текст. if(tim_D<10){lcd.print(0);} // Выводим 0 перед количеством дней. lcd.print(tim_D); // Выводим количество дней. lcd.setCursor(0, 1); // Устанавливаем курсор в позицию (0 столбец, 1 строка) lcd.print("Time: "); // Выводим текст. if(tim_H<10){lcd.print(0);} // Выводим 0 перед количеством часов. lcd.print(tim_H); // Выводим количество часов. lcd.print(":"); // Выводим символ. if(tim_M<10){lcd.print(0);} // Выводим 0 перед количеством минут. lcd.print(tim_M); // Выводим количество минут. lcd.print(":"); // Выводим символ. if(tim_S<10){lcd.print(0);} // Выводим 0 перед количеством секунд. lcd.print(tim_S); // Выводим количество секунд. } // } //

Funcții comune bibliotecilor LiquidCrystal și LiquidCrystal_I2C:

începe ( cols, rânduri, ); - Inițializarea afișajului prin specificarea numărului de coloane, rânduri și a mărimii caracterului.
clar ();- Șterge afișajul cu cursorul la 0.0 (Durează mult timp!).
Acasă ();- Setarea cursorului pe poziția 0,0 (Ia mult timp!).
afișaj ();- Pornirea rapidă a afișajului (fără modificarea datelor din RAM).
noDisplay ();- Opriți rapid afișajul (fără a schimba datele din RAM).
clipi ();- Porniți cursorul intermitent (cu o frecvență de aproximativ 1 Hz).
nu Blink ();- Opriți cursorul care clipește.
cursor ();- Activați sublinierea cursorului.
noCursor ();- Dezactivați sublinierea cursorului.
scrollDisplayLeft ();- Derulează afișajul spre stânga. Shift display coordonează o coloană la stânga (fără a schimba RAM).
scrollDisplayRight ();- Derulează afișajul spre dreapta. Shift display coordonează o coloană la dreapta (fără a schimba RAM).
de la stânga la dreapta ();- Indică pe viitor deplasarea poziției cursorului, după afișarea următorului caracter, cu o coloană la dreapta.
de la dreapta la stanga ();- Indică pe viitor deplasarea poziției cursorului, după afișarea următorului caracter, cu o coloană la stânga.
noAutoscroll ();- Indică justificarea suplimentară a textului din stânga poziției cursorului (ca de obicei).
autoscroll ();- Indică o justificare suplimentară la dreapta a textului din poziția cursorului.
createChar ( num, matrice ); - Scrierea unui caracter personalizat pe afișajul CGRAM sub numărul specificat.
setCursor ( col, rând ); - Setarea cursorului în poziția indicată de numărul coloanei și al liniei.
imprimare ( text ); - Afișați text, simboluri sau numere pe ecranul de afișare. Sintaxa este similară cu funcția cu același nume din clasa Serial.

Funcții implementate numai în biblioteca LiquidCrystal_I2C:

init ();- Inițializarea afișajului. Ar trebui să fie prima comandă a bibliotecii LiquidCrystal_I2C după crearea obiectului. De fapt, această funcție se află și în biblioteca LiquidCrystal, dar în acea bibliotecă este apelată automat (implicit) atunci când obiectul este creat.
iluminare din spate ();- Porniți iluminarea de fundal a afișajului.
nuBacklight ();- Opriți iluminarea de fundal a afișajului.
setBacklight ( steag ); - Controlul luminii de fundal (true - activare / fals - dezactivare), utilizat în locul funcțiilor noBacklight și backlight.

Conexiune:

// Pentru magistrala I2C: #include #include LiquidCrystal_I2C lcd ( abordare , col , rând ); void setup () ( lcd.init (); }	Parametru: abordare: Afișează adresa pe magistrala I2C - 0x27 sau 0x3F col: rând:
// Pentru o magistrală paralelă cu 4 fire: #include Cristal lichid lcd ( Rs , E , D4 , D5 , D6 , D7 ); void setup () ( lcd.begin ( col , rând ); }	Parametru: RS: Pinul Arduino # la care este conectat pinul RS E: Pinul Arduino # la care este conectat pinul E D0 ... D3: Numărul de pini Arduino la care sunt conectați pinii D0-D3 D4 ... D7: Numărul de pini Arduino la care sunt conectați pinii D4-D7 col: numărul de coloane implementat de afișaj rând: numărul de linii implementate de afișaj
// Pentru o magistrală paralelă cu 8 fire: #include Cristal lichid lcd ( Rs , E , D0 , D1 , D2 , D3 , D4 , D5 , D6 , D7 ); void setup () ( lcd.begin ( col , rând ); }
începe ( col , rând , ); Inițializarea afișajului prin specificarea dimensiunilor și simbolurilor ecranului.	Parametru: col: numărul de coloane implementat de afișaj rând: numărul de linii implementate de afișaj mărimea: dimensiunea caracterelor, specificată de o constantă: LCD_5x8DOTS (implicit) sau LCD_5x10DOTS

/ * Pentru magistrala I2C: * / #include // Conectăm biblioteca pentru lucrul cu magistrala I2C #include // Conectăm biblioteca pentru lucrul cu afișajul LCD prin magistrala I2C LiquidCrystal_I2C lcd (0x3F, 20.4); // Declarați obiectul bibliotecă, specificând parametrii de afișare (adresa I2C = 0x3F, număr de coloane = 20, număr de rânduri = 4) // void setup () (// lcd.init (); // Inițiază lucrul cu LCD display lcd.backlight (); // Porniți iluminarea de fundal a afișajului LCD ... // Afișează informații care ar trebui să fie afișate la pornire) // // void loop () () // ... // Afișează informații care ar trebui să se schimbe în funcție de algoritmul codului dvs.) // / * Pentru magistrala paralelă cu 4 fire: * / #include // Conectați biblioteca LiquidCrystal pentru a lucra cu afișajul LCD LiquidCrystal lcd (2,3,4,5,6,7); // Declarăm obiectul bibliotecă, indicând pinii afișajului (RS, E, D4, D5, D6, D7) // Dacă sunt folosite 8 fire ale magistralei de date, atunci indicăm (RS, E, D0, D1, D2 , D3, D4, D5, D6, D7) void setup () (// lcd.begin (16, 2); // Inițiați lucrul cu afișajul LCD, specificând numărul (coloane, rânduri) ... // Afișare informații care ar trebui să fie afișate la pornire) / / // void loop () () // ... // Afișează informații care ar trebui să se modifice în funcție de algoritmul codului dvs.) //

Funcții de control a afișajului:

afișaj (); Pornește afișajul după ce a fost oprit de funcția noDisplay.	Notă: Funcția este executată rapid și fără modificări ale RAM-ului afișajului.
noDisplay (); Oprește afișajul. Datele de pe afișaj nu vor fi afișate până când nu este apelată funcția de afișare, dar nu vor fi șterse din memoria RAM, iar după ce funcția de afișare este apelată, acestea vor fi afișate din nou.	Notă: Funcția este executată rapid și fără modificări ale RAM-ului afișajului.
scrollDisplayLeft (); Schimbă coordonatele de afișare cu o coloană la stânga.
scrollDisplayRight (); Schimbă coordonatele de afișare cu o coloană la dreapta. Apelul constant al acestei funcții va crea efectul unei linii rampante. Coordonatele sunt deplasate atât pentru informațiile disponibile pe afișaj, cât și pentru informațiile care vor fi afișate ulterior.	Notă: Funcția este efectuată fără modificarea memoriei RAM de afișare. Dacă apelați funcția de 40 de ori la rând, atunci coordonatele se vor întoarce la punctul inițial
clar (); Șterge afișajul cu cursorul setat la 0.0. Informațiile de pe afișaj vor fi șterse definitiv.	Notă: durează mult.
iluminare din spate (); Pornește iluminarea de fundal a afișajului.
nuBacklight (); Opriți iluminarea de fundal a afișajului.	Notă: Această funcție este implementată numai în biblioteca LiquidCrystal_I2C.
setBacklight ( steag ); Controlul luminii de fundal (în loc de funcțiile fără iluminare de fundal și iluminare de fundal).	Parametru: steag: true pentru a activa și false pentru a dezactiva iluminarea de fundal. Notă: Această funcție este implementată numai în biblioteca LiquidCrystal_I2C.

/ * Afișează o inscripție pentru monitorizarea funcțiilor de control a afișajului: * / lcd.cursor (0,0); // Setați cursorul în colțul superior al afișajului (0 coloană, 0 rând) lcd.print ("iarduino.ru"); // Afișează textul „iarduino.ru” (prima literă „i” va fi în poziția „0,0”, iar ultimul „u” în poziția „10,0”, cursorul invizibil la „11” poziție ,0") // lcd.noDisplay (); // Opriți afișajul (inscripția va dispărea de pe afișaj) lcd.display (); // Porniți afișajul (inscripția va apărea pe afișaj în același loc) lcd.scrollDisplayLeft (); // Deplasați coordonatele coloanelor la stânga (afișajul va afișa „arduino.ru” fără prima literă „i”, care va trece dincolo de afișaj, dar va rămâne în RAM-ul său) lcd.scrollDisplayRight (); // Deplasați coordonatele coloanelor la dreapta (afișajul va afișa „iarduino.ru” în același loc în care a fost afișat inițial) lcd.clear (); // Curățați afișajul (inscripția va dispărea definitiv de pe afișaj) lcd.noBacklight (); // Dezactivează iluminarea de fundal a afișajului lcd.backlight (); // Porniți iluminarea de fundal a afișajului lcd.setBacklight (0); // Opriți iluminarea de fundal a afișajului lcd.setBacklight (1); // Porniți iluminarea de fundal a afișajului

Funcții de control al cursorului:

setCursor ( col , rând ); Poziționează cursorul la poziția specificată.	Parametru: col: numărul coloanei (începând cu 0). rând: numărul de linie (începând cu 0)
Acasă (); Setarea cursorului pe poziția 0,0. Funcționează ca setCursor (0,0);	Notă: durează mult.
clipi (); Pornește cursorul care clipește.	Notă: Cursorul ocupă întreg câmpul simbolului și clipește la o frecvență de aproximativ 1 Hz, în poziția în care a fost setat anterior.
nu Blink (); Opriți cursorul care clipește.	Notă: Cursorul devine invizibil, dar poziția sa este păstrată.
cursor (); Activați sublinierea cursorului.	Notă: Cursorul ia forma unui caracter de subliniere și se află în poziția în care a fost plasat anterior.
noCursor (); Dezactivați sublinierea cursorului.	Notă: Cursorul devine invizibil, dar poziția sa este păstrată.

lcd.setCursor (0, 1); // Poziționați cursorul pe primul caracter al celei de-a doua rânduri (numerotarea rândurilor și coloanelor începe de la 0) lcd.home (); // Setați cursorul la primul caracter al primei linii (ca atunci când apelați lcd.setCursor (0,0);) lcd.blink (); // Faceți cursorul vizibil (un dreptunghi va clipi la poziția cursorului) lcd.noBlink (); // Faceți cursorul invizibil (eliminați dreptunghiul care clipește) lcd.cursor (); // Faceți cursorul vizibil (un caracter de subliniere va apărea la poziția cursorului) lcd.noCursor (); // Faceți cursorul invizibil (eliminați caracterul de subliniere) // Dacă cursorul lovește locul unde există un caracter, atunci acest caracter nu dispare

Funcții care indică direcția și alinierea:

de la stânga la dreapta (); Indică faptul că după fiecare caracter nou, poziția cursorului trebuie deplasată cu o coloană la dreapta.	Notă: Dacă introduceți textul „abc”, afișajul va afișa „abc”, iar textul va fi în dreapta poziției inițiale a cursorului. (Ca de obicei)
de la dreapta la stanga (); Indică faptul că după fiecare caracter nou, poziția cursorului trebuie deplasată cu o coloană la stânga.	Notă: Dacă introduceți textul „abc”, afișajul va afișa „cba” și textul va fi la stânga poziției inițiale a cursorului. (Scriind de la dreapta la stânga)
noAutoscroll (); Indică faptul că, în viitor, textul ar trebui să fie aliniat la stânga față de poziția inițială a cursorului.	Notă: dacă plasați cursorul în poziția 10.0 și afișați textul, atunci primul caracter al textului afișat va fi localizat în această poziție. (Ca de obicei)
autoscroll (); Indică faptul că, în viitor, textul ar trebui să fie aliniat la dreapta față de poziția inițială a cursorului.	Notă: dacă plasați cursorul în poziția 10.0 și afișați textul, atunci cursorul va fi localizat în această poziție. (Coordonatele afișajului vor fi deplasate la stânga, ca și cum ați fi apelat funcția scrollDisplayLeft de câte ori există litere în textul afișat)

lcd.leftToRight (); // Spune cursorului să se deplaseze la dreapta (Ca de obicei în scrisul european) lcd.clear (); lcd.setCursor (5.0); lcd.print ("ABC"); // Pe display vom vedea: „ABC” (După „A” cursorul s-a deplasat la dreapta și a afișat „B”, apoi cursorul s-a mutat la dreapta și a afișat „C”) lcd.rightToLeft (); // Spune cursorului să se deplaseze la stânga (Ca în scris de la dreapta la stânga) lcd.clear (); lcd.setCursor (5.0); lcd.print ("ABC"); // Pe display vom vedea: „CBA” (După „A” cursorul s-a mutat la stânga și a afișat „B”, apoi cursorul s-a mutat la stânga și a afișat „C”) lcd.noAutoscroll (); // Setați alinierea la stânga (Ca de obicei) lcd.clear (); lcd.setCursor (5.0); lcd.print ("ABC"); // Afișajul va afișa: „ABC” (Ca de obicei) lcd.autoscroll (); // Setați alinierea la dreapta (Coordonatele afișajului vor fi deplasate la stânga cu numărul de caractere afișat) lcd.clear (); lcd.setCursor (5.0); lcd.print ("ABC"); // Pe display vom vedea: "ABC" (Coordonatele afișajului vor fi deplasate cu 3 caractere la stânga, deoarece după fiecare caracter se face un apel la funcția scrollDisplayLeft)

Funcții pentru introducerea textului și a simbolurilor:

createChar (num, array); Scrierea unui caracter personalizat pe afișajul CGRAM sub numărul specificat. Dacă doriți să afișați textul (folosind funcția de imprimare) în care ar trebui să fie caracterul pe care l-ați instalat, specificați slash-ul și numărul sub care a fost scris acest caracter: print ("C \ 1MBO \ 2").	Parametru: num: numărul sub care va fi scris caracterul. matrice: o matrice reprezentând caracterul de scris. Notă: tabloul este format din mai mulți octeți, al căror număr este egal cu numărul de linii dintr-un caracter. Fiecare bit set al unui octet corespunde unui pixel de caracter setat (afisat).
imprimare (text); Afișează text, caractere sau numere pe ecranul de afișare.	Parametru: text: un caracter, număr sau șir de afișat. Notă: Sintaxa este similară cu funcția cu același nume din clasa Serial.

#include // Conectăm biblioteca pentru lucrul cu magistrala I2C #include // Conectam biblioteca pentru lucrul cu display-ul LCD prin magistrala I2C LiquidCrystal_I2C lcd (0x27,16,2); // Declarați obiectul bibliotecă, specificând parametrii de afișare (adresa I2C = 0x27, număr de coloane = 16, număr de rânduri = 2) // uint8_t symbol_d = (0b00000, // 1 linie a simbolului „d” 0b00000, // / 2 rând de simbol "d "0b00110, // 3 șir de caractere" d "0b01010, // 4 șir de caractere" d "0b01010, // 5 șir de caractere" d "0b01010, // 6 șir de caractere " d "0b11111, // 7 șir de caractere" d "0b10001); // 8 șir de simbol „d” Întreaga matrice poate fi scrisă într-o singură linie: uint8_t symbol_d = (0,0,6,10,10,10,31,17); // uint8_t symbol_i = (0b00000, // 1 rând din simbolul „și” 0b00000, // 2 rând din simbolul „și” 0b10001, // 3 rând din simbolul „și” 0b10011, // 4 rând din simbol „și” 0b10101, // șir de 5 caractere „și” 0b11001, // șir de 6 caractere „și” 0b10001, // șir de 7 caractere „și” 0b00000); // 8 șir de simboluri „și” Întregul tablou poate fi scris într-o singură linie: uint8_t symbol_i = (0,0,17,19,21,25,17,0); void setup () (// lcd.init (); // Inițiați lucrul cu ecranul LCD lcd.backlight (); // Porniți iluminarea de fundal a afișajului LCD lcd.createChar (1, symbol_d); // Încărcați primul caracter lcd în memoria afișajului .createChar (2, simbol_i); // Încărcați al doilea simbol în memoria afișajului lcd.clear (); // Ștergeți ecranul lcd.setCursor (0,0); // Setați cursorul la colțul de sus lcd.print ("Pa \ 1 \ 2o "); // Afișează textul" Radio "în timp ce caracterele" P "," a "," o "sunt scrise în latină,) // și caracterele" d "," și "sunt afișate din memoria afișajului, indicând numerele lor // void loop () (// lcd.setCursor (0,1); lcd.print (""); // șterge întreaga linie de jos lcd. setCursor (0,1); lcd.print ("i"); lcd.print ("arduino"); lcd.print (". ru"); // afișează textul "i" "arduino" ".ru" în întârzierea liniei de jos (2000); // așteptați 2 secunde lcd.setCursor ( 0,1); lcd.print (""); // ștergeți întreaga linie de jos lcd.setCursor (0,1); lcd.print (12.345); // imprimați numărul 12.34 (se afișează 2 zecimale) întârziere (2000); // așteptați 2 secunde lcd.setCursor (0,1); lcd.pri nt (""); // șterge întreaga linie de jos lcd.setCursor (0,1); imprimare lcd (12, HEX); // afișează numărul 12 ca număr hexazecimal întârziat (2000); // așteptați 2 secunde lcd.setCursor (0,1); lcd.print (""); // șterge întreaga linie de jos lcd.setCursor (0,1); lcd.print (1); // afișează numărul 1 întârziere (2000); // așteptați 2 secunde)

Linie târâtoare pe LCD pe HD44780.

Căutarea unei „soluții gata făcute” a liniei de rulare în C nu a dat niciun rezultat. Așa că a trebuit să o fac eu.

Această „piesă” de cod vă permite să afișați o linie târâtoare (de la dreapta la stânga), oriunde și folosind orice număr de familiaritate, în afișajele LCD cu controlerul HD44780 sau similar.

Primul lucru de menționat este că limbajul C nu vă permite să lucrați cu șiruri „direct”. Adică, este imposibil să copiați un caracter dintr-un șir în altul folosind operatorul de atribuire ( = ) ... pentru aceasta trebuie să folosiți o funcție specială strncpy (). În general, există mai multe funcții folosite pentru a manipula șirurile în C. În Autotutorii, un capitol separat este dedicat utilizării acestor funcții. În Ajutor „e pe CV_AVR, descrierea funcțiilor pentru lucrul cu șiruri este în secțiune „Funcții șir”... Prototipurile acestor funcții se află în fișier sfoară.h.

„... linia originală...” - linia de caractere din care doriți să afișați în linia „târâtoare”;

„... caractere afișate...” este de fapt o linie târâtoare.

Pentru a organiza linia târâtoare, a fost ales următorul algoritm:

1. Caracterele afișate sunt deplasate de la dreapta la stânga. Extrema stângă este „pierdută” în acest caz.

2. După schimbare, următorul caracter din șirul original este copiat în caracterul din dreapta.

3. Când se ajunge la sfârșitul liniei originale, primul caracter al liniei originale devine următorul.

Pentru a schimba caracterele - pentru celula deplasată, codul caracterului este citit din RAM-ul ecranului HD44780 (DDRAM) și scris în celula RAM din stânga.

Conform fișei de date de pe HD44780, caracterul din stânga al rândului de sus are o adresă DDRAM de 0x00, iar caracterul din stânga al rândului de jos este 0x40. Trebuie amintit că, pentru a ne referi în mod specific la RAM-ul ecranului (și nu la RAM generator de caractere), bitul RS trebuie să fie egal cu 1 (RS este bitul cel mai semnificativ din octetul de adresă, vezi Fișa de date).

Ca urmare, obținem că pentru a „adresa” al doilea caracter din stânga liniei de sus, este necesar să „lucram” cu adresa 0x01 | 0x80 = 0x81.

Funcțiile pentru scrierea și citirea „conținutului intern” al HD44780 sunt în bibliotecă (prototipuri în lcd.h) .... prin urmare ... programul în sine:

/ * pentru CV_AVR

În acest exemplu, linia progresivă este afișată în cifre de la 8 (0xC7) la 16 din linia de jos a unui indicator pe 16 biți.

. ......

#include

unsigned char n_sim = 1, m_end = 43; // 43 - lungimea liniei din exemplu
...........

beg_stroka () (
nesemnat char i;

// deplasează linia târâtoare

dacă (beg_str) (
pentru (i = 0; i<9;i++)lcd_write_byte(0xC7+i,lcd_read_byte(0xC8+i));
beg_str = 0;

// scrie următorul caracter în poziția cea mai din dreapta

lcd_gotoxy (15,1);
lcd_putchar (ish_str);
dacă (++ n_sim> m_end) n_sim = 1;
}
}

Glosar:

n_sim - pointer către poziția caracterului curent în linia sursă;

m_end - numărul total de caractere din linia sursă;

beg_str- shift bit "permisiv". Cu ajutorul acestuia, puteți regla viteza de „rulare”;

ish_str este șirul original.

Cel mai probabil, fiecare dintre compilatoarele C existente are funcții de bibliotecă pentru a lucra cu HD44780. Prin urmare, nu va fi dificil să „refaceți” programul pentru compilatorul „tău”.

„Pregătesc” linia originală folosind binecunoscutul utilitar „HD44780.exe”. Când îl utilizați, comentariile indică lungimea liniei: "/ * Lungimea maximă a unei linii: 43 octeți * /"