Pic16f877a mikrokontroller alapú digitális ébresztőóra

Az 1950-ben kezdődött digitális forradalom az összes létező mechanikus és analóg elektronikus szerkezetet digitális számítógépekké változtatja. Mivel a digitális elektronika növekedése exponenciális volt, ma szinte lehetetlen, hogy egy ember ellenálljon bármilyen elektronikus berendezés használatának. Az ébresztőórától kezdve, amely felébreszt, és a kenyérpirítótól, amely reggelit szolgál fel, minden a digitális elektronika hozzájárulása. Mindezekre gondolva, nagyon izgalmas programozni a saját dolgainkat, amelyek egyszerű, mégis hasznos feladatokat képesek elvégezni, például az ébresztőórát, amelyet ebben a projektben a PIC mikrokontrollerrel építünk. Korábban már építettünk ébresztőórát más mikrovezérlőkkel:

• Raspberry Pi ébresztőóra a DS1307 RTC modullal
• Arduino alapú digitális óra riasztással
• Ébresztőóra az ATmega32 mikrokontroller használatával

Ennek az ébresztőórának 16x2-es LCD-kijelzője lesz, amely megjeleníti az aktuális és a beállított időt. Kevés nyomógomb segítségével állíthatjuk be a riasztási időt, amikor szükséges. Az aktuális időt a DS3231 RTC modul segítségével követjük nyomon, és IIC kommunikációt fogunk használni, hogy ezeket az értékeket az RTC modulból kapjuk. Már megtanultuk az RTC modult és annak összekapcsolását a PIC-kel. Ezért ajánlott elolvasni ezt az oktatóanyagot, az adott oktatóanyagban szereplő információk nagy részét kihagyjuk.

Szükséges anyagok:

• Kenyérlap - 2Nos
• PIC16F877A
• 5 V-os áramforrás - Tápegység
• 20 MHz kristály
• 33pf kondenzátor - 2Nos
• DS3231 RTC modul
• 16 * 2 LCD kijelző modul
• 10K POT
• 10k és 1K ellenállás
• Nyomógombok - 5Nos
• Berregő
• Csatlakozó vezetékek

Előfeltételek:

Ehhez a projekthez kevés alapismeret szükséges a PIC mikrovezérlőről és annak programozásáról. Ehhez a projekthez GPIO-kat, LCD-kijelzőt és RTC modult fogunk használni. Ezért jobb, ha előzetesen megtanuljuk ezeket a modulokat használni. A következő linkek segítenek megismerni ugyanezt

• Az első program írása PIC mikrokontrollerrel
• Összekötő LCD és PIC
• I2C kommunikáció PIC segítségével
• DS3231 RTC kapcsolódik a PIC-hez

Kördiagramm:

A PIC alapú ébresztőóra projekt kapcsolási rajza az alábbiakban látható, amelyet a proteus szoftver segítségével hoztak létre. A projektet a továbbiakban szimulációra is felhasználják.

Az öt nyomógomb bemenetként szolgál a riasztás szükséges időre történő beállításához. Tehát az összes nyomógomb egyik vége a földhöz, a többi vége pedig a PORTB csaphoz van csatlakoztatva, ezeken a csapokon belső felhúzási ellenállást fognak használni, hogy elkerüljék a csapok lebegését. A hangjelző kimenetként fog működni, és sípoló hangot ad, amikor a riasztás bekapcsol és a PORT S tűhöz csatlakozik. Az aktuális időt mindig nyomon tartja az a DS3231 RTC modul, ahonnan a PIC az adatokat az I2C buszon keresztül fogadja, így az RTC modul SCL és SDA csapjai csatlakoznak a PIC vezérlő SCL és SDA tűjéhez. A PIC portjához LCD kijelző csatlakozik, amely az aktuális és a beállított idő megjelenítésére szolgál. Tudjon meg többet a DS3231 RTC modul és a PIC használatáról itt.

A teljes áramkör kiépíthető egy kenyérlapon. Mivel pár tucat vezetéket kell csatlakoztatni, legyen türelemmel, és ellenőrizze, hogy a csatlakozások megfelelőek-e. A hardveres beállításom valahogy így nézett ki, miután befejeztem a csatlakozásokat

A modul áramellátásához kenyérlemez-modult és 12 V-os adaptert használtam. Ez az én + 5V tápfeszültségem forrása. Két áramköri táblát kell használnom az áramkör tisztaságának megőrzéséhez. Az egész áramkört egy forrasztópadra is forraszthatja, ha robusztusabb projektet szeretne készíteni.

Programozás ébresztőóra számára:

Az Ébresztőóra projekt teljes PIC programja az oldal alján található. Ehhez a projekthez három könyvtárra is szükség van az LCD, I2C és RTC PIC használatához. A fejlécfájlokkal ellátott teljes kód letölthető a ZIP fájlból, és kibontás után az MPLABX segítségével megnyitható. Az alábbiakban csak a fő c fájlt magyarázom kis részletként. Visszaléphet a fent említett oktatóanyagokhoz, ha meg szeretné tudni, hogyan működnek a fejlécfájlok.

Mielőtt bekerülnénk a főprogramba, meg kell határoznunk azokat a csapokat, amelyeket értelmesebb névvel használtunk. Így a programozás során könnyű lesz használni őket. A programunkban meghatározott csapok az alábbiakban láthatók

// Definiálja az LCD csapokat #define RS RD2 // Visszaállítja az LCD pinjét #define EN RD3 // Engedélyezi az LCD tűjét #define D4 RD4 // Az LCD 0. adatbitje #define D5 RD5 // Az LCD #define 1. adatbitje D6 RD6 // Az LCD 2. adatbitje #define D7 RD7 // Az adatlap 3.bitje // Definiáljon gombokat #define MB RB1 // A középső gomb #define LB RB0 // Bal gomb #define RB RB2 // Jobb gomb # define UB RB3 // Felső gomb #define BB RB4 // Alsó gomb // Define Buzz #define BUZZ RD1 // A buzzer csatlakozik az RD1-hez

A fő funkció belsejében az Input and output csapok deklarálásával kezdjük. A projektünkben a PORTB-t nyomógombokra használják, ami egy beviteli eszköz, ezért a csapjaikat bemenetként állítjuk be, a PORTD-t pedig az LCD-hez és a hangjelzőhöz használjuk, így a csapjaikat kimenetként állítjuk be. Szintén egy tűt soha nem szabad lebegő jelentéssel hagyni, az I / O érintkezőket mindig a földre vagy az + 5 V feszültségre kell csatlakoztatni. A nyomógombok esetében a csapok nem lesznek semmihez csatlakoztatva, ha a gombot nem nyomják meg, ezért használunk egy belső felhúzó ellenállást, amely a csapot magasra állítja, ha nem használják. Ez a vezérlő regiszterek segítségével történik, az alábbiak szerint

TRISD = 0x00; // Készítsen D port tűket outptu-ként az LCD interfészhez TRISB = 0xFF; // A kapcsolókat bemeneti csapokként deklaráljuk OPTION_REG = 0b00000000; // engedélyezése húzza fel Ellenállás porton B switchs BUZZ = 0; // Hangjelzés

Mivel az LCD és az I2C fejlécfájl a fő programhoz van kapcsolva, egy egyszerű funkció meghívásával elindíthatjuk az LCD inicializálását. Ugyanez megtehető az I2C inicializálásnál is. Itt kezdjük az I2C kommunikációt 100 kHz-en, mivel az RTC modul 100 kHz-mel működik.

Lcd_Start (); // Az LCD modul inicializálása I2C_Initialize (100); // Az I2C Master inicializálása 100KHz-es órával

Az alábbi funkció segítségével beállíthatja az időt és a dátumot az RTC modulon, miután beállította az időt és a dátumot, távolítsa el ezt a sort. Minden egyes alkalommal, amikor elindítja a programot, az idő és a dátum újra és újra be lesz állítva

// Távolítsa el az alábbi sort, ha az idő és a dátum először van beállítva. Set_Time_Date (); // idő és dátum beállítása az RTC modulon

Annak jelzésére, hogy a program elindul, megjelenítünk egy kis bevezető képernyőt, amely megjeleníti a projekt nevét és a webhely nevét az alábbiak szerint

// Adjon bevezető üzenetet az LCD-n Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("Ébresztőóra"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __késleltetési_ms (1500);

Ezután a while cikluson belül be kell olvasnunk az aktuális időt és dátumot az RTC modulból, ezt csak az alábbi függvény meghívásával tehetjük meg.

Update_Current_Date_Time (); // Olvassa el az aktuális dátumot és időt az RTC modulból

A fenti függvény meghívásával a sec, min és hour változók az aktuális értékkel frissülnek. Az LCD-képernyőn való megjelenítéshez az alábbi kód segítségével külön karakterekre kell bontanunk őket.

// Bontsa a char-t az lcd-n való megjelenítésre char sec_0 = sec% 10; char sec_1 = (sec / 10); char min_0 = min% 10; char min_1 = min / 10; char hour_0 = óra% 10; char óra_1 = óra / 10;

Ezután frissítjük az értékeket az LCD képernyőn. Az aktuális idő megjelenik az első sorban, és a beállított idő, amikor a riasztást be kell váltani, a második sorban jelenik meg. Az azonos kódot az alábbiakban mutatjuk be.

// Jelenítse meg az aktuális időt az LCD képernyőn Lcd_Clear (); Lcd_Set_Cursor (1, 1); Lcd_Print_String ("IDŐ:"); Lcd_Print_Char (óra_1 + '0'); Lcd_Print_Char (óra_0 + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (min_1 + '0'); Lcd_Print_Char (min_0 + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (sec_1 + '0'); Lcd_Print_Char (sec_0 + '0'); // A dátum megjelenítése az LCD képernyőn Lcd_Set_Cursor (2, 1); Lcd_Print_String ("Riasztás:"); Lcd_Print_Char (alarm_val + '0'); Lcd_Print_Char (alarm_val + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (alarm_val + '0 '); Lcd_Print_Char (alarm_val + '0');

Megjelenítettük az időt és az időt az LCD-n, és ellenőriznünk kell, hogy a felhasználó megpróbálja-e beállítani a riasztási időt. Ehhez a felhasználónak meg kell nyomnia a középső gombot, így ellenőrizni fogjuk, hogy megnyomta-e a középső gombot, és váltani fogunk egy változót, hogy riasztási módba lépjen. Ugyanazt a gombot újra megnyomják, hogy megerősítsék, hogy az értékek be vannak állítva, és ebben az esetben ki kell lépnünk a riasztás beállítása módból. Tehát az alábbi kódsor segítségével megváltoztatjuk a set_alarm változó állapotát .

// A középső gombbal ellenőrizze , hogy be kell-e állítani a riasztást , ha (MB == 0 && set_alarm == 0) {// Ha a középső gombot megnyomja, és a riasztás nincs bekapcsolva, amíg (! MB); // Várjon, amíg a gombot elengedik set_alarm = 1; // riasztási érték beállításának megkezdése } if (MB == 0 && set_alarm == 1) {// Ha a középső gombot megnyomjuk és a riasztást nem kapcsoljuk ki (! MB); // Várjon, amíg a gombot elengedik set_alarm = 0; // leállítja a riasztási érték beállítását }

Ha a felhasználó megnyomta a középső gombot, az azt jelenti, hogy megpróbálja beállítani a riasztási időt. Ebben az esetben a program riasztási módba lép a fenti kód használatával. A riasztási módban, ha a felhasználó megnyomja a bal vagy a jobb gombot, ez azt jelenti, hogy a kurzort balra vagy jobbra kell mozgatnunk. Ehhez egyszerűen csökkenteni kell annak a pozíciónak az értékét, amelyre a kurzort fel kell helyezni

if (LB == 0) {// Ha a bal oldali gombot lenyomjuk, míg (! LB); // Várjon, amíg a gombot elengedik pos--; // Ezután mozgassa a kurzort balra }, ha (RB == 0) {// Ha a jobb oldali gombot lenyomja, míg (! RB); // Várjon, amíg a gombot elengedik pos ++; // Kurzor mozgatása jobbra }

Miközben nyomógombot használ egy mikrokontrollerrel vagy mikroprocesszorral, egy közös problémát kell kezelni. Ezt a problémát kapcsoló pattogásnak nevezzük. Ekkor a gomb lenyomásakor zajos impulzusokat adhat az MCU / MPU, ami hamisíthatja az MCU-t több bejegyzésnél. Ezt a problémát meg lehet oldani kondenzátor hozzáadásával a kapcsolón vagy késleltetési funkció használatával, amint észleli a gombot. Ezt a típusú megoldást visszapattanásnak nevezzük. Itt már használt , miközben hurkot, hogy tartsa a program helyett, míg a gomb elengedésekor. Ez nem a legjobb visszapattanó megoldás, de számunkra ez remekül fog működni.

míg (! RB);

A bal és a jobb gombhoz hasonlóan nálunk is van egy felső és alsó gomb, amelyekkel növelhető vagy csökkenthető a riasztási idő értéke. Az ehhez hasonló kód az alábbiakban látható. Vegye figyelembe, hogy a beállított riasztási idő minden karakterét a tömb indexértéke címzi. Így könnyen elérhetjük a szükséges karaktert, amelynek értékeit meg kell változtatni.

if (UB == 0) {// Ha a felső gombot lenyomják, míg (! UB); // Várjon, amíg a gombot elengedik alarm_val ++; // Növelje az adott char értéket }, ha (BB == 0) {// Ha az alsó gombot lenyomja, míg (! UB); // Várjon, amíg a gombot elengedik alarm_val--; // Csökkenti az adott karakter értéket }

Az ébresztési idő beállítása után a felhasználó ismét megnyomja a középső gombot. Ezután elkezdhetjük összehasonlítani az aktuális időt a beállított idővel. Az összehasonlítás annak ellenőrzésével, hogy az aktuális idő minden egyes karaktere megegyezik-e a beállított idő karakterével. Ha az értékek megegyeznek, akkor a trigger_alarm változó beállításával indítjuk el a riasztást, máskülönben csak összehasonlítjuk, amíg egyenlővé nem válik.

// HA riasztás be van állítva Ellenőrizze, hogy a beállított érték megegyezik-e az aktuális értékkel, ha (set_alarm == 0 && alarm_val == hour_1 && alarm_val == hour_0 && alarm_val == min_1 && alarm_val == min_0) trigger_alarm = 1; // Kapcsolja be a ravaszt, ha az érték megegyezik

Ha a riasztás be van állítva, akkor hangjelzést kell adnunk, hogy figyelmeztessük a felhasználót riasztásra. Ezt úgy tehetjük meg, hogy egyszerűen szabályos időközönként átkapcsoljuk a hangjelzőt az alábbiak szerint.

if (trigger_alarm) {// Ha riasztás aktiválódik // Csipogjon a hangjelzésre BUZZ = 1; __késleltesms (500); BUZZ = 0; __késleltesms (500); }

Szimuláció:

Ez a program a proteus szoftver segítségével is szimulálható. Csak hozza létre újra a fent látható áramkört, és töltse be a hex fájlt a PIC-be. A projekt hex kódja az itt linkelt ZIP fájlban található. A szimuláció során készített képernyőképet az alábbiakban mutatjuk be

A szimuláció nagyon hasznos lesz, ha új funkciókat próbál felvenni a projektbe. Az I2C hibakereső modullal is ellenőrizheti, hogy az I2C buszon keresztül milyen adatok kerülnek be és kijönnek. Megpróbálhatja megnyomni a gombokat, és beállíthatja az ébresztés idejét is. Ha a beállított idő megegyezik az aktuális idővel, akkor a hangjelző magasra megy.

Digitális ébresztőóra működése a PIC16F877A segítségével:

Építse fel az áramkört a táblára, szerezze be a kódot a letöltési hivatkozásból, és fordítsa le az MplabX és az XC8 fordító segítségével. Ha letöltötted a kódot az itt megadott ZIP fájlból, akkor nem okoz gondot a fordítás, mivel a fejlécfájlok már csatolva vannak.

Összeállítása után töltse fel a programot hardveresen a PicKit3 programozó segítségével. A kapcsolót a pickit programozó PIC IC-hez való csatlakoztatásához a kapcsolási rajz is mutatja. A program feltöltése után meg kell látnia a bevezető képernyőt, majd a megjelenített időt, majd a nyomógombokkal beállíthatja az ébresztés idejét. Az áramellátás alatt álló hardverbeállításom az alábbiak szerint néz ki.

Amikor a riasztás ideje megegyezik az aktuális idővel, a hangjelző elkezd csipogni a felhasználó riasztására. A teljes munka az alábbi videón található. A projekt rengeteg lehetőségre épít. Az RTC modul nyomon követheti az időpontot és dátumot, így ütemezett feladatot bármikor elvégezhet. Csatlakoztathat egy váltóáramú készüléket, például ventilátort vagy lámpát, és ütemezheti, hogy szükség esetén be- vagy kikapcsoljon. Még mindig sok mindent fel lehet építeni erre a projektre, tudassa velem, milyen ötlet jut eszébe a projekt frissítéseként, és örömmel értesítem Önt.

Remélem, megértette a projektet, és valami hasznosat tanult a folyamatból. Ha kétségei vannak a projekt iránt, használja a megjegyzés részt a közzétételhez, vagy használja a fórumokat bármilyen technikai segítségért.

A fejlécfájlokkal ellátott teljes PIC-kód itt található