7 szegmenses kijelző, ciklusok - Arduino és programozása
Keresés a weboldalon
Programozási alapismeretek
Főmenü:
7 szegmenses kijelző, ciklusok
Haladás > 3. 7 szegmenses kijelző, xiklusutasítások
6. témakör: 7 szegmenses kijelző kezelése, ciklusutasítás
A 7 szegmenses kijelző, egy tokba elhelyezett 8 darab LED (a 7 szegmens + a pont). A felépítéséról, és a fejlesztő panelon történő kezelésről ide kattintva részletesebb leírás található. A probléma kezelésének első lépése, a kijelzősor vezérlésének megértése. Ehhez oldjunk meg egy egyszerű feladatot, mely a kijelzőn megjelenít egy végtelen, ciklois szerű ábrázolást. A ciklois balról jobbra haladva, az aktuális helyértéken végig megy a 0-t formázó szegmenseken az óra járásával ellentétes irányban járja be a kijelzőt. A helyiérték végére érve átlép a bal szélső helyiértékre, és ismét bejárja az útját. A foglalkozáson ezt a folyamatot egyszerűen, a LED-k fel/le kapcsolásával valósítottuk meg. Próbáld megismételni a programot! Itt egy másik úton, ciklusutasítás használatával oldjuk meg a feladatot. Ehhez ismerjük meg a ciklusutasítást!
Ciklusutasítás
A ciklusutasításról ide kattintva lehet olvasnai! A "for" utasítás felhasználásával építjük fel az egyszerüsített ciklois programunkat. A példa-programban látható, az eredetinél lényegesen kevesebb utasítással is megoldható a feladat, ha ciklusutasítást használunk. Ilyenkor viszont körültekintőbben kell dolgoznunk, és tagolnunk kell a programot. Az áttekinthetőség érdekében használjunk soremeléseket, de válasszuk el a ciklusutasításokat is különféle mélységű bekezdéssel, így látható, mi és hova tartozik. Sok kellemetlenségtől kímélhetjük meg magunkat egy esetleges programhiba esetén, az átlátható, magyarázattal kiegészített programkép használatával.
A mintapélda
/*A program a korábbi ciklois nevű, LED-enkénti fel/lekapcsolással elkészített
műveletsor módosított változata, röviditett, ciklusutasítással megvalósított kivitelben */
byte cikl[] = {34, 35, 36, 37, 32, 33, 34, 30};/*a szegmensek fel/le kapcsolási sorrendje
(d, c, b, a, f, e, d, dp) került egy tömbváltozóba, amit a ciklusutasítás olvas ki egyenként*/
int t = 200;//léptetési időköz
void setup()
{
for ( int i=9; i < 13; i++ )
{
pinMode (i, OUTPUT);
}//helyiértékek portjainak (9-12) kimenetként való egymásutáni beállítása
for ( int i=30; i < 38; i++ )
{
pinMode (i, OUTPUT); //szegmensek portjainak (30-38)ciklusutasítással kimenetként való beállítása
}
}
void loop()
{
for ( int j = 12; j > 8; j--)//kezdeti érték 12, 9-ig csökkentve kapcsolja be és ki egyenként a helyiétéket
{
digitalWrite (j, HIGH);//12-től kezdve, bekapcsol
for ( int i=0; i < 8; i++ ) //belső ciklus a szegmensek kiírására
{
digitalWrite (cikl [i], HIGH);//a tömben tárolt "i" indexű szegmens bekapcsolása
delay (t);
digitalWrite (cikl [i], LOW); //a tömben tárolt "i" indexű szegmens kikapcsolása
}//szegmensek egyenkénti felvillantása, beágyazott ciklus
digitalWrite (j, LOW);//"j" számú helyiérték kikapcsol
}//csupán ennyi a loop-ban a ciklois megvalósítása
}
7 szegmenses kijelző helyiérték kezelése
Mint a foglalkozáson is kiderült, de ide kattinva is olvasható a hétszegmenses kijelzés problémája, nevezetesen túl sok vezetéket kellene használni a 7 szegmenses kijelző közvetlen vezérléséhez. 4 helyiérték esetén, helyiértékenként -a közös ponttal és a pont(DP) használatával- 9, ami 4 helyiérték esetén 36 vezetéket, azaz portot jelent. A Mega ugyan rendelkezik ennyi digitális porttal, de már egy UNO-val sem lehetne megoldani a direkt vezérlést. Létezik hardver megoldás a vezetékszám drasztikus csökkentésére, de a fejlesztő panelra nem került fel ilyen, tehát szoftveresen kell a kijelzést kezelni. Ennek módja, időszeletekbe megjeleníteni a számokat vagy karaktereket, minden időszeletben csupán egy karaktert, ami egymás után gyorsan felvillantva, szemünk tehetetlenségét kihasználva, a 4 karakter együttes látványa jelenik meg. Ide kattintva megtekinthető a vezérlés folyamatábrája!
A mintapélda
/* A decimális számok szegmensmintái byte formátumú tömbbe kerültek.
Helyiértékenként deklarálásra került a bejövő adatok tárolását végző tömb (segma[]..segmd[]
A szegment [] átmeneti kiíró tömbbe kerül a kiirandó adat
Kiírás időszelenként, kiíró rutin használatával, helyiértékek egyenkénti be/kikapcsolásával*/
byte zero [] = {1, 1, 1, 1, 1, 1, 0}; //0 szegmensei
byte one [] = {0, 1, 1, 0, 0, 0, 0}; //1 szegmensei
byte two [] = {1, 1, 0, 1, 1, 0, 1}; //2 szegmensei
byte three [] = {1, 1, 1, 1, 0, 0, 1};//3 szegmensei
byte four [] = {0, 1, 1, 0, 0, 1, 1}; //4 szegmensei
byte five [] = {1, 0, 1, 1, 0, 1, 1}; //5 szegmensei
byte six [] = {1, 0, 1, 1, 1, 1, 1}; //6 szegmensei
byte seven [] = {1, 1, 1, 0, 0, 0, 0};//7 szegmensei
byte eight [] = {1, 1, 1, 1, 1, 1, 1};//7 szegmensei
byte nine [] = {1, 1, 1, 1, 0, 1, 1}; //9 szegmensei
byte szegment [6] = {};//átmeneti szegmensadat tároló
byte segma [7] = {};//1-s helyiérték tároló
byte segmb [7] = {};//10-s helyiérték tároló
byte segmc [7] = {};//100-s helyiérték tároló
byte segmd [7] = {};//1000-s helyiérték tároló
byte a = 0; //aktuális "a" szegmens tárolója
byte b = 0; //aktuális "b" szegmens tárolója
byte c = 0; //aktuális "c" szegmens tárolója
byte d = 0; //aktuális "d" szegmens tárolója
byte e = 0; //aktuális "e" szegmens tárolója
byte f = 0; //aktuális "f" szegmens tárolója
byte g = 0; //aktuális "g" szegmens tárolója
byte dp = 0; //aktuális "dp" szegmens tárolója
int t= 5; // 1 helyiérték felvillantási ideje
int egy = 0;
int tiz = 0;
int szaz = 0;
int ezer = 0;
int num = 0; //ide kerül a kiírandó szám
void setup() {
//30-37 szegmens LED-k kimenetként való beállítása
for ( byte i = 30; i < 38; i++){
pinMode (i, OUTPUT);
}
//9-12 helyiérték bekapcsolók kimenetként való beállítása
for ( byte i = 9; i < 13; i++){
pinMode (i, OUTPUT);
}
}
void loop() {
//adatok feltöltése helyiértékenként a tömbbel megadott számértékre
//a feltöltésre kerülő szám tömbjének nevét mi adjuk meg!
// a kiírásra váró szám átadása "num" nevű változónak
num = 5678; dp = 0;
if (num >= 10000) {
num = 0;}
bont();
if (ezer == 0) { // ha az "ezer" változó 0,
for(int m = 0; m < 7; m++) { // akkor a zero[] tömb adatait olvassa át a ciklus
segmd[m] = zero[m];}} // a helyiértékhez tartozó "segmd" változóba.
if (ezer == 1) { // innen minden az előzőek szerint történik, csak
for(int m = 0; m < 7; m++) { // az 1-s alakiérték miatt itt a one[] került
segmd[m] = one[m];}} // feltöltésre, és így tovább 9-ig
if (ezer == 2) {
for(int m = 0; m < 7; m++) {
segmd[m] = two[m];}}
if (ezer == 3) {
for(int m = 0; m < 7; m++) {
segmd[m] = three[m];}}
if (ezer == 4) {
for(int m = 0; m < 7; m++) {
segmd[m] = four[m];}}
if (ezer == 5) {
for(int m = 0; m < 7; m++) {
segmd[m] = five[m];}}
if (ezer == 6) {
for(int m = 0; m < 7; m++) {
segmd[m] = six[m];}}
if (ezer == 7) {
for(int m = 0; m < 7; m++) {
segmd[m] = seven[m];}}
if (ezer == 8) {
for(int m = 0; m < 7; m++) {
segmd[m] = eight [m];}}
if (ezer == 9) {
for(int m = 0; m < 7; m++) {
segmd[m] = nine[m];}}
// értékadás helyiértékenként 100-s helyiértéken
// a "szaz" valtozó értéke szerinti tömb kerül a segmc˙[] tömbbe
if (szaz == 0) {
for(int m = 0; m < 7; m++) {
segmc[m] = zero[m];}}
if (szaz == 1) {
for(int m = 0; m < 7; m++) {
segmc[m] = one[m];}}
if (szaz == 2) {
for(int m = 0; m < 7; m++) {
segmc[m] = two[m];}}
if (szaz == 3) {
for(int m = 0; m < 7; m++) {
segmc[m] = three[m];}}
if (szaz == 4) {
for(int m = 0; m < 7; m++) {
segmc[m] = four[m];}}
if (szaz == 5) {
for(int m = 0; m < 7; m++) {
segmc[m] = five[m];}}
if (szaz == 6) {
for(int m = 0; m < 7; m++) {
segmc[m] = six[m];}}
if (szaz == 7) {
for(int m = 0; m < 7; m++) {
segmc[m] = seven[m];}}
if (szaz == 8) {
for(int m = 0; m < 7; m++) {
segmc[m] = eight [m];}}
if (szaz == 9) {
for(int m = 0; m < 7; m++) {
segmc[m] = nine[m];}}
// értékadás helyiértékenként 10-s helyiértéken
// a "tiz" valtozó értéke szerinti tömb kerül a segmb˙[] tömbbe
if (tiz == 0) {
for(int m = 0; m < 7; m++) {
segmb[m] = zero[m];}}
if (tiz == 1) {
for(int m = 0; m < 7; m++) {
segmb[m] = one[m];}}
if (tiz == 2) {
for(int m = 0; m < 7; m++) {
segmb[m] = two[m];}}
if (tiz == 3) {
for(int m = 0; m < 7; m++) {
segmb[m] = three[m];}}
if (tiz == 4) {
for(int m = 0; m < 7; m++) {
segmb[m] = four[m];}}
if (tiz == 5) {
for(int m = 0; m < 7; m++) {
segmb[m] = five[m];}}
if (tiz == 6) {
for(int m = 0; m < 7; m++) {
segmb[m] = six[m];}}
if (tiz == 7) {
for(int m = 0; m < 7; m++) {
segmb[m] = seven[m];}}
if (tiz == 8) {
for(int m = 0; m < 7; m++) {
segmb[m] = eight [m];}}
if (tiz == 9) {
for(int m = 0; m < 7; m++) {
segmb[m] = nine[m];}}
// értékadás helyiértékenként 1-s helyiértéken
// az "egy" valtozó értéke szerinti tömb kerül a segma˙[] tömbbe
if (egy == 0) {
for(int m = 0; m < 7; m++) {
segma[m] = zero[m];}}
if (egy == 1) {
for(int m = 0; m < 7; m++) {
segma[m] = one[m];}}
if (egy == 2) {
for(int m = 0; m < 7; m++) {
segma[m] = two[m];}}
if (egy == 3) {
for(int m = 0; m < 7; m++) {
segma[m] = three[m];}}
if (egy == 4) {
for(int m = 0; m < 7; m++) {
segma[m] = four[m];}}
if (egy == 5) {
for(int m = 0; m < 7; m++) {
segma[m] = five[m];}}
if (egy == 6) {
for(int m = 0; m < 7; m++) {
segma[m] = six[m];}}
if (egy == 7) {
for(int m = 0; m < 7; m++) {
segma[m] = seven[m];}}
if (egy == 8) {
for(int m = 0; m < 7; m++) {
segma[m] = eight [m];}}
if (egy == 9) {
for(int m = 0; m < 7; m++) {
segma[m] = nine[m];}}
// helyiértékek kiíratása
for (byte k=0; k < 7; k++) {
szegment [k] = segma [k];
}//1-s helyiérték adat átadása a kiiró tömbbe
digitalWrite(9, HIGH);//1-s helyiérték bekapcsolása
cikl();// kiiró funkcióhívás
delay (t);//időszeletnyi késleltetés
digitalWrite(9, LOW);//1-s helyiérték kikapcsolása
clr ();// aktuális adatok törlése
//10-s helyiérték kiiratása
for (byte j=0; j < 7; j++) {
szegment [j] = segmb [j];
}
digitalWrite(10, HIGH);
cikl ();
delay (t);
digitalWrite(10, LOW);
clr ();
//100-s helyiérték kiiratása
for (byte l=0; l < 7; l++) {
szegment [l] = segmc [l];
}
digitalWrite(11, HIGH);
digitalWrite (30, dp);
cikl();
delay (t);
digitalWrite(11, LOW);
digitalWrite(30, LOW);
clr ();
//1000-s helyiérték kiiratása
for (byte o=0; o < 7; o++) {
szegment [o] = segmd [o];
}
digitalWrite(12, HIGH);
cikl();
delay (t);
digitalWrite(12, LOW);
clr ();
}
void bont () {
ezer = num / 1000;// 1000-s helyiérték leválasztása
szaz = (num - ezer * 1000) / 100;// 100-s helyiérték leválasztása
tiz = (num - ezer * 1000 - szaz * 100) / 10;// 10-s helyiérték leválasztása
egy = num - ezer * 1000 - szaz * 100 - tiz * 10; }
//kiíró funkció, szegmensre bontás, kiírás
void cikl ()
{
a = szegment [0];
b = szegment [1];
c = szegment [2];
d = szegment [3];
e = szegment [4];
f = szegment [5];
g = szegment [6];
digitalWrite(37, a);
digitalWrite(36, b);
digitalWrite(35, c);
digitalWrite(34, d);
digitalWrite(33, e);
digitalWrite(32, f);
digitalWrite(31, g);
}
//átmeneti tároló törlés funkció
void clr () {
a=0; b=0; c=0; d=0; e=0; f=0; g=0;//aktuális szegmensérték 0-s
for (int i=0; i < 7; i++) {
szegment [i] = 0; }
}
