Digitálny budík založený na mikrokontroléri Pic16f877a

Digitálna revolúcia začala v roku 1950 a mení všetky existujúce mechanické a analógové elektronické štruktúry na digitálne počítače. Pretože rast digitálnej elektroniky bol exponenciálny, dnes je takmer nemožné, aby človek odolával použitiu akýchkoľvek elektronických zariadení. Počnúc budíkom, ktorý vás zobudí, a hriankovačom, ktorý vám podáva raňajky, je všetko príspevkom digitálnej elektroniky. Keď na to myslíme všetky, je skutočne vzrušujúce programovať si vlastné veci, ktoré by mohli robiť jednoduché, ale užitočné úlohy, ako je napríklad budík, ktorý v tomto projekte s mikrokontrolérom PIC postavíme. Predtým sme budovali budík s inými mikrokontrolérmi:

Budík Raspberry Pi využívajúci modul RTC DS1307
Arduino digitálne hodiny s budíkom
Budík pomocou mikrokontroléra ATmega32

Tento budík bude mať 16x2 LCD displej, ktorý bude zobrazovať aktuálny čas a nastavený čas. Pomocou niekoľkých tlačidiel nastavíme čas budenia, kedykoľvek je to potrebné. Aktuálny čas bude udržiavaný v stopách pomocou modulu RTC DS3231 a na získanie týchto hodnôt z modulu RTC použijeme komunikáciu IIC. O RTC module a jeho prepojení s PIC sme sa už dozvedeli. Preto sa odporúča prečítať si tento návod, preskočíme väčšinu informácií uvedených v tomto návode.

Potrebné materiály:

Chlebová doska - 2č
PIC16F877A
5V zdroj energie - napájací modul
20 MHz kryštál
33pf kondenzátor - 2Nos
Modul RTC DS3231
16 * 2 modul LCD displeja
10K POT
10k a 1K rezistor
Tlačidlá - 5č
Bzučiak
Pripojovacie vodiče

Predpoklady:

Tento projekt vyžaduje, aby ste vedeli niekoľko základných informácií o mikrokontroléri PIC a o tom, ako ho programovať. Pre tento projekt použijeme GPIO, LCD displej a RTC modul. Je lepšie sa vopred naučiť používať tieto moduly. Nasledujúce odkazy vám pomôžu naučiť sa to isté

Písanie prvého programu pomocou mikrokontroléra PIC
Prepojenie LCD s PIC
Komunikácia I2C pomocou PIC
DS3231 RTC prepojený s PIC

Schéma zapojenia:

Schéma zapojenia tohto projektu budíka na základe PIC je uvedená nižšie, ktoré bolo vytvorené pomocou softvéru proteus. V tomto projekte sa tiež použije na simuláciu.

Päť tlačidiel bude slúžiť ako vstup pre nastavenie budíka na požadovaný čas. Takže jeden koniec všetkých tlačidiel je pripojený k zemi a druhý koniec je pripojený k kolíku PORTB, na tieto piny sa použije vnútorný pull-up rezistor, aby sa zabránilo plávaniu kolíkov. Bzučiak bude fungovať ako výstup a dá nám pípnutie, keď sa spustí alarm, a je pripojený ku kolíku PORT S. Aktuálny čas je vždy sledovaný modulom RTC DS3231, z ktorého PIC prijíma údaje cez zbernicu I2C, takže piny SCL a SDA modulu RTC sú pripojené k pinu SCL a SDA PIC radiča. K PORTD na PIC je pripojený LCD displej, ktorý slúži na zobrazenie aktuálneho času a nastaveného času. Viac informácií o používaní modulu DS3231 RTC s PIC sa dozviete tu.

Celý obvod je možné postaviť na nepájivej doske. Pretože sa dá pripojiť niekoľko desiatok vodičov, buďte trpezliví a skontrolujte, či sú pripojenia správne. Moje hardvérové nastavenie vyzeralo nižšie asi takto, keď som skončil s pripojeniami

Na napájanie modulu som použil nepájivový modul a 12V adaptér. Toto je môj zdroj napájacieho napätia + 5 V. Tiež musím použiť dva nepájivé panely, aby bol obvod čistý. Celý obvod môžete tiež spájkovať na dosku perf, ak hľadáte robustnejší projekt.

Programovanie budíka:

Kompletný PIC program pre tento projekt budík možno nájsť v dolnej časti tejto stránky. Tento projekt tiež vyžaduje tri knižnice na používanie LCD, I2C a RTC s PIC. Celý kód so hlavičkovými súbormi si môžete stiahnuť zo súboru ZIP tu a po rozbalení ho môžete otvoriť pomocou MPLABX. Ďalej len vysvetľujem hlavný súbor c ako malé úryvky. Ak sa chcete dozvedieť, ako fungujú hlavičkové súbory, môžete sa vrátiť k vyššie uvedeným tutoriálom.

Pred vstupom do hlavného programu si musíme definovať piny, ktoré sme použili so zmysluplnejším názvom. Takto bude ľahké ich používať počas programovania. Kolíky definované v našom programe sú zobrazené nižšie

// Definujte PIN piny #define RS RD2 // Reset pin LCD #define EN RD3 // Aktivujte pin LCD #define D4 RD4 // Dátový bit 0 LCD #define D5 RD5 // Dátový bit 1 LCD #define D6 RD6 // Dátový bit 2 na LCD # definovať D7 RD7 // Dátový bit 3 na LCD // Definovať tlačidlá # definovať MB RB1 // Stredné tlačidlo # definovať LB RB0 // Ľavé tlačidlo # definovať RB RB2 // Pravé tlačidlo # definovať UB RB3 // Horné tlačidlo # definovať BB RB4 // Spodné tlačidlo // definovať Buzz # definovať BUZZ RD1 // Bzučiak je pripojený k RD1

Vo vnútri hlavnej funkcie začneme vyhlásením vstupných a výstupných pinov. V našom projekte sa PORTB používa pre tlačidlá, čo je vstupné zariadenie, takže sme nastavili ich piny ako vstupy a PORTD sa používa pre LCD a bzučiak, takže sme nastavili ich piny ako výstup. Pin tiež nikdy nesmie zostať plávajúci, to znamená, že I / O piny by mali byť vždy pripojené buď k uzemneniu, alebo k napätiu + 5V. V našom prípade pre tlačidlá nebudú kolíky spojené s ničím, keď nie je tlačidlo stlačené, takže použijeme interný pull-up rezistor, ktorý nastaví kolík na High, keď sa nepoužíva. To sa deje pomocou riadiacich registrov, ako je uvedené nižšie

TRISD = 0x00; // Vyrobte kolíky portu D ako čosi pre rozhranie LCD TRISB = 0xFF; // Prepínače sú deklarované ako vstupné piny OPTION_REG = 0b00000000; // Povoliť pull up rezistor na porte B pre prepínače BUZZ = 0; // Zapnutie bzučiaka

Pretože máme hlavičkový súbor LCD a I2C prepojený s hlavným programom, môžeme spustiť inicializáciu LCD zavolaním jednoduchej funkcie. To isté sa dá urobiť aj pre inicializáciu I2C. Tu začíname komunikáciu I2C na 100 kHz, pretože modul RTC pracuje so 100 kHz.

Lcd_Start (); // Inicializácia LCD modulu I2C_Initialize (100); // Inicializujte I2C Master s hodinami 100 KHz

Nasledujúca funkcia slúži na nastavenie času a dátumu na module RTC. Po nastavení času a dátumu tento riadok odstráňte. Pri každom ďalšom spustení programu sa čas a dátum nastavia znova a znova

// Odstráňte nasledujúci riadok raz a dátum je nastavený prvýkrát. Set_Time_Date (); // nastavenie času a dátumu na module RTC

Aby sme naznačili, že program sa spúšťa, zobrazíme malú úvodnú obrazovku, ktorá zobrazuje názov projektu a názov webovej stránky, ako je uvedené nižšie

// Dajte úvodnú správu na LCD displeji Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("Budík"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __delay_ms (1 500);

Ďalej vo vnútri while slučky musíme načítať aktuálny čas a dátum z modulu RTC, čo je možné urobiť jednoduchým zavolaním nižšie uvedenej funkcie.

Update_Current_Date_Time (); // Prečítajte si aktuálny dátum a čas z modulu RTC

Volanie vyššie uvedenej funkcie aktualizuje premenné sec, min a hodinu na aktuálnu hodnotu. Aby sme ich mohli zobraziť na LCD obrazovke, musíme ich rozdeliť na jednotlivé znaky pomocou nižšie uvedeného kódu.

// Rozdelíme na char, aby sa zobrazili na lcd char sec_0 = sec% 10; char sec_1 = (s / 10); char min_0 = min% 10; char min_1 = min / 10; char hour_0 = hodina% 10; char hour_1 = hodina / 10;

Ďalej aktualizujeme hodnoty na obrazovke LCD. Aktuálny čas sa zobrazí v prvom riadku a nastavený čas, v ktorom sa má spustiť alarm, sa zobrazí v druhom riadku. Kód, ktorý robí to isté, je uvedený nižšie.

// Zobrazenie aktuálneho času na LCD obrazovke Lcd_Clear (); Lcd_Set_Cursor (1, 1); Lcd_Print_String ("TIME:"); Lcd_Print_Char (hodina_1 + „0“); Lcd_Print_Char (hodina_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'); // Zobrazenie dátumu na LCD obrazovke Lcd_Set_Cursor (2, 1); Lcd_Print_String ("Alarm:"); 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');

Teraz sme na LCD zobrazili čas a nastavili čas, ktorý musíme skontrolovať, či sa používateľ pokúša nastaviť čas budenia. Aby to bolo možné, musí užívateľ stlačiť stredné tlačidlo, takže skontrolujeme, či je stlačené stredné tlačidlo a prepneme premennú, aby sme vstúpili do režimu nastaveného alarmu. Rovnaké tlačidlo sa znova stlačí, aby sa potvrdilo, že hodnoty sú nastavené, a v takom prípade musíme vyjsť z režimu nastavenia alarmu. Nasledujúci riadok kódu teda používame na zmenu stavu premennej set_alarm .

// Prostredným tlačidlom skontrolujeme, či je potrebné nastaviť budík if (MB == 0 && set_alarm == 0) {// Ak je stlačené stredné tlačidlo a budík nie je zapnutý, kým (! MB); // Počkajte, kým sa tlačidlo neuvoľní set_alarm = 1; // začnite nastavovať hodnotu alarmu } if (MB == 0 && set_alarm == 1) {// Ak je stlačené stredné tlačidlo a alarm sa nevypne, kým (! MB); // Počkajte, kým sa tlačidlo neuvoľní set_alarm = 0; // prestať nastavovať hodnotu alarmu }

Ak používateľ stlačil stredné tlačidlo, znamená to, že sa pokúša nastaviť čas budenia. V takom prípade program prejde do režimu nastavenia alarmu pomocou vyššie uvedeného kódu. Ak používateľ v režime nastavenia budíka stlačí ľavé alebo pravé tlačidlo, znamená to, že musíme posúvať kurzor doľava alebo doprava. Za týmto účelom jednoducho zvýšime pokles hodnoty polohy, na ktorú musí byť kurzor umiestnený

if (LB == 0) {// Ak je stlačené ľavé tlačidlo, kým (! LB); // Počkajte, kým sa tlačidlo neuvoľní pos--; // Potom posuňte kurzor doľava } if (RB == 0) {// Ak je stlačené pravé tlačidlo, kým (! RB); // Počkajte, kým sa neuvoľní tlačidlo pos ++; // Presunúť kurzor doprava }

Pri používaní tlačidla s mikrokontrolérom alebo mikroprocesorom existuje jeden spoločný problém. Tento problém sa nazýva odrazenie prepínača. To znamená, že keď je stlačené tlačidlo, mohlo by to vydať hlučné impulzy do MCU / MPU, čo by mohlo falošné MCU pre viac vstupov. Tento problém je možné vyriešiť pridaním kondenzátora cez prepínač alebo použitím funkcie oneskorenia ihneď po zistení stlačenia tlačidla. Tento typ riešenia sa nazýva odskakovanie. Tu sme použili while slučka držať program na svojom mieste až do uvoľnenia tlačidla spúšte. Toto nie je najlepšie riešenie na odskakovanie, ale pre nás to bude fungovať dobre.

while (! RB);

Podobne ako ľavé a pravé tlačidlo máme aj horné a spodné tlačidlo, pomocou ktorého je možné zvyšovať alebo znižovať hodnotu času alarmu. Kód, ktorý urobí to isté, je uvedený nižšie. Všimnite si, že každý znak nastaveného času alarmu je adresovaný hodnotou indexu poľa. To znamená, že môžeme ľahko získať prístup k požadovanému znaku, ktorého hodnoty je potrebné zmeniť.

if (UB == 0) {// Ak je stlačené horné tlačidlo, kým (! UB); // Počkajte, kým sa neuvoľní tlačidlo alarm_val ++; // Zvýšiť konkrétnu hodnotu znaku } if (BB == 0) {// Ak je stlačené spodné tlačidlo, kým (! UB); // Počkajte, kým sa neuvoľní tlačidlo alarm_val--; // Znížiť konkrétnu hodnotu znaku }

Akonáhle je nastavený čas budíka, užívateľ znovu stlačte prostredné tlačidlo. Potom môžeme začať porovnávať aktuálny čas s nastaveným časom. Porovnanie kontrolou, či sa každý znak aktuálneho času rovná znaku nastaveného času. Ak sú hodnoty rovnaké, spustíme alarm nastavením premennej trigger_alarm, inak iba porovnávame, kým sa nerovná.

// AK je nastavený alarm Skontrolujte, či sa nastavená hodnota rovná súčasnej hodnote, ak (set_alarm == 0 && alarm_val == hodina_1 && alarm_val == hodina_0 && alarm_val == min_1 && alarm_val == min_0) trigger_alarm = 1; // Zapnite spúšťač, ak sa hodnota zhoduje

Ak je nastavený alarm, musíme pípnuť bzučiak, aby sme používateľa upozornili na alarm. To je možné dosiahnuť jednoduchým prepínaním bzučiaka v pravidelných intervaloch, ako je uvedené nižšie.

if (trigger_alarm) {// Ak sa spustí alarm // Pípne bzučiak BUZZ = 1; __delay_ms (500); BUZZ = 0; __delay_ms (500); }

Simulácia:

Tento program je možné simulovať aj pomocou softvéru proteus. Stačí znovu vytvoriť obvod zobrazený vyššie a načítať hexadecimálny súbor do PIC. Hex kód tohto projektu nájdete v súbore ZIP, ktorý je prepojený tu. Snímka obrazovky nasnímaná počas simulácie je uvedená nižšie

Simulácia sa stáva veľmi užitočnou, keď sa snažíte do projektu pridať nové funkcie. Môžete tiež použiť debuggerový modul I2C na kontrolu toho, aké údaje vstupujú a vystupujú cez zbernicu I2C. Môžete skúsiť stlačiť tlačidlá a tiež nastaviť čas budenia. Keď je nastavený čas rovný aktuálnemu času, bzučiak pôjde vysoko.

Práca s digitálnym budíkom pomocou PIC16F877A:

Postavte obvod na doske, získajte kód z odkazu na stiahnutie a skompilujte ho pomocou kompilátora MplabX a XC8. Ak ste si stiahli kód zo tu uvedeného súboru ZIP, nemali by ste mať problém s jeho kompiláciou, pretože hlavičkové súbory sú už pripojené.

Po zostavení nahrajte program na váš hardvér pomocou programátora PicKit3. Pripojenie na pripojenie pickit programátora k PIC IC je tiež znázornené v schéme zapojenia. Po nahraní programu by ste mali vidieť úvodnú obrazovku a potom čas, ktorý sa zobrazí, pomocou tlačidiel môžete nastaviť čas budenia. Moje nastavenie hardvéru pri napájaní vyzerá takto nižšie.

Keď sa čas alarmu zhoduje s aktuálnym časom, začne bzučiak pípať, aby upozornil používateľa. Kompletné fungovanie nájdete na videu nižšie. Projekt má nepreberné množstvo možností, na ktorých je možné stavať. Modul RTC dokáže sledovať akýkoľvek čas a dátum, takže môžete vykonať naplánovanú úlohu v ľubovoľnom požadovanom čase / dátume. Môžete tiež pripojiť sieťový spotrebič ako ventilátor alebo svetlo a podľa potreby naplánovať jeho zapnutie alebo vypnutie. Na tomto projekte je ešte oveľa viac, na čom môžete stavať, dajte mi vedieť, aký nápad vás napadne ako inovácia tohto projektu, a budem rád, keď sa dozviete.

Dúfam, že ste pochopili projekt a dozvedeli ste sa z procesu niečo užitočné. Ak máte pochybnosti o tomto projekte, pošlite ich do sekcie komentárov alebo použite technickú pomoc vo fórach.

Kompletný PIC kód so súbormi hlavičiek nájdete tu