Avtorja: Vladimir Mitrović in Robert Sedak
V Geekcreit kompletu najdemo tri LED displeje (slika 23). V tem članku bomo pokazali, kako jih povezati z Arduino UNO ploščico in kako jih “oživeti” z ustreznimi programi.
Najenostavnejši je enojni 7-segmentni displej, na sliki 23 prikazan spodaj desno. Tak displej je sestavljen iz sedmih paličastih svetlečih diod, zloženih na način, da tvorijo obrise številke 8, in ene točkaste LED-ice, ki predstavlja decimalno piko. Segmenti se običajno označujejo s črkami od A do G, decimalna pika pa je označena kot DP (slika 24). Če vklopimo kombinacije LED-ic prikazane na sliki 24, se bo na displeju izpisala ena od številk 0-9. Na 7-segmentnem displeju je možno prikazati tudi nekaj črk, kot so A, b, C, d, E, F, H, L ali P ali, očitno pa ne vseh.
Ta vsebina je samo za naročnike
Če želite odkleniti to vsebino, se naročite.
Da bi zmanjšali število priključkov na ohišju 7-segmentnega displeja, so vsi anodni ali vsi katodni priključki LED-ic vezani skupaj. Displej 5161BS iz Geekcreit kompleta je s skupno anodo in ta priključek se veže na + pol napajalne napetosti. Katodni priključki se preko uporov upornosti okoli 1 kΩ vežejo na priključke Arduino UNO ploščice: kadar Arduino program postavi enega od teh priključkov v stanje logične ničle, bo skozi pridruženi segment stekel tok in segment bo zasvetil. Prikaz na enojnem 7-segmentnem displeju ne predstavlja zahtevne programske naloge, zato ga tukaj ne bomo analizirali. Rajši se bomo posvetili modulu s štirimi 7-segmentnimi displeji, prikazanim na sliki 23 zgoraj desno. Štirištevilčni displej iz Geekcreit kompleta, 3461BS, je prav tako s skupno anodo: anode vseh LED-ic, ki tvorijo eno številko so povezane skupaj. Pri večštevilčnih displejih so znotraj ohišja medsebojno povezane tudi katode istoimenskih priključkov, tako da imamo na ohišju displeja po en priključek za skupaj vezane anodne priključke vsakega digita, in po en priključek za skupaj vezane katodne priključke vseh istoimenskih segmentov.
Shema na sliki 25 prikazuje, kako to izgleda pri displeju 3461BS. Oznake D1-D4 ustrezajo po vrsti skupnim anodam prvega, drugega, tretjega in četrtega digita, gledano z leve v desno. Priključek A je skupen katodni priključek A segmentov vseh digitov, in tako naprej. Izhodni priključki niso razporejeni po nekem logičnem vrstnem redu, zato moramo zelo paziti pri povezovanju na Arduino UNO! Na Arduinu smo seveda uvedli več reda: priključki 11-8 so povezani z anodnimi priključki D1-D4, priključki 7-0 so preko uporov R1-R8 povezani s katodnimi priključki A-DP.
Način na katerega so povezani posamezni priključki znotraj 3461BS displeja je običajen je za vse večštevilčne 7-segmentne displeje, ker se tako prihrani na številu krmilnih priključkov mikrokontrolerja. V konkretnem primeru je za krmiljenje displeja potrebnih 12 namesto 32 priključkov! Vendar pa tak način povezovanja prinaša tudi določene omejitve: nemogoče je v istem trenutku vključiti različne kombinacije segmentov na različnih digitih! Problem bomo rešili na sledeč način:
- priključke 11-8 bomo postavili v stanje logične ničle in tako ugasnili vse digite;
- priključke 7-0 bomo postavili v logična stanja, ki ustrezajo številu, ki ga želimo prikazati na prvem digitu, pri čemer logična ničla vključuje pridruženi segment;
- kratkotrajno bomo postavili priključek 11 v stanje logične enice in tako vključili prvi digit;
- ko bomo priključek 11 vrnili v stanje logične ničle, bomo priključke 7-0 postavili v logična stanja, ki ustrezajo številu, ki ga želimo prikazati na drugem digitu;
- kratkotrajno bomo postavili priključek 10 v stanje logične enice in tako vključili drugi digit;
- postopek bomo ponoviti za tretji in četrti digit, in nato spet pričeli od začetka.
Opisani postopek se imenuje multipleksiranje in nam omogoča, da na različnih digitih prikazujemo različne vsebine. Če se odvija dovolj hitro, 50 ali večkrat v sekundi, se nam bo zdelo, da vsi digiti svetijo sočasno. Ker pa segmenti posameznega digita svetijo komaj četrtino časa, bo intenzivnost svetlobe manjša kot če bi imeli možnost neodvisnega krmiljenja z vsakim posameznim segmentom. To bomo kompenzirali s povečanjem toka skozi segmente, pri čemer moramo paziti na možnost mikrokontrolerja in LED-ic. Poglejmo kako bomo izbrali optimalno vrednost upornosti uporov R1-R8:
Če so stalno vključeni, bodo segmenti jasno svetili takrat, ko skozi njih tečejo tokovi jakosti 2-3 mA, kar dosežemo z upori upornosti 1 kΩ. Da bi kompenzirali padec intenzitete zaradi multipleksiranja, bomo zmanjšali njihove upornosti na četrtino. V Geekcreit kompletu imamo prav prikladne upore upornosti 220 Ω, pri katerih bi maksimalni tokovi segmentov bili malo večji od 10 mA, srednji tok pa idealnih 2,5 mA: številke 7-segmentnega displeja bi svetile z enako intenzivnostjo, kot da sploh ne bi bilo multipleksiranja.
No, taka rešitev pač ni dobra! Če vključimo sočasno vse segmente neke številke, bo skozi »skupen« priključek stekel tok večji od dovoljenih 40 mA (skupni so priključki 8-11, na katerih vključujemo posamezen digit displeja). Zato bomo za upore R1-R8 izbrali prvo naslednjo vrednost iz Geekcreit kompleta, 330 Ω. Če upoštevamo tudi padce napetosti, ki nastajajo notranjih uporih izhodnih priključkov mikrokontrolerja (njihova tipična vrednost znaša okoli 25 Ω), bo pri takšni vrednosti upornosti v najslabšem primeru maksimalen tok skozi skupne priključke malo višji od 40 mA.
S tako kompromisno izbrano vrednostjo upornosti smo ohranili mikrokontroler, prikaz na 7-segmentnem displeju pa bomo še vedno lahko jasno razbrali tudi pri močnejši dnevni svetlobi. Če bi kljub temu potrebovali večjo intenzivnost prikaza, bi morali ojačiti moč skupnih izhodnih priključkov mikrokontrolerja z dodajanjem tranzistorjev. Takrat bi lahko dovolj zmanjšali vrednosti uporov R1-R8, brez nevarnosti, da bi preobremenili priključke mikrokontrolerja. Ker ustreznih tranzistorjev ni v kompletu komponent, ne bomo naprej opisovali te možnosti.
Da bi lahko preverili programsko rešitev postopka multipleksiranega prikaza, bomo komponente s sheme postavili na veliko testno ploščico po risbi na sliki 26. Vsi upori imajo enake vrednosti upornosti, zato ni pomembno, kakšno oznako ima kateri. Pri postavljanju displeja moramo paziti na to, da bodo decimalne pike obrnjene »proti spodaj«.
6. programska naloga
Napišite program za vezje s slik 25 in 26, ki bo zajemal napetost na drsniku potenciometra P1 in bo vrednosti v razponu 0-1023 prikazal na četvernem 7-segmentnem displeju!
Arduino rešitev (program Geekcreit_6.ino)
Napisali bomo dve funkciji: prva bo prikazovala eno številko, druga pa večštevično število. Funkcijo za izpisovanje številke bomo poimenovali displayDigit(), in ji dodelili tri parametre:
- digit vrste byte – z njim bomo definirali, kateri digit bo prikazan,
- number vrste byte – z njim bomo definirali, katero število bo prikazano in
- show vrste bool – z njim bomo definirali vklop LED-ic neke številke.
V funkciji najprej definiramo polje DIGIT[], v katerem so opisane številke 0 do 9. Prvi bajt polja (njegov indeks je 0) vsebuje razpored LED-ic, ki jih je treba vključiti tako, da bi formirale številko 0, drugi bajt (indeks = 1) vsebuje razpored LED-ic za prikaz številke 1, itd.:
void displayDigit(byte digit, byte number, bool show){ // ABCDEFG.
const byte DIGIT[] = {B00000011, // 0
B10011111, // 1
B00100101, // 2
B00001101, // 3
B10011001, // 4
B01001001, // 5
B01000001, // 6
B00011111, // 7
B00000001, // 8
B00001001}; // 9
Nato preverjamo, ali mora biti digit prikazan ali ne. Če da, prenesemo indeksirani element polja na port D in postavimo ustrezen priključek v stanje 1. V kolikor ni treba, da je digit prikazan, postavljamo ustrezen priključek v stanje 0. Npr., če mora število biti prikazano na mestu enote, takrat bo vrednost spremenljivke digit enaka 1, priključek za vklop LED-ic je 8. V kolikor mora biti prikazan na mestu desetic, bo vrednost spremenljivke digit enaka 2, priključek za vklop LED-ic je 9, itd.
if (show) {
PORTD = DIGIT[number];
digitalWrite(7+digit, HIGH);
} else {
digitalWrite(7+digit, LOW);
}
}
Funkciji za prikaz številke prenesemo samo en parameter, število ki ga želimo prikazati. Poimenujmo jo displayNumber():
void displayNumber(int number){
V njej definiramo spremenljivko digit, ki bo vsebovala mesto digita, ki ga bomo prikazali.
byte digit = 1;
Število, ki ga želimo prikazati se nahaja v spremenljivki number. Najprej bomo preverili, če je to število večje od ničle:
če je enako ničli, bomo prikazali številko 0 na mestu enote v trajanju 2 ms;
če je večje od ničle, bomo v while() zanki razdelili digit po digit in jih prikazovali po vrsti na mestu enota, desetica, stotica in tisočica.
To razdeljevanje digitov delamo tako, da izračunamo ostanek deljenja s številom 10 in ga prikazujemo na mestu digita shranjene v spremenljivki digit v trajanju po 2 ms. Ko smo razdelili številko, vsebino spremenljivke number delimo z 10, da bi v naslednji iteraciji lahko prikazali naslednjo številko. Opazili boste da je spremenljivka number celoštevična spremenljivka, zato bo vrednost po deljenju ostala celo število.
void displayNumber(int number){
byte digit = 1;
if (number > 0) {
while (number > 0) {
int shownumber = number % 10;
number = number / 10;
displayDigit(digit, shownumber, 1);
delay(2);
displayDigit(digit, shownumber, 0);
digit ++;
}
while (digit <= 4) {
delay(2);
digit++;
}
} else {
displayDigit(1, 0, 1);
delay(2);
displayDigit(1, 0, 0);
}
}
Prva while() zanka se izvršuje vse dokler je vsebina spremenljivke number večja od ničle, in v njej se po vrsti prikazujejo vse številke, razen vodečih ničel. Če ima število ima manj od štirih digitov, se bodo prikazovali bolj pogosto in zato bodo digiti »krajših« števil svetili močneje. To bo posebej prišlo do izraza, ko želimo prikazati enoštevilčna števila. Tu nam pomaga druga while() zanka, v kateri dodajamo po 2 ms za vsako neprikazano vodečo ničlo: tako da bo frekvenca prikaza posamezne številke trajala enako dolgo, neodvisno od števila digitov, ki jih moramo prikazati. V tabeli 2 lahko vidite spremembe vrednosti spremenljivk po iteracijah while() zanke.
Iteracija number digit shownumber digit/10
1 1023 1 3 102
2 102 2 2 10
3 10 3 0 1
4 1 4 1 0
Opisane funkcije bomo, kot običajno, postavili na konec programa. Sedaj pojdimo od začetka! V glavnem programu bomo najprej preimenovati priključek A3 v POT:
const byte POT = A3;
V funkciji setup() konfiguriramo vse priključke vezane na 7-segmentni displej kot izhodne, in takoj nato izključimo vse številke:
void setup() {
for (int i = 0; i <= 15; i++) {
pinMode(i, OUTPUT);
}
for (int i = 0; i <= 7; i++) {
digitalWrite(i, LOW);
}
}
V funkciji loop() preberemo stanje potenciometra in ga izpišemo na displeju s klicem funkcije displayNumber():
void loop() {
int potValue = analogRead(POT);
displayNumber(potValue);
}
Važna opomba: opisi načinov multipleksiranja štirištevilčnega 7-segmentnega displeja in program Geekcreit_6.ino nanašajo se na displej s skupnimi anodami, kot 3461BS. V nekaterih Geekcreit kompletih se nahajajo displeji sa skupnimi katodami, kot SMA420564. Displeji so pin-kompatibilni, način dela z displejem s skupnimi katodami je obrnjen od opisa, ki smo dali: posamezni digiti se vklapljajo z logično ničlo, segmenti se vključujejo z logičnimi enicami. Temu je prilagojen program Geekcreit_6_ck.ino.
Največji in najzahtevnejši LED displej iz Geekcreit kompleta je prikazan na sliki 23 levo. Sestavlja ga matrica 64 LED-ic, ki so razporejene v 8 vrst s po 8 LED-ic v vsaki vrsti (slika 27 desno). Če želimo vključiti posamezno LED-ico, moramo izhodni priključek Arduino Uno ploščice, na katerega je povezana njena anoda, sočasno postavili v stanje logične enice, priključek na katerega je vezana njena katoda pa v stanje logične ničle.
Prikaz na displeju lahko multipleksiramo vrsto po vrsti ali stolpec po stolpcu. Upori R1-R8 omejujejo tokove skozi LED-ice na okoli 8 mA; to bo proizvedlo dovolj močan blisk svetlobe, da bi bila vključena LED-ica dobro vidna tudi pri dnevni svetlobi, čeprav je realno vključena samo 1/8 časa. Vrednosti uporov so izbrane po istem kriteriju, kot v predhodnem primeru. Če so upori vezani kot na shemi na sliki 27, moramo prikaz multipleksirati stolpec po stolpcu:
priključke 7-0 bomo postavili v stanje logične enice in tako ugasnili vse stolpce;
priključke 15-8 bomo postavili v logična stanja, ki ustrezajo kombinaciji LED-ic, ki jih želimo vključiti v prvem stolpcu, pri čemer logična enica vklopi, ničla pa izklopi LED-ico;
kratkotrajno bomo postavili priključek 0 v stanje logične ničle in tako vključili LED-ice iz prvega stolpca;
ko priključek 0 vrnemo v stanje logične enice, bomo priključke 15-8 postavili v logična stanja, ki ustrezajo kombinaciji LED-ic, ki jih želimo vključiti v drugem stolpcu;
kratkotrajno bomo postavili priključek 1 v stanje logične ničle in tako vključili LED-ice iz drugega stolpca;
postopek bomo po vrsti ponavljati za vse naslednje stolpce, in nato spet pričeli od začetka.
Da bi na displeju dobili stabilni prikaz, bez utripanja moramo tudi tukaj celoten postopek ponavljati najmanj 50-krat v sekundi.
Opomba: isti displej lahko na podoben način multipleksiramo tudi vrsto po vrsti, v tem primeru moramo premestiti upore R1-R8 v vezi vezane na priključke 0-7!
Zaradi velikosti matričnega displeja bomo morali uporabiti veliko in malo testno ploščico (slika 28). Vsi upori imajo enake vrednosti upornosti, zato ni pomembno, kateri ima katero oznako. Matrični displej bomo obrnili tako, da bo oznaka tipa displeja obrnjena »proti spodaj«, oziroma, da se nahaja na veliki testni ploščici.
7. programska naloga
Napišite program za vezje s slika 27 in 28, ki bo na matričnem LED displeju vžigala LED-ice po vrsti po vzorcu prikazanem na sliki 29. Ko se vžgejo vse LED-ice, jih mora program ugašati eno po eno v obrnjenem vrstnem redu.
Arduino rešitev (program Geekcreit_7.ino)
Program bomo razdelili na dva logična dela: prvi del bo definiral katere LED-ice morajo biti vklopljene, drugi del jih bo vklapljal in izklapljal. Za definicijo LED-ic uporabimo polje display8x8 velikosti osem bajtov. Prvi bajt predstavlja prvi (levi) stolpec, drugi bajt predstavlja drugi stolpec itd. V vsakem bajtu skrajni levi bit označuje prvo vrsto gledano od zgoraj, končni desni bit pa označuje spodnjo vrsto. Podatke iz polja bomo prenašali na LED-ice v prekinitveni rutini (OVF ISR) Timerja 2. Z ustreznim deljenjem dosežemo, da se izvrši približno 61-krat v sekundi:
16 MHz : 256 : 1024 = 61,035 Hz
Na ta način smo zagotovili, da se stanje na LED matrici ažurira dovolj hitro tudi v pravilnih časovnih razmikih.
Polje display8x8 mora biti tipa volatile, ker ga bomo uporabili v ISR rutini. Po njemu definiramo spremenljivko animationDelay, v kateri določamo 20 ms pavzo pred novo spremembo prikaza:
volatile byte display8x8[8] = {0, 0, 0, 0, 0, 0, 0, 0};
byte animationDelay = 20;
V funkciji setup() konfiguriramo vse priključke vezane na LED matrico kot izhodne in takoj nato izklopimo vse stolpce:
void setup() {
for (int i = 0; i <= 15; i++) {
pinMode(i, OUTPUT);
}
for (int i = 0; i <= 7; i++) {
digitalWrite(i, HIGH);
}
Sedaj se bomo pozabavali s konfiguriranjem timerja Timer2. Najprej bomo v ustrezne kontrolne registre vpisali vrednost 0:
TCCR2A = 0;
TCCR2B = 0;
Postavimo bitove delitelja takta, da bi dosegli želeni faktor 1024:
bitWrite(TCCR2B, CS20, 1);
bitWrite(TCCR2B, CS21, 1);
bitWrite(TCCR2B, CS22, 1);
ISR se mora aktivirati takrat, ko števec Timerja 2 preskoči iz stanja 255 v stanje 0, kar predstavlja dodatno deljenje s faktorjem 256; to dosežemo s postavljanjem TOIE2 bita v TIMSK2 registru:
noInterrupts();
bitWrite(TIMSK2, TOIE2, 1);
interrupts();
}
Opazili boste, da smo pred spremembo konfiguracijskih bitov morali onemogočiti prekinitve! Ko smo jih ponovno vključili, bo mehanizem prekinitev delal tako, kot smo si zamislili.
V nalogi je definirano, da se morajo LED-ice vklapljati v koncentričnih kvadratih, ki so štirje. Zato bomo v funkciji loop() najprej definirali zanko, s katero definiramo iz katerega koncentričnega kvadrata vklapljamo LED-ice:
void loop() {
for (int j = 0; j <= 3; j++) {
Sedaj v polju display8x8 vklopimo zgornjo vrsto kvadrata z leve v desno in s pavzo definirano v spremenljivki animationDelay:
for (int i = j; i <= 7-j; i++) {
display8x8[i] |= (B10000000 >> j);
delay(animationDelay);
}
Nato vklopimo LED-ice v desnem stolpcu od zgoraj proti dol
for (int i = 6-j; i >= j; i–) {
display8x8[7-j] |= (1 << i);
delay(animationDelay);
}
in v spodnji vrsti z desne v levo
for (int i = 6-j; i >= j; i–) {
display8x8[i] |= (1 << j);
delay(animationDelay);
}
in končno, v levem stolpcu kvadrata od spodaj proti zgoraj:
for (int i = 1+j; i <= 6-j; i++) {
display8x8[j] |= (1 << i);
delay(animationDelay);
}
}
In na koncu izklopimo LED-ice v koncentričnih kvadratih, vendar v nasprotni smeri:
for (int j = 3; j >= 0; j–) {
for ( int i = 6-j; i >= 1+j; i–) {
display8x8[j] &= ~(1 << i);
delay(animationDelay);
}
for (int i = j; i <= 6-j; i++) {
display8x8[i] &= ~(1 << j);
delay(animationDelay);
}
for (int i = j; i <= 6-j; i++) {
display8x8[7-j] &= ~(1 << i);
delay(animationDelay);
}
for (int i = 7-j; i >= j; i–) {
display8x8[i] &= ~(B10000000 >> j);
delay(animationDelay);
}
}
}
Sedaj bomo definirali ISR rutino TIMER2_OVF_vect, v kateri bomo, stolpec po stolpec, prikazovali vsebino polja display8x8[]:
ISR(TIMER2_OVF_vect) {
for (byte column = 0; column <=7; column++) {
Prvih šest vrst od spodaj proti zgoraj se prenašajo na priključke 8-13, katere krmili port B; zato bomo izločili samo bite, ki so namenjeni portu B:
PORTB = display8x8[column] & B00111111;
Gornji dve vrsti se prenašata na priključke A0 in A1 (14 in 15), katera krmili port C. Ta dva bita bomo izločili, premaknili za 6 oziroma 7 mest v desno in s pomočjo ukaza digitalWrite() jih vpisali na priključke 14 in 15:
digitalWrite(15, (display8x8[column] &
B10000000) >> 7);
digitalWrite(14, (display8x8[column] &
B01000000) >> 6);
Vsak stolpec vklopimo za 1 ms in ga takoj nato izklopimo:
digitalWrite(column, LOW);
delay(1);
digitalWrite(column, HIGH);
}
}
8. programska naloga
Napišite program za vezje s slik 27 in 28, ki bo na matričnem LED displeju narisal Smeška pro vzorcu na sliki 30. Displej nima dovolj LEDica za boljšo resolucijo, zato bomo Smeška naredili bolj atraktivnega tako, da nam »namigne« ko pritisnemo tipko T1.
Arduino rešitev (program Geekcreit_8.ino)
Uporabili bomo isti princip prikaza kot v predhodni nalogi, izgled Smeška bomo definirali v poljih SMILEY1[] in SMILEY2[]. Priključek A5, na katerega je vezana tipka, bomo v programu klicali T1:
const byte SMILEY1[] = {B01111100, // 0 stolpec
B10000010, // 1 stolpec
B10101001, // 2 stolpec
B10000101, // 3 stolpec
B10000101, // 4 stolpec
B10101001, // 5 stolpec
B10000010, // 6 stolpec
B01111100}; // 7 stolpec
const byte SMILEY2[] = {B01111100, // 0 stolpec
B10000010, // 1 stolpec
B10001001, // 2 stolpec
B10000101, // 3 stolpec
B10000101, // 4 stolpec
B10001001, // 5 stolpec
B10000010, // 6 stolpec
B01111100}; // 7 stolpec
const byte T1 = A5;
Da bi prikazali Smeška je dovolj prepisati vsebina enega od teh polj v polje display8x8[]. To bomo naredili v funkciji loop(): če je tipka T1 pritisnjena prepisujemo vsebina polja SMILEY2[], če ni, prepisujemo vsebina polja SMILEY1[]:
void loop() {
if (digitalRead(T1) == 0) {
for (int i = 0; i <= 7; i++){
display8x8[i] = SMILEY2[i];
}
} else {
for (int i = 0; i <= 7; i++){
display8x8[i] = SMILEY1[i];
}
}
}
Tako nam bo Smeško namignil vsakič, ko pritisnemo tipko. ISR rutina ostane nespremenjena.
Opomba: Programe Geekcreit_6.ino, Geekcreit_6_ck.ino, Geekcreit_7.ino in Geekcreit_8.ino lahko brezplačno dobite od uredništva revije Svet elektronike.
_
_
https://svet-el.si
