// portul la care este conectat magistrala de date LCD
#define PORT_DATA PORTD
#define PIN_DATA PIND
#define DDRX_DATA DDRD

// portul la care sunt conectați pinii de control
#define PORT_SIG PORTB
#define PIN_SIG PINB
#define DDRX_SIG DDRB

// numerele de pin ale microcontrolerului
// la care sunt conectați pinii de control LCD
#define RS 5
#definiți RW 6
#define EN 7

// macrocomenzi pentru lucrul cu biți
#define ClearBit (reg, bit) reg & = (~ (1<<(bit)))
#define SetBit (reg, bit) reg | = (1<<(bit))

#define F_CPU 8000000
#define _delay_us (noi) __cicluri_de_întârziere((F_CPU / 1000000) * (noi));
#define _delay_ms (ms) __cicluri_de_întârziere((F_CPU / 1000) * (ms));

// funcția de înregistrare a comenzii
gol LcdWriteCom ( nesemnat char date)
{
ClearBit (PORT_SIG, RS); // setați RS la 0
PORT_DATA = date; // scoateți date către magistrală
SetBit (PORT_SIG, EN); // setați E la 1
_delay_us (2);
ClearBit (PORT_SIG, EN); // setați E la 0
_delay_us (40);

// funcția de scriere a datelor

ClearBit (PORT_SIG, EN); // setați E la 0

Delay_us (40);
}

int principal ( gol )
{
in timp ce (1);
întoarcere 0;
}

Nu există locuri dificile aici, totul ar trebui să fie clar. Dați-i drumul.

Orice afișaj LCD trebuie inițializat înainte de utilizare. Procesul de inițializare este de obicei descris în fișa de date pentru controlerul de afișare. Dar chiar dacă nu există informații acolo, secvența este probabil ca aceasta.

2. Așteptați> 40 ms

3. Trimiteți comanda Function set

DL- bit pentru setarea lățimii magistralei
magistrală 0 - 4 biți, magistrală 1 - 8 biți

N- bit pentru setarea numărului de linii de afișare
0 - modul cu o linie, 1 - modul cu două linii

F- bit de setare a fontului
0 - format 5 * 8, 1 - format 5 * 11

* - nu contează ce va fi în aceste biți

4. Trimitem comanda Display ON / OFF

D- afișaj bit pornit / oprit
0 - afișaj oprit, 1 - afișaj aprins

C- bit de pornire/dezactivare a cursorului
0 - cursorul dezactivat, 1 - cursorul activat

B- bit de activare a pâlpâirii
0 - cursor intermitent pornit, 1 - cursor intermitent oprit

5. Trimitem comanda Clear Display

6. Așteptați> 1,5 ms

7. Dați comanda Entry Mode Set

I/D- ordinea de creștere/scădere a adresei DDRAM (afișare date RAM)
0 - cursorul se deplasează la stânga, adresa scade cu 1, 1 - cursorul se deplasează la dreapta, adresa crește cu 1

SH- ordinul de a muta întregul afișaj
0 - nicio schimbare, 1 - deplasarea are loc în funcție de semnalul I / D - dacă este 0 - afișajul este deplasat la dreapta, 1 - afișajul este deplasat la stânga

Pentru exemplul nostru, funcția de inițializare va arăta astfel

Ecranele LCD de dimensiunea 1602, bazate pe controlerul HD44780, sunt unul dintre cele mai simple, mai accesibile și solicitate afișaje pentru dezvoltarea diferitelor dispozitive electronice. Poate fi găsit atât în ​​aparatele asamblate pe genunchi, cât și în dispozitivele industriale, precum, de exemplu, aparatele de cafea. Pe baza acestui afișaj, sunt colectate cele mai populare module și scuturi din tema Arduino, cum ar fi și.

În acest articol vă vom spune cum să îl conectați la Arduino și să afișați informații.

Componente folosite (cumpărare din China):

... Panou de control

... Fire de conectare

Aceste afișaje sunt disponibile în două versiuni: iluminare de fundal galbenă cu litere negre sau, mai frecvent, iluminare de fundal albastră cu litere albe.

Dimensiunile display-urilor de pe controlerul HD44780 pot fi diferite, ele vor fi controlate în același mod. Cele mai comune dimensiuni sunt 16x02 (adică 16 caractere pe două rânduri) sau 20x04. Rezoluția simbolurilor în sine este de 5x8 pixeli.

Majoritatea afișajelor nu au suport pentru alfabetul chirilic, doar afișajele cu marcaj CTK îl au. Dar această problemă poate fi parțial rezolvată (continuare în articol).

Știfturi de afișare:

Display-ul are un conector cu 16 pini pentru conectare. Știfturile sunt marcate pe spatele plăcii.

1 (VSS) - Sursa de alimentare a controlerului (-)
2 (VDD) - Alimentare controler (+)
3 (VO) - Pin de control al contrastului
4 (RS) - Înregistrați selecția
5 (R / W) - Citire / Scriere (modul de scriere atunci când este conectat la masă)
6 (E) - Activare (poartă la dezintegrare)
7-10 (DB0-DB3) - Biți scăzuti ai interfeței pe 8 biți
11-14 (DB4-DB7) - Biți de ordin înalt ai interfeței
15 (A) - Alimentare cu anod (+) pentru iluminare de fundal
16 (K) - Alimentare cu iluminare de fundal catod (-).

Modul autotest:

Înainte de a încerca să conectați și să scoateți informații, ar fi bine să cunoașteți afișajul de lucru sau nu. Pentru a face acest lucru, trebuie să aplicați tensiune controlerului însuși ( VSS și VDD), porniți lumina de fundal ( A și K) și, de asemenea, reglați contrastul.

Utilizați un potențiometru de 10 kΩ pentru a regla contrastul. Ce formă va avea nu contează. + 5V și GND sunt aplicate picioarelor exterioare, piciorul central este conectat la ieșire VO

După aplicarea alimentării circuitului, este necesar să se obțină contrastul corect, dacă nu este configurat corect, atunci nimic nu va fi afișat pe ecran. Pentru a regla contrastul, jucați cu potențiometrul.

Cu asamblarea corectă a circuitului și setarea corectă a contrastului, linia de sus de pe ecran ar trebui să fie umplută cu dreptunghiuri.

Ieșire de informații:

Ecranul folosește biblioteca LiquidCrystal.h încorporată cu Arduino IDE.

Funcționalitatea bibliotecii

// Lucrează cu cursorul lcd.setCursor (0, 0); // Setați cursorul (numărul celulei, linie) lcd.home (); // Setați cursorul la zero (0, 0) lcd.cursor (); // Activați vizibilitatea cursorului (subliniere) lcd.noCursor (); // Ascunde vizibilitatea cursorului (subliniat) lcd.clipire (); // Activați clipirea cursorului (cursor 5x8) lcd.noBlink (); // Opriți cursorul intermitent (cursor 5x8) //Ieșire de informații lcd.print („site”); // Informații de ieșire lcd.clear (); // Ștergeți afișajul, (ștergeți toate datele) setați cursorul la zero lcd.rightToLeft (); // Scrierea se face de la dreapta la stânga lcd.leftToRight (); // Scrierea se face de la stânga la dreapta lcd.scrollDisplayRight (); // Deplasați totul de pe afișaj cu un caracter la dreapta lcd.scrollDisplayLeft (); // Deplasați totul de pe afișaj cu un caracter la stânga // Informații utile pentru spioni :) lcd.noDisplay (); // Informațiile de pe afișaj devin invizibile, datele nu sunt șterse // dacă, în momentul în care această funcție este activă, nu este afișat nimic pe afișaj, atunci Ecran LCD (); // La apelarea funcției de afișare (), afișajul restabilește toate informațiile care au fost

Afișajul în sine poate funcționa în două moduri:

Mod pe 8 biți - atât cei mai puțin semnificativi, cât și cei mai semnificativi biți sunt utilizați pentru aceasta (BB0-DB7)

Mod pe 4 biți - doar biții mai puțin semnificativi sunt utilizați pentru aceasta (BB4-DB7)

Utilizarea modului pe 8 biți pe acest afișaj nu este recomandabilă. Este nevoie de încă 4 picioare pentru a funcționa și practic nu există nici un câștig în viteză. rata de reîmprospătare a acestui afișaj atinge limita< 10раз в секунду.

Pentru a afișa text, conectați pinii RS, E, DB4, DB5, DB6, DB7 la pinii controlerului. Ele pot fi conectate la orice pini ai Arduino, principalul lucru este să setați secvența corectă în cod.

Exemplu de cod de program:

// Testat pe Arduino IDE 1.0.5#include // Adăugați biblioteca necesară LiquidCrystal LCD (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) gol înființat() (lcd.begin (16, 2); // Setați dimensiunea ecranului lcd.setCursor (0, 0); // Setați cursorul la începutul liniei 1 lcd.print ("Bună ziua, lume!"); // Afișează textul lcd.setCursor (0, 1); // Setați cursorul la începutul liniei 2 lcd.print („site”); // Afișează textul) void buclă (){ }

Crearea propriilor simboluri

Ne-am dat seama de rezultatul textului, literele alfabetului englezesc sunt cusute în memoria controlerului în interiorul afișajului și nu există probleme cu ele. Dar ce să faci dacă simbolul necesar nu se află în memoria controlerului?

Instrucțiuni

Acțiunea telemetrului cu ultrasunete HC-SR04 se bazează pe principiul ecolocației. Emite impulsuri sonore în spațiu și primește un semnal reflectat de la un obstacol. Distanța până la obiect este determinată de timpul de propagare a undei sonore la obstacol și înapoi.
Unda sonoră este declanșată prin aplicarea unui impuls pozitiv de cel puțin 10 microsecunde la piciorul TRIG al telemetrului. De îndată ce pulsul se termină, telemetrul emite o explozie de impulsuri sonore cu o frecvență de 40 kHz în spațiul din fața lui. În același timp, algoritmul pentru determinarea timpului de întârziere al semnalului reflectat este lansat și o unitate logică apare pe piciorul ECHO al telemetrului. De îndată ce senzorul preia semnalul reflectat, pe pinul ECHO apare un zero logic. Durata acestui semnal („Întârzierea ecoului” din figură) determină distanța până la obiect.
Gama de măsurare a distanței telemetrului HC-SR04 - până la 4 metri cu o rezoluție de 0,3 cm.Unghi de observare - 30 de grade, unghi efectiv - 15 grade. Curentul de consum în modul standby este de 2 mA, în timpul funcționării - 15 mA.

Alimentarea telemetrului cu ultrasunete se realizează cu o tensiune de +5 V. Ceilalți doi pini sunt conectați la orice porturi digitale ale Arduino, ne vom conecta la 11 și 12.

Acum să scriem o schiță care determină distanța până la obstacol și o trimite la portul serial. Mai întâi, setăm numerele pinii TRIG și ECHO - aceștia sunt pinii 12 și 11. Apoi declarăm declanșatorul ca ieșire și ecoul ca intrare. Inițializați portul serial la 9600 baud. În fiecare repetare a ciclului buclă () citim distanța și o scoatem în port.
Funcţie getEchoTiming () generează un impuls de pornire. Acesta creează doar un impuls de curent de 10 microsecunde, care este un declanșator pentru începerea emisiei unui pachet de sunet de către telemetru în spațiu. Apoi își amintește timpul de la începutul transmiterii undei sonore până la sosirea ecoului.
Funcţie getDistance () calculează distanța până la obiect. De la cursul de fizică a școlii, ne amintim că distanța este egală cu viteza înmulțită cu timp: S = V * t. Viteza sunetului în aer este de 340 m/s, timpul în microsecunde știm că este „duratuion”. Pentru a obține timpul în secunde, împărțiți la 1.000.000. Deoarece sunetul parcurge de două ori distanța - până la obiect și înapoi - trebuie să împărțiți distanța la jumătate. Deci, se dovedește că distanța până la obiect S = 34000 cm / sec * durata / 1.000.000 sec / 2 = 1.7 cm / sec / 100, ceea ce am scris în schiță. Microcontrolerul efectuează înmulțirea mai rapid decât împărțirea, așa că am înlocuit „/ 100” cu echivalentul „* 0.01”.

De asemenea, multe biblioteci au fost scrise pentru a lucra cu un telemetru cu ultrasunete. De exemplu, acesta: http://robocraft.ru/files/sensors/Ultrasonic/HC-SR04/ultrasonic-HC-SR04.zip. Biblioteca este instalată într-un mod standard: descărcare, dezarhivare într-un director biblioteci care se află în folderul Arduino IDE. După aceea, biblioteca poate fi folosită.
După ce ați instalat biblioteca, să scriem o nouă schiță. Rezultatul muncii sale este același - în monitorul portului serial distanța până la obiect este afișată în centimetri. Dacă scrii în schiță float dist_cm = ultrasonic.Ranging (INC);, atunci distanța va fi afișată în inci.

Deci, am conectat telemetrul cu ultrasunete HC-SR04 la Arduino și am primit date de la acesta în două moduri diferite: folosind o bibliotecă specială și fără.
Avantajul utilizării bibliotecii este că cantitatea de cod este redusă semnificativ și lizibilitatea programului este îmbunătățită, nu trebuie să vă aprofundați în complexitățile dispozitivului și îl puteți utiliza imediat. Dar acesta este și dezavantajul: înțelegeți mai puțin bine cum funcționează dispozitivul și ce procese au loc în el. În orice caz, ce metodă să folosești depinde de tine.

Astăzi vom încerca să ne concentrăm asupra rezultatului pe afișajul text. Cel mai popular este cipul HD44780 (sau KS0066 compatibil cu acesta). Să le enumerăm avantajele și dezavantajele:

Pro:

1. Preț scăzut.
2. Ușurință de programare, codul va fi același pentru orice model.
3. Varietate de modele - cele mai comune: 8x1, 16x2, 20x4. Poti gasi si modele 40x4 destul de exotice, i.e. patru rânduri a câte 40 de caractere fiecare.
4. Posibilitatea de a conecta mai multe display-uri la un singur Arduino.
5. Abilitatea de a-ți defini propriile simboluri.

Minusuri:

1. Nu toate afișajele acceptă caractere rusești. Mai multe detalii ar trebui găsite în descrierea unui anumit afișaj.
2. Conectarea fără a utiliza o magistrală I2C necesită 10-16 fire, ceea ce este foarte rău. cu I2C - 4 fire.

Pe baza celor de mai sus, voi lua în considerare doar conectarea afișajului prin I2C.

Sa incercam.

De ce avem nevoie.

1. Arduino (am luat modelul Nano)
2. Afișare pe cip HD44780 cu sau fără modul I2C (atunci veți avea nevoie de o placă IIC LC1602 separată) - în cazul nostru 16x2 fără modul I2C
3. Rezistor de 10K (dacă este nevoie de control manual al luminii de fundal).
4. Potențiometru (dacă este necesar controlul manual al luminii de fundal).
5. Placă de dezvoltare Breadboard.
6. Biblioteca LiquidCrystal_I2C. http://www.ansealk.ru/files/LiquidCrystal_V1.2.1.zip

Mică digresiune # 1: Cum să faceți diferența dintre un afișaj și un modul I2C?

De fapt, este destul de simplu. Dacă, prin întoarcerea afișajului, vedem o bandă lungă de conector (de obicei 16 bucăți), atunci nu există niciun modul I2C pe afișaj:

Și așa arată afișajul cu modulul I2C deja instalat:

Pinii SCL, SDA, VCC, GND sunt folosiți pentru a conecta Arduino. Două contacte din stânga - în imagine sunt închise cu un jumper - sunt necesare pentru ca lumina de fundal să funcționeze.

Dacă modulul nu este conectat, va trebui să o faceți singur. Principalul lucru la care trebuie să acordați atenție este să conectați contactele în ordinea corectă. De regulă, primul și 16 ace sunt marcate. Uneori se întâmplă ca cele 15-16 contacte prin care se controlează lumina de fundal să poată fi amplasate în fața primei (în acest caz vor fi numerotate). Pe modul în sine, primul pin poate fi, de asemenea, desemnat nu printr-un număr, ci printr-un pătrat în jurul pinului însuși.

Sistem:

Să punem cap la cap următoarea schemă:

Aș dori să vă atrag atenția asupra următoarelor puncte:

1. Dacă dați peste un afișaj cu un modul I2C deja lipit, atunci firele marcate cu gri nu sunt necesare. Altfel, nimic nu se schimba.
2. Dacă nu dorim să schimbăm luminozitatea afișajului, atunci circuitul va fi simplificat:

după cum ați observat, doi pini de pe modulul I2C etichetați cu LED sunt responsabili pentru iluminarea de fundal a afișajului. Dacă nu doriți să utilizați controlul luminozității, puteți pur și simplu să le închideți.

Acum să descompun codul.

Aproape totul ar trebui să fie familiar aici. În rândul 5, indicăm adresa dispozitivului. Rândurile 16 și 17 arată numărul de caractere pe linie și numărul de rânduri. Rândurile 20-22 - Creăm un obiect pentru lucrul cu afișajul și descriem parametrul pentru lucrul cu acesta.

Mică digresiune # 2: Cum să găsiți adresa unui dispozitiv I2C?

În cea mai mare parte, adresa poate fi găsită în fișa de date pentru microcircuitul pe care este construit dispozitivul I2C. Dacă acest lucru nu este posibil, iată un link către arhiva cu schița și diagramele - http://www.ansealk.ru/files/Arduino_lcd_i2c.zip care definește adresele tuturor dispozitivelor conectate prin magistrala I2C. Trebuie doar să conectați dispozitivul la Arduino, să încărcați schița, să deschideți consola și să vedeți adresa.

Aici vedem o funcție care, de fapt, se va ocupa de afișaj. Principiul retragerii este cam așa:

Setați poziția de pornire a ieșirii folosind funcția setCursor ().

Tipărim un șir cu funcția print ().

După aceea, următoarea funcție de imprimare () va porni ieșirea din următoarea poziție după care s-a încheiat intrarea anterioară. De asemenea, aș dori să vă atrag atenția asupra faptului că, spre deosebire de ieșirea către consolă, funcția println () nu este folosită aici pentru a finaliza ieșirea și avansul de linie.

Astfel, pe prima linie a ecranului nostru va apărea inscripția „Test LCD1602”, iar a doua va indica rezoluția afișajului și un contor care arată câte cicluri a funcționat schița noastră.

Dar, dacă trebuie să afișăm o mulțime de valori variabile pe ecran, această metodă nu este complet convenabilă. Faptul este că procedura de afișare este foarte consumatoare de energie și lentă, iar ieșirea în această funcție este de până la 7 ori. Va fi mult mai ușor să preformați șirul în avans și apoi să îl scoateți în întregime. Funcția sprintf () de intrare formatată ne va ajuta în acest sens.

Mică digresiune # 3: Funcția de intrare formatată sprintf ().

În limbajul C, există câteva funcții foarte convenabile pentru tipărirea șirurilor - ele se numesc funcții de ieșire formatate - printf (din cuvintele print și format). În cazul nostru particular, ne interesează funcția sprintf, care nu afișează nimic pe ecran, ci generează un șir pentru afișarea ulterioară. Arata cam asa:

sprintf (str, „String% d pentru ieșire”, i);

Funcția generează un șir (marcat cu albastru) folosind un șablon (cu galben), în care sunt înlocuite valorile variabilelor (cu verde). Rezultatul rezultat va fi scris într-o variabilă șir (în roșu).

Pot exista mai multe șabloane și variabile. În acest caz, variabilele sunt scrise separate prin virgule. Principalul lucru este să vă asigurați că numărul de șabloane pe linie se potrivește cu numărul de variabile. Variabilele pentru șabloane sunt luate secvenţial, de exemplu. primul șablon este înlocuit cu valoarea primei variabile, în al doilea - a doua variabilă și așa mai departe.

Ce sunt șabloanele? Orice model începe cu un caracter „%” și se termină cu unul din zece (în cazul Arduino - șapte) caractere de tip. Între ele pot exista o mulțime de informații despre cum să afișați valoarea sau nimic altceva.

Să aruncăm o privire la ceea ce poate fi în șablon. În general, șablonul arată astfel:

% [drapel] [lățime] [. precizie] tip

Parantezele pătrate indică faptul că elementul inclus în ele poate fi absent. Bara verticală indică faptul că una dintre valorile specificate ar trebui să fie selectată în acest câmp (în cazul nostru, una dintre literele H, I sau L).

Să ne ocupăm mai întâi de elementul șablon necesar - tipul. Indică ce tip de variabilă va fi afișată și poate lua una dintre următoarele valori:

Acele tipuri care nu sunt aplicabile atunci când lucrați cu Arduino sunt marcate cu gri. Astfel, „% s” trebuie specificat pentru a scoate un șir, iar „% d” pentru a scoate un întreg.

În continuare, să ne uităm la caseta de lățime. Numărul din acesta indică lățimea minimă a câmpului în care va fi afișat șablonul. Dacă dimensiunea valorii din variabilă este mai mică - câmpul va fi terminat cu spații, dacă este mai mare - înregistrarea va depăși câmpul. Astfel, modelul „% 6d” pentru 385 va scoate 385 (rețineți cele trei spații dinaintea numărului).

Specificatorul de precizie începe întotdeauna cu un punct și următorul număr indică acțiuni diferite în funcție de tipul valorii. Pentru tipurile „d, o, u, x” va indica numărul minim de caractere care ar trebui să apară în timpul procesării. Pentru tipul "f" - numărul de zecimale. Pentru tipul „s” - numărul maxim de caractere șir care vor fi tipărite. De exemplu, „% 6.1f” pentru 34.2345 va scoate „34.1” (rețineți că un punct este, de asemenea, considerat un semn și vor fi două spații înaintea numărului). Sau modelul „% .3s” din șirul „precizie” va afișa doar primele trei caractere - „exact”.

Steagul vă permite să schimbați afișarea valorii afișate:

Puteți citi mai multe despre șabloanele de funcție printf pe Internet. Aici am oferit o scurtă prezentare a caracteristicilor cele mai frecvent utilizate.

Astfel, funcția noastră de ieșire, rescrisă pentru a utiliza ieșirea formatată, va arăta astfel:

Rețineți că pe liniile 33 și 37 formăm întreaga linie pentru ieșire, iar pe liniile 34 și 38 le scoatem.

În cele din urmă, funcțiile noastre preferate de configurare și buclă.

Pe linia 47 setăm rezoluția afișajului, pe linia 48 pornim lumina de fundal (a cărei luminozitate poate fi reglată cu un potențiometru). Pe linia 49, setați contorul de cicluri la zero. Îl vom crește cu unul în a 37-a linie în timpul ieșirii (vă amintiți construcția numărului ++?). În cele din urmă, pe linia 56, numim funcția de afișare despre care am discutat mai devreme. Tot.

Ce poate fi schimbat sau îmbunătățit?

De exemplu, puteți face controlul automat al luminii de fundal în funcție de iluminare folosind un fotorezistor sau un senzor de lumină de la stația meteo discutată în mai multe articole anterior. Să spunem la iluminare puternică - crește luminozitatea luminii de fundal, iar noaptea - scade. Sau înșurubați senzorul de mișcare și aprindeți lumina de fundal când apare un obiect în fața afișajului, sau... În general, cred că v-ați dat deja seama că dacă doriți, înlocuiți una sau mai multe componente și scrieți o bucată de cod poate îmbunătăți semnificativ gradul de utilizare al afișajului. De asemenea, putem folosi simboluri create manual pentru a le afișa pe afișaj.

Nu iau în considerare toate aceste întrebări aici, deoarece ele depășesc scopul revizuirii pentru începători.

Și pentru azi am de toate.

Arduino. Conectam display-ul LCD