Tartalom:
- Pozitív és negatív számadatok megjelenítése 7 szegmenses kijelző soron
- Beállítható tizedes jegy szám, bekapcsolható zéró elnyomás az értékes jegyek előtt
- Negatív előjel kijelzése az első értékes jegy előtt
- Pozitív és negatív túlcsordulás jelzése (a szám nem fér ki)
- Teljes forráskód, példa program a használathoz
—————————————————————————————————
Egy régebbi barkácsolásból visszamaradt 5db 74HC595 shiftregiszterrel meghajtott 7 szegmenses LED kijelző. Óriás méretűek, legalább 2-3cm magas a karakterkép, de ez most lényegtelen. Fel szerettem volna használni ezt az 5 kijelzőt egy pozitív illetve negatív szám kijelzésére alkalmas számkijelző építésére. A shift regisztereket eredetileg a kijelzők hátoldalára építettem, és a „levegőben” összevezetékeztem. Meglehetősen borzalmasan néz ki, de működik, nem is volt nagy munka. Nyákot nem kellett gyártani, a kijelzőket műanyag patronos ragasztóval „szereltem” össze:
Nagy előny, hogy a kijelzők szegmenseit a 74HC595 shift regiszter folyamatos árammal látja el amikor világítani kel a szegmensnek (a 74HC595 működéséről itt bővebben olvashatsz). Ez lényegesen nagyobb fényerőt eredményez, mint pl. egy MAX7219 IC használata esetén, ami időosztásos módon hajtja meg a szegmenseket és az eredő fényerő így sokkal kisebb.
Ha már elkészült a hardver, írtam egy függvényt, ami kijelez egy számot. Nagyon kényelmes a használata, mert paraméterként egy long típusú változóban át kell adni a kijelzésre szánt számadatot, és ezzel készen is vagyunk. Tizedes érték megjelenítésre is alkalmas, ekkor azonban előtte „egész”-re kell felszorozni, és egy paraméterben beállítható a tizedesjegyek száma, azaz a tizedespont megjelenésének helye. Van egy harmadik paraméter is, amivel beállítható a vezető zeró elnyomás, azaz a szám elején lévő felesleges nullák kikapcsolhatók. Biztos vagyok benne, hogy számtalan hasonló függvény létezik, de szórakoztató volt megírni. Egy ilyen piti feladat végrehajtása után már tudom, hogy miért kellett a holdraszálláshoz közel 10 év és több tízezer ember munkája.
A függvény megírása nem is volt rövid munka, sokat kínlódtam, hogy minden szituációban jól működjön. Különösan a negatív számok és zéró elnyomás esetén volt sok eset amit mind végig kellett gondolni, és helyesen leprogramozni. Azt hiszem, hogy most jól működik. Mivel elég sok munka van benne, érdemesnek tartom arra, hogy megosszam, talán másnak is hasznos. A példa programban a loop()-ban található az a tesztelő programrész, amivel a legtöbb kritikusnak ítélt szituációt leteszteltem. Pár órám ráment, mire minden helyesen működött. A kommentekben található instrukció arra vonatkozóan, hogyan kell átalakítani a programot, ha más 74HC595 kivezetésekre kerültek a szegmensek.
A függvény +99.999 és -9.999 közötti számot tud megjeleníteni. Ha a paraméterben átadott szám nagyobb illetve kisebb mint a megjeleníthető, akkor „>>>” és „<<<” jelekhez hasonló jelzés jelenik meg a kijelzőn. Beállítható, hogy a felesleges vezető nullákat ne jelenítse meg, pl. 00021 helyett 21 lesz a látható eredmény. A tizedes pont helye, azaz a kijelzett szám tizedes jegyeinek száma beállítható. Pl. 0,21 kijelzéséhez a függvénynek át kell adni paraméterként a 21-et tartalmazó változó értéket, második paraméterként 2-őt, mert két tizedesjegyet akarunk látni, illetve harmadik paraméterként a zéró elnyomást jelezni kell 1-el:
sseg_disp(21,2,1);
Zéró elnyomás esetén figyelemebe veszi a tizedespontot, tehát ha a tizedes pont miatt kell vezető nulla, akkor azt oda helyezi. Pl. az előző példa szerinti 0.21-nél is ez történik, nem csinált belőle .21-et! Ezekkel az esetekkel vesződtem sokat, hogy mind jól működjön.
Néhány fotó a működésről. Olyan nagy volt a fényerő, hogy a fotókat sötétíteni kellett, illetve mindegyik másképpen színeződik, így kicsit csúnya lett:
Remélem a példaprogram kommentjei alapján használható a függvény:
/*******************************************************************************************
* Az alábbi memóban némi instrukció található ahhoz, hogy a példa program *
* miért éppen a megadott adatokat küldi a 74HC595 shift regiszterbe ahhoz *
* hogy a megfelelő számjegy jelenjen meg a kijelzőn. *
* Szegmensek kódolása: *
* --a-- *
* f b *
* --g-- *
* e c *
* --d-- dp *
* *
* Az alábbi módon sikerült nekem bekötnöm a LED kijelzők szegmenseit. *
* Tehát ha beírok egy 74HC595 regiszterébe egy alábbi értéket, akkor *
* a megadott szegmens világít. *
* dec érték bin. érték világító szegmens *
* abfgd ce *
* 1 00000001 e *
* 2 00000010 c *
* 4 00000100 dp *
* 8 00001000 d *
* 16 00010000 g *
* 32 00100000 f *
* 64 01000000 b *
* 128 10000000 a *
* *
* Az alábbi táblázat azt adja meg, hogy az általam megvalósított bekötéssel, melyik *
* számjegyet melyik bitsorozat regiszterbe léptetésével lehet megjeleníteni. *
* Számjegy világító szegmensek bin érték dec.érték *
* -------- -------- --------- --- *
* abfgd ce *
* 0 afedcb 11101011 235 *
* 1 bc 01000010 66 *
* 2 abged 11011001 217 *
* 3 abgcd 11011010 218 *
* 4 fgbc 01110010 114 *
* 5 afgcd 10111010 186 *
* 6 afgecd 10111011 187 *
* 7 abc 11000010 194 *
* 8 abfgecd 11111011 251 *
* 9 afbgcd 11111010 250 *
* space 00000000 0 *
* - g 00010000 16 *
* < egd 00011001 25 *
* > gcd 00011010 26 *
*******************************************************************************************/
const byte SH_CP = 8; //chip 11-es láb, órajel bemenet (felfutó élre lépteti be az adatot)
const byte ST_CP = 9; //chip 12-es láb, Latch bemenet (beléptetett adat kimenetre írása, tárolása felfutó éllel)
const byte OE_negalt = 10; //chip 13-as láb, kimenet engedélyező (pwm fényerő szabályozáshoz)
const byte DS = 11; //chip 14-es láb, adatbemenet
const byte disp[]={235,66,217,218,114,186,187,194,251,250,0,16,25,26}; //karakterképek a disp nevű tömbbe töltése
//10-es index értékű elem a space, 11 a negatív jel
long i; //teszteléshez használt változó
void setup()
{
Serial.begin(9600);
pinMode(7, OUTPUT); //74LS595 reset lábához kötött kimenet
digitalWrite(7,LOW);delay(10);digitalWrite(7,HIGH);delay(10); //adunk egy reset jelet (LOW) a chip-nek.
//elvileg a reset bemenetet magas szintre is lehet kötni,
//nem szükséges a reset használata. Törölni az összes bit
//0-ra állításával is lehet.
pinMode(SH_CP, OUTPUT); //74HC595 órajel bemenetére kötött kimenet minden felfutóélnél belépteti a DS-en lévő értéket
pinMode(ST_CP, OUTPUT); //74HC595 Latch bemenetére kötött kimenet lefutóéllel tárolja a beléptetett adatot
pinMode(OE_negalt, OUTPUT); //74HC595 órajel bemenetére kötött kimenet LOW szinttel engedélyezi a kimeneteket, magas szint esetén
//tristate állapotba kerül a led meghajtó kimenet, így egyetlen szegmens sem világít. Fényerőszabályozáshoz
//használatos bemenete a chip-nek.
analogWrite(OE_negalt,0); //pwm jelet adunk a chip OE bemenetére, 0 max. fényerő, 255 a minimális fényerő, mivel 0-nél világitanak a szegmensek
pinMode(DS, OUTPUT); //74HC595 adatbemenetére kötött kimenet, erre léptetjük rá sorban az egyes biteket
}
/**************************************************************************************************
* Ez a loop() egy tesztelésre írt program részemről. Ezzel mutatom be, illetve teszteltem, *
* hogy a megjelenítés minden szituációban jól működik. Különösen a zéró elnyomás tizedes *
* jegyekkel történő kombinálását kellett tesztelni, mert elég sok esetet kellett végig gondolni! *
* Remélem minden szituációt végig próbáltam. *
**************************************************************************************************/
void loop()
{
i=100000; //felső értékhatár átlépése teszt
sseg_disp(i,0,1);
delay(1000);
i=-10000; //als értékhatár átlépése teszt
sseg_disp(i,0,1);
delay(1000);
i=0;
sseg_disp(i,0,0); //nulla megjelenítés tizedespont nélkül, bevezető zéró elnyomás nélkül
delay(1000);
sseg_disp(i,1,0); //nulla megjelenítés, tizedespont a második digiten, bevezető zéró elnyomás nélkül (egy tizedesjegyű szám)
delay(1000); //a többi digiten való tizedespont megjelenítést nem érdemes tesztelni, mert nem befolyásolja a megjelenítést a tizedespont helye
sseg_disp(i,0,1); //nulla megjelenítés tizedespont nélkül, bevezető zéró elnyomással
delay(1000);
sseg_disp(i,1,1); //nulla megjelenítés, tizedespont második digiten, bevezető zéró elnyomással
delay(1000); //az első digiten nincs értelme a tizedespontnak
sseg_disp(i,2,1); //nulla megjelenítés, tizedespont harmadik digiten, bevezető zéró elnyomással
delay(1000);
sseg_disp(i,3,1); //nulla megjelenítés, tizedespont negyedik digiten, bevezető zéró elnyomással
delay(1000); //az ötödik digiten nincs értelme megjeleníteni a tizedespontot
i=-1;
sseg_disp(i,0,1); //nulla megjelenítés tizedespont nélkül, bevezető zéró elnyomással
delay(1000);
sseg_disp(i,1,1); //nulla megjelenítés, tizedespont második digiten, bevezető zéró elnyomással
delay(1000); //az első digiten nincs értelme a tizedespontnak
sseg_disp(i,2,1); //nulla megjelenítés, tizedespont harmadik digiten, bevezető zéró elnyomással
delay(1000);
sseg_disp(i,3,1); //nulla megjelenítés, tizedespont negyedik digiten, bevezető zéró elnyomással
delay(1000); //az ötödik digiten nincs értelme megjeleníteni a tizedespontot
for (i=5;i<16;i++) { //Kijelezett érték nő, nincs tizedespont, így vezető nulla elnyomás történik
Serial.println(i);
sseg_disp(i,0,1);
delay(500);
}
for (i=5;i<16;i++) { //Kijelezett érték nő, de tizedes pont helye miatt van vezető nulla
Serial.println(i);
sseg_disp(i,1,1);
delay(500);
}
for (i=5;i<16;i++) { //még arrébb raktuk a tizedespontot
Serial.println(i);
sseg_disp(i,2,1);
delay(500);
}
for (i=-15;i<-5;i++) { //negatív szám kijelzése, nincs tizedespont, így vezető nulla elnyomás történik
Serial.println(i);
sseg_disp(i,0,1);
delay(500);
}
for (i=-15;i<-5;i++) { //negatív szám kijelzése, de tizedes pont helye miatt van vezető nulla
Serial.println(i);
sseg_disp(i,1,1);
delay(500);
}
for (i=-15;i<-5;i++) { //negatív szám, még arrébb raktuk a tizedespontot
Serial.println(i);
sseg_disp(i,2,1);
delay(500);
}
}
/*****************************************************************************
* Ez a függvény egy jelen esetben 5 digites 74HC595 shift regiszter *
* láncolatra léptet ki egy megadott számadatot. A szám tartománya *
* -9999-től +99999-ig terjed. A tizedespont egy külön paraméterben *
* meghatározott fix helyen jelenik meg. Erre oda kell figyelni, átadni *
* egész értékű számot lehet (long). Beállítható a bevezető nullák elnyomása,*
* ekkor a kisebb számok elején lévő nullák nem jelennek meg. *
* Bemenő paraméterek: *
* szam - long érték -9999 és +99999 között, ezt jelenítjük meg *
* dp - a tizedesjegyek száma. 0 esetén nincs tizedesjegy a kijelzett *
* számban, 1 esetén egy tizedesjegy, 2 esetén két tizedesjegy stb.*
* zeroelnyomas - 0 esetén megjelennek a vezető nullák, míg 1 esetén *
* a kisebb számok vezető nulláit nem jeleníti meg *
* Ha be van állítva tizedespont, akkor a tizedes pont *
* digitjéig mindenképpen megjelenik a vezető nulla pl.: *
* -0.01 *
*****************************************************************************/
void sseg_disp(long szam,byte dp,bool zeroelnyomas) {
byte c4;
byte c3;
byte c2;
byte c1;
byte c0;
bool minusz=false;
if (szam<99999 and szam>-9999)
{
if (szam<0) {minusz=true; szam=-1*szam;}
c4=szam/10000; //tízezres helyiérték számjegyének kiszámítása
c3=(szam-(c4*10000))/1000; //ezres helyiértéken lévő szemjegy kiszámítása
c2=(szam-(c4*10000)-(c3*1000))/100; //százas helyiértéken lévő szemjegy kiszámítása
c1=(szam-(c4*10000)-(c3*1000)-(c2*100))/10; //tizes helyiértéken lévő szemjegy kiszámítása
c0=szam-(c4*10000)-(c3*1000)-(c2*100)-(c1*10); //egyes helyiértéken lévő szemjegy kiszámítása
if (minusz) { //negatív szám vezető nulláinak és mínusz jelnek a kezelése az alábbi ágon
if (!zeroelnyomas) {c4=11;} //ha nincs vezető nulla elnyomás, a bal oldali digit akkor is "-" jelet tartalmaz
else { //van vezető nulla elnyomás, így változtatni kell a karaktereken
if (c3!=0 or dp>=3) {c4=11;} //a legnagyobb helyiérték nulla, és nincs tizedespont, tehát mínuszjelet rakunk
if (c3==0 and dp<3) {c4=10;c3=11;} //az eggyel kisebb helyiérték is nulla, ott sincs tizedespont, így a legnagyobb helyiérték nem világít, ez pedig minusz
if (c3==11 and c2==0 and dp<2) { //az eggyel kisebb helyiérték is nulla, és tizedespont sincs, így a legnagyobb és azt követő helyiérték nem világít, és ez a negatív
c4=10;c3=10;c2=11;
}
if (c3==10 and c2==11 and c1==0 and dp<1) { //még az utolsó előtti helyiérték is nulla és nincs tizedespont, így eddig a helyiértékig semmi nem világít, és ez a mínusz jel
c4=10;c3=10;c2=10;c1=11;
}
}
}
else { //pozitív szám vezető nulláinak kezelése az alábbi else ágon
if (zeroelnyomas) { //csak akkor kell csinálni valamit, ha van vezető nulla elnyomás
if (c4==0 and dp<4) {c4=10;} //legnagyobb helyiérték nulla, nincs ott tizedespont sem, így nem világít a digit
if (c4==10 and c3==0 and dp<3) { //eggyel kisebb helyiérték is nulla és nincs tizedespont, tehát ez sem világít
c4=10;c3=10;
}
if (c4==10 and c3==10 and c2==0 and dp<2) { //eggyel kisebb helyiérték is nulla és nincs tizedespont, tehát ez sem világít
c4=10;c3=10;c2=10;
}
if (c4==10 and c3==10 and c2==10 and c1==0 and dp<1) { //utolsó előtti helyiérték is nulla és nincs tizedespont, tehát ez sem világít
c4=10;c3=10;c2=10;c1=10;
}
}
}
}
else {
if (szam>99999) {c4=12;c3=12;c2=12;c1=10;c0=10;} //ha a szám nagyobb mint 99999, akkor "<<< " jelzi a pozitív túlcsordulást
if (szam<-9999) {c4=10;c3=10;c2=13;c1=13;c0=13;} //ha a szám kisebb mint -9999, akkor " >>>" jelzi a negatív túlcsordulást
}
digitalWrite(ST_CP,0); //Latch bemenetre 0-at kapcsolunk, ekkor lehet beléptetni az adatokat
//sorban beléptetjük az adatokat a kijelző láncolatba. Mivel nálam jobbról lépnek be az adatok, először a lánc legvégén
//lévő chip adatait kell kiléptetni. Mivel a láncolatom 5 db chip-ből áll, 5 shiftout() függvénnyel lép ki egy teljes kijelző tertalom.
//Amennyiben egy adott digitnél tizedespont is kell, a tizedespontot egy bitenkénti vagy művelettel állítjuk be a kiléptetésre
//kerülő adatban.
if (dp==4) {shiftOut(DS, SH_CP, MSBFIRST, disp[c4]|0b00000100);} else {shiftOut(DS, SH_CP, MSBFIRST, disp[c4]);} //balról az első digit beléptetése
if (dp==3) {shiftOut(DS, SH_CP, MSBFIRST, disp[c3]|0b00000100);} else {shiftOut(DS, SH_CP, MSBFIRST, disp[c3]);} //balról második digit beléptetése
if (dp==2) {shiftOut(DS, SH_CP, MSBFIRST, disp[c2]|0b00000100);} else {shiftOut(DS, SH_CP, MSBFIRST, disp[c2]);} //balról harmadik digit beléptetése
if (dp==1) {shiftOut(DS, SH_CP, MSBFIRST, disp[c1]|0b00000100);} else {shiftOut(DS, SH_CP, MSBFIRST, disp[c1]);} //balról negyedik digit beléptetése
shiftOut(DS, SH_CP, MSBFIRST, disp[c0]); //jobbról az első digiten nem lehet tizedespont
digitalWrite(ST_CP,1); //Latch bemenetet vissza állítjuk 1-re, a beléptetett adatokat a chip tárolja, és megjelenik a kimeneteken a beléptetett állapot
}