Introduceți matricea, matricea LED care este! Creați – vă propriul afișaj LED cu LED-uri cu Arduino

un singur LED poate fi util în testarea proiectelor Arduino. Dar când adăugați o matrice LED, puteți deveni cu adevărat creativ, scriind litere, numere și simboluri. Este, de asemenea, o modalitate la îndemână de a afla cum funcționează afișajele mai complexe – cum ar fi cea pe care o citiți. În acest ghid, vă vom arăta cum să configurați o matrice LED 8 de bază 8.

cum funcționează matricele LED

o matrice LED de bază precum cea pe care o vom folosi are o grilă de LED-uri 8 de la 8 la 8, care poate fi utilizată pentru a desena caractere, imagini de bază și multe altele. În ghidurile anterioare, am arătat cum Arduino poate controla un singur LED. Această componentă se întinde pe acest concept într-o serie de LED-uri 64 care pot fi controlate cu un singur Arduino.

Tiny Dot-matrix LED Display de HP

LED Matrix

într-o matrice LED, un curent este rulat prin rânduri de LED-uri. Pentru a finaliza circuitul și a activa o lumină individuală, o coloană este conectată la masă. În cazul în care liniile de alimentare și de masă se intersectează, LED-urile sunt activate. Vă puteți gândi la ea un pic ca BattleShip tabla de joc. De exemplu, dacă alimentarea este rulată la rândurile A, B și C, dar numai coloana 1 este conectată la masă, atunci luminile de la A1, B1 și C1 se vor aprinde. Restul va rămâne întunecat.

acesta este un mod util de a activa mai multe LED-uri simultan, dar creează o problemă dacă doriți doar anumite LED-uri dintr-o coloană să se aprindă. Spune, în schimb, ai vrut lumini A1, B2, și C3 pentru a aprinde crearea unei linii diagonale. Activarea tuturor celor trei rânduri și coloane ar activa întreaga grilă, ceea ce nu este ceea ce ne dorim.

pentru a rezolva această problemă, un Arduino poate rula printr-o buclă, activând doar un singur rând de LED-uri la un moment dat. În acest fel, puteți activa câte coloane doriți fără a afecta rândul următor. Fără o funcție de întârziere lungă (), rândurile vor fi activate într-o succesiune atât de rapidă încât ochiul uman nu va putea spune. Dar vom arăta cum să adăugați o întârziere, astfel încât să puteți vedea cum funcționează oricum.

ce veți avea nevoie

folosim o metodă mai complicată pentru a controla matricea LED în scopuri educaționale – alte componente pot reduce numărul de pini necesari – și astfel acest lucru va dura destul de mulți pini și fire decât majoritatea celorlalte ghiduri. Din acest motiv, vom folosi un Arduino Mega 2560, în loc de Arduino Uno obișnuit, pentru a controla această matrice. De asemenea, veți avea nevoie de următoarele:

Arduino Mega 2560 Arduino Mega 2560
8×8 matrice LED matrice LED 8x8
8 rezistor x 220ohm

majoritatea LED-urilor se vor arde dacă le conectați direct la ieșirea de 5V a unui Arduino. Plasați un rezistor din kit între pinul de ieșire și LED.

 8 x 220ohm rezistor
o pereche de breadboards o pereche de breadboards
Arduino IDE Arduino IDE

de asemenea, veți avea nevoie de un cablu USB și de câteva fire – cel puțin 32!

există o serie de moduri de a organiza cablajul pentru acest proiect, dar din moment ce poate deveni complex, vă recomandăm să utilizați o pereche de plăci de pâine fixate împreună, una pentru a gestiona matricea LED și alta pentru cablarea în rezistențe. Este posibil să realizați același lucru folosind fire cu capete feminine care rulează către matricea LED, deși va sta în lateral în loc de staționare, ceea ce poate fi puțin mai greoi.

Codul

codul pentru acest proiect va face uz de bucle și matrice pentru a scrie fiecare LED individual. Rezultatul va fi o matrice în partea de sus a scriptului dvs. pe care o puteți modifica cu ușurință pentru a schimba imaginea pe care o afișează matricea LED. Mai întâi, lipiți codul complet în Arduino IDE și încărcați-l în Arduino Mega.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
int toDisplay = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
void setup () {
pentru (int i = 2; i & lt; = 9; i++) {
pinMode (i, ieșire) ;
pinMode (i + 44, ieșire);
digitalWrite (i, scăzut);
digitalWrite (i + 44, ridicat);
}
pinMode (A0, intrare);
}
buclă void () {
pentru (int i = 0; i & lt;8; i++) {
dacă (i==0) {
digitalWrite (9, scăzut);
}
else {
digitalWrite (i + 1, scăzut);
}
pentru (Int j = 0; j & lt;8; j++) {
dacă (toDisplay == 1) {
digitalWrite (j + 46, scăzut) ;
}
else {
digitalWrite (j + 46, mare);
}
}
digitalWrite (I + 2, Mare);
întârziere(1);
}
}

apoi, să trecem prin modul în care funcționează fiecare dintre aceste secțiuni.

1
2
3
4
5
6
7
8
9
10
int toDisplay = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};

înainte de oricare dintre buclele principale din schiță, această matrice multidimensională va defini ce LED-uri ar trebui să fie aprinse și care ar trebui să rămână întunecate. Există opt rânduri de opt valori fiecare, care corespund cu cele opt rânduri de LED-uri de pe matrice. Așezându-le într-o grilă din schiță, este mai ușor să vizualizați ce formă vor alcătui LED-urile.

1
2
3
4
5
6
7
8
9
void setup() {
pentru (int i=2; i<=9; i++) {
pinMode(i, ieșire);
pinMode(i+44, ieșire);
digitalWrite(i, scăzut);
digitalWrite(i, scăzut);

digitalWrite (i+44, înalt);
}
pinMode (A0, intrare) ;
}

în secțiunea setup (), vom inițializa pinii de care avem nevoie pentru matrice. Deoarece există șaisprezece pini diferiți, putem face acest lucru mai eficient decât unul câte unul. Pinii care rulează la sol vor fi conectați la pinii 2 până la 9. Pinii care trimit energie către matrice vor rula la pinii 46 până la 53. Această secțiune va utiliza o buclă pentru a inițializa ambele seturi de pini.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
buclă void () {
pentru (int i = 0; i & lt;8; i++) {
dacă (i==0) {
digitalWrite (9, scăzut) ;
}
else {
digitalWrite (i + 1, scăzut);
}
pentru (Int j = 0; j & lt;8; j++) {
dacă (toDisplay == 1) {
digitalWrite (j + 46, scăzut);
}
else {
digitalWrite (j + 46, mare);
}
}
digitalWrite (I + 2, Mare);
întârziere(1);
}
}

în secțiunea buclă principală () a schiței, există o buclă în mai multe etape. Prima declarație if va reseta ultimul rând utilizat la scăzut, ceea ce va opri alimentarea către acesta.

următoarea buclă imbricată va verifica datele din matrice. Dacă o celulă este listată ca 1, va seta firul de împământare pentru acea coloană la scăzut, permițând curentului să curgă. În caz contrar, va seta pinul la înălțime, ceea ce va împiedica finalizarea unui circuit de-a lungul acelei coloane. Va face acest lucru pentru toate cele opt celule dintr-un rând dat.

în cele din urmă, ultima instrucțiune digitalWrite() va activa întregul rând. Orice coloane setate la scăzut se vor aprinde. Restul va rămâne întunecat. Când schița se învârte din nou, va începe imediat prin oprirea acelui rând.

ultima comandă este o declarație delay() care stabilește întârzierea între fiecare rând. Este setat la 1 milisecundă în exemplul nostru, deoarece atunci când declarația nu este acolo, LED-urile devin puțin prea slabe. Cu toate acestea, puteți crește întârzierea pentru a vedea ce face schița mai încet. Ar trebui să vedeți fiecare rând aprinde unul la un moment dat, înainte de a opri ca rândul următor se aprinde.

cablajul

pentru acest proiect, cablajul este relativ simplu, există doar o mulțime de ea. Deoarece există mulți pini, vom descrie ce doriți să faceți pentru fiecare circuit complet, mai degrabă decât să enumerați fiecare fir individual, așa cum facem de obicei.

pinii de la 2 la 9 ar trebui să fie pinii dvs. de alimentare, iar pinii de la 46 la 53 ar trebui să fie pinii dvs. de masă. Rulați un fir de la știftul de alimentare, la matricea LED (verificați mai multe detalii despre pinii de mai jos – acest lucru este important), de la matricea LED într-un rezistor de 220 ohmi, apoi rulați un fir înapoi la un știft de pe Arduino. Pinul 2 ar trebui să conducă în cele din urmă la pinul 46, pinul 3 ar trebui să conducă la pinul 47 și așa mai departe.

principala complicație aici este cu matricea LED în sine. Contraintuitiv, pinii de pe ambele părți ale matricei nu sunt deloc într-o ordine coerentă. De exemplu, dorim ca pinul 2 să alimenteze ceea ce vom numi rândul A. cu toate acestea, pinul pentru acesta este al patrulea pin din stânga din partea de sus a matricei LED. Celălalt capăt al acestui circuit – care ar trebui să conducă la coloana 1 – este primul știft din dreapta din partea de jos a matricei.

deoarece această comandă este destul de complicată, vom preciza care pini de pe matrice ar trebui să fie conectați direct la fiecare pin Arduino.

de-a lungul vârfului matricei (partea cu numărul imprimat pe ea) există opt pini. De la stânga la dreapta, acestea ar trebui să fie conectate la următorii pini de pe Arduino:

  • Pin 7
  • Pin 4
  • Pin 49
  • Pin 2
  • Pin 51
  • Pin 52
  • Pin 3
  • Pin 5

apoi, rândul de jos de opt pini de pe matrice (partea fără numere) trebuie să fie conectat la următorii pini (de la stânga la dreapta, cu numerele încă orientate în sus):

  • Pin 9
  • Pin 50
  • Pin 48
  • Pin 6
  • Pin 53
  • Pin 8
  • Pin 47
  • Pin 46

odată ce toate firele sunt conectate, puteți activa proiectul dvs. și veți vedea că matricea LED se aprinde. Încercați să schimbați aranjamentul 1s în matricea inițială și re-încărcați scriptul pentru a crea diferite forme. De asemenea, puteți ajusta lungimea comenzii delay() pentru a vedea fiecare rând luminând unul câte unul.

Lasă un răspuns

Adresa ta de email nu va fi publicată.