een enkele LED kan handig zijn bij het testen van Arduino-projecten. Maar als je een LED-matrix toevoegt, kun je heel creatief worden door letters, cijfers en symbolen te spellen. Het is ook een handige manier om te leren hoe meer complexe displays – zoals degene die je dit leest op het werk. In deze handleiding laten we u zien hoe u een basic 8×8 led matrix kunt instellen.
hoe LED-matrixen werken
een basis-led-matrix zoals die we zullen gebruiken, heeft een 8×8-raster van LEDs dat kan worden gebruikt om tekens, basisafbeeldingen en meer te tekenen. In vorige gidsen, hebben wij getoond hoe Arduino één enkele leiden kan controleren. Deze component strekt dat concept uit over een array van 64 LED ‘ s die allemaal kunnen worden bestuurd met een enkele Arduino.
LED-Matrix
in een LED-matrix wordt een stroom door rijen LEDs geleid. Om het circuit te voltooien en een individueel licht te activeren, wordt een kolom met de grond verbonden. Waar de stroom – en grondlijnen elkaar kruisen, worden LEDs geactiveerd. Je kunt er een beetje aan denken als het bordspel Battleship. Als de stroom bijvoorbeeld wordt uitgevoerd op de rijen A, B en C, maar alleen kolom 1 is aangesloten op de grond, lichten de lichten op A1, B1 en C1 op. De rest blijft donker.
dit is een handige manier om meerdere LEDs tegelijk in te schakelen, maar het creëert een probleem als u alleen bepaalde LEDs in een kolom wilt inschakelen. Zeg, in plaats daarvan, je wilde lichten A1, B2, en C3 om op te lichten het creëren van een diagonale lijn. Het activeren van alle drie de rijen en kolommen zou het hele raster activeren, wat niet is wat we willen.
om dit probleem op te lossen, kan een Arduino door een lus lopen en slechts één rij LEDs tegelijk activeren. Op deze manier kunt u zoveel kolommen activeren als u wilt zonder de volgende rij te beïnvloeden. Zonder een lange delay () – functie worden de rijen zo snel na elkaar geactiveerd dat het menselijk oog het niet kan zien. Maar we zullen laten zien hoe je een vertraging toe te voegen, zodat u kunt zien hoe het werkt toch.
wat u nodig hebt
we gebruiken een meer gecompliceerde methode om de led – matrix te besturen voor educatieve doeleinden – andere componenten kunnen het aantal benodigde pinnen verminderen-en dus zullen er behoorlijk wat meer pinnen en draden nodig zijn dan de meeste van onze andere gidsen. Om die reden, zullen wij een Arduino Mega 2560, in plaats van gebruikelijke Arduino Uno, gebruiken om deze matrijs te controleren. Je hebt ook het volgende nodig:
| Arduino Mega 2560 |  |
| 8×8 LED-Matrix |  |
| 8 x 220ohm weerstand
de meeste LEDs branden uit als je ze direct aansluit op de 5V uitgang van een Arduino. Plaats een weerstand van uw kit tussen de uitgangspeld en de LED. |
 |
| Een paar breadboards |  |
| Arduino IDE |  |
Je hebt ook een USB-kabel en een paar draden – minimaal 32!
er zijn een aantal manieren om de bedrading voor dit project te organiseren, maar omdat het complex kan worden, raden we aan een paar aan elkaar geklemde breadboards te gebruiken, een om de led-matrix te verwerken, en een andere voor bedrading in de weerstanden. Het is mogelijk om hetzelfde te bereiken door draden te gebruiken met vrouwelijke uiteinden die naar de led-matrix lopen, hoewel het aan de zijkant zal zitten in plaats van stilstaand, wat een beetje omslachtiger kan zijn.
de Code
de code voor dit project zal gebruik maken van lussen en arrays om elke LED afzonderlijk te schrijven. Het resultaat zal een array aan de bovenkant van uw script dat u gemakkelijk kunt wijzigen om de afbeelding die uw led-matrix weergeeft te veranderen. Plak eerst de volledige code in de Arduino IDE en upload het naar uw 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() {
for (int i=2; i<=9; i++) {
pinMode(i, OUTPUT);
pinMode(i+44, OUTPUT);
digitalWrite(i, LOW);
digitalWrite(i+44, HOGE);
}
pinMode(A0, INGANG);
}
void loop() {
for (int i=0; i<8; i++) {
als ik==0) {
digitalWrite(9, LAGE);
}
else {
digitalWrite(i+1, LAGE);
}
for (int j=0; j<8; j++) {
als (toDisplay == 1) {
digitalWrite(j+46, LAAG);
}
else {
digitalWrite (j + 46, hoog);
}
}
digitalWrite (i + 2, hoog);
vertraging(1);
}
}
|
laten we vervolgens doorlopen hoe elk van deze secties werken.
|
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}
};
|
voor een van de hoofdlussen in de schets, zal deze multi-dimensionale array bepalen welke LED ‘ s moeten worden verlicht en welke donker moeten blijven. Er zijn acht rijen van elk acht waarden, die overeenkomen met de acht rijen LEDs op de matrix. Door ze in een raster in de schets te leggen, wordt het makkelijker om te visualiseren welke vorm de LED ‘ s zullen vormen.
|
1
2
3
4
5
6
7
8
9
|
void setup() {
for (int i=2; i<=9; i++) {
pinMode(i, OUTPUT);
pinMode(i+44, OUTPUT);
digitalWrite(i, LOW);
digitalWrite(i+44, HOGE);
}
pinMode(A0, INGANG);
}
|
in de setup() sectie, zullen we de pins initialiseren die we nodig hebben voor de matrix. Aangezien er zestien verschillende pinnen zijn, kunnen we dit efficiënter doen dan één voor één. De pinnen die naar de grond lopen worden aangesloten op pinnen 2 tot en met 9. De pinnen die stroom naar de matrix sturen, lopen naar pinnen 46 tot en met 53. Deze sectie zal een lus gebruiken om beide sets pins te initialiseren.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
void loop() {
for (int i=0; i<8; i++) {
als ik==0) {
digitalWrite(9, LAAG);
}
else {
digitalWrite(i+1, LAGE);
}
for (int j=0; j<8; j++) {
als (toDisplay == 1) {
digitalWrite(j+46, LAGE);
}
else {
digitalWrite(j+46, HOGE);
}
}
digitalWrite(i+2, HIGH);
vertraging(1);
}
}
|
In de main loop() gedeelte van de sketch, er is een multi-step-loop. Het eerste if statement zal de laatst gebruikte rij resetten naar laag, wat zal stoppen met stroomtoevoer naar het.
de volgende geneste lus zal de gegevens in de array controleren. Als een cel wordt vermeld als 1, zal het de aarddraad voor die kolom te laag, waardoor de stroom uit te stromen. Anders wordt de pin op hoog gezet, wat voorkomt dat een circuit langs die kolom wordt voltooid. Het zal dit doen voor alle acht cellen in een bepaalde rij.
ten slotte zal het laatste digitalwrite() statement de hele rij aanzetten. Alle kolommen die op laag zijn ingesteld, zullen oplichten. De rest blijft donker. Wanneer de schets weer loops, het zal onmiddellijk beginnen met het uitschakelen van die rij.
het laatste commando is een delay () statement dat de vertraging tussen elke rij instelt. Het is ingesteld op 1 milliseconde in ons voorbeeld, want als het statement er niet is, worden de LEDs een beetje te dim. U kunt echter de vertraging verhogen om te zien wat de schets langzamer doet. U moet elke rij één voor één zien oplichten, voordat u uitschakelt als de volgende rij wordt ingeschakeld.
de bedrading
voor dit project is de bedrading relatief eenvoudig, er is gewoon veel van. Aangezien er veel pinnen zijn, zullen we beschrijven wat je wilt doen voor elk compleet circuit, in plaats van een lijst van elke afzonderlijke draad zoals we meestal doen.
pinnen 2 tot en met 9 zouden uw power pinnen moeten zijn, en pinnen 46 tot en met 53 zouden uw ground pinnen moeten zijn. Voer een draad uit van de power pin, naar de led matrix (controleer voor meer details over welke pinnen hieronder – Dit is belangrijk), van de led matrix in een 220 ohm weerstand, en voer vervolgens een draad terug naar een pin op de Arduino. Speld 2 zou uiteindelijk tot speld 46 moeten leiden, speld 3 zou etc. tot speld 47 moeten leiden.
de belangrijkste complicatie hier is de led-matrix zelf. Contra-intuïtief zijn de pinnen aan weerszijden van de matrix helemaal niet in een samenhangende volgorde. Bijvoorbeeld, we willen pin 2 aan de macht wat we noemen Rij A. Maar de pin voor dit is de vierde pin van links op de bovenkant van de led matrix. Het andere uiteinde van dit circuit – dat naar kolom 1 moet leiden-is de eerste pin rechts aan de onderkant van de matrix.
omdat deze volgorde nogal ingewikkeld is, zullen we spellen op welke pinnen op de matrix elke Arduino pin direct moet worden aangesloten.
aan de bovenkant van de matrix (de zijde met het nummer erop) bevinden zich acht pinnen. Van links naar rechts, deze moet verbonden worden met de volgende pinnen van de Arduino:
- Pin 7
- Pin 4
- Pin-49
- Pin 2
- Pin-51
- Pin-52
- Pin 3
- Pin 5
Volgende, de onderste rij van acht pinnen op de matrix (de kant zonder nummers) moet worden aangesloten aan de volgende pinnen (van links naar rechts, met de nummers nog steeds naar boven):
- Pin 9
- Pin-50
- Pin-48
- Pin 6
- Pin-53
- Pin-8
- Pin-47
- Pin 46
Nadat alle kabels zijn aangesloten, kunt u op uw project en u zult zien dat uw LED-matrix oplichten. Probeer de rangschikking van 1s in de initiële array te veranderen en het script opnieuw te uploaden om verschillende vormen te maken. U kunt ook de lengte van de opdracht delay() aanpassen om elke rij één voor één te zien oplichten.