שעון מעורר דיגיטלי מבוסס מיקרו-בקר Pic16f877a

המהפכה הדיגיטלית שהחלה בשנת 1950 משנה את כל המבנים האלקטרוניים המכניים והאנלוגיים הקיימים למחשבים דיגיטליים. מכיוון שצמיחת האלקטרוניקה הדיגיטלית הייתה אקספוננציאלית, כיום כמעט ואי אפשר לאדם להתנגד לשימוש בציוד אלקטרוני כלשהו. החל מהשעון המעורר שמעיר אתכם והטוסטר שמגיש לכם ארוחת בוקר, הכל תרומה מהאלקטרוניקה הדיגיטלית. כשחושבים על כל אלה זה באמת מרגש לתכנת דברים משלנו שיכולים לבצע משימות פשוטות אך יעילות, כמו השעון המעורר שאנחנו הולכים לבנות בפרויקט זה עם PIC Microcontroller. בנינו בעבר שעון מעורר עם מיקרו-בקרים אחרים:

• שעון מעורר פטל פי באמצעות מודול RTC DS1307
• שעון דיגיטלי מבוסס ארדואינו עם אזעקה
• שעון מעורר באמצעות מיקרו-בקר ATmega32

לשעון המעורר הזה תצוגת LCD בגודל 16x2 שתציג את השעה הנוכחית ואת הזמן שנקבע. נשתמש בכפתורי לחיצה ספורים כדי לקבוע את זמן האזעקה בכל עת. הזמן הנוכחי יישמר במעקב באמצעות מודול RTC DS3231 ונשתמש בתקשורת IIC כדי לקבל ערכים אלה ממודול RTC. למדנו כבר על מודול ה- RTC וכיצד ניתן לממשק אותו עם PIC. לכן מומלץ לקרוא את אותה הדרכה, אנו מדלגים על רוב המידע המכוסה במדריך זה.

חומרים נדרשים:

• לוח לחם - 2 מס
• PIC16F877A
• מקור כוח 5V - מודול אספקה
• גביש 20 מגה הרץ
• קבלים 33pf - 2Nos
• מודול DS3231 RTC
• 16 * 2 מודול תצוגת LCD
• עציץ 10K
• נגד 10k ו- 1K
• לחצני כפתור - 5 מס '
• זַמזָם
• חוטי חיבור

דרישות קדם:

פרויקט זה מצריך לדעת כמה יסודות על מיקרו-בקר PIC וכיצד לתכנת אותו. אנו נשתמש ב- GPIO, בתצוגת LCD ובמודול RTC לפרויקט זה. לכן עדיף ללמוד כיצד להשתמש במודולים אלה מראש. הקישורים הבאים יעזרו לך ללמוד את אותו הדבר

• כותב את התוכנית הראשונה שלך עם PIC Microcontroller
• ממשק LCD עם PIC
• תקשורת I2C באמצעות PIC
• ממשק DS3231 RTC עם PIC

תרשים מעגל:

תרשים המעגל לפרויקט שעון מעורר מבוסס PIC זה מוצג להלן, אשר נוצר באמצעות תוכנת הפרוטאוס. הפרויקט ישמש גם להדמיה נוספת.

חמשת כפתורי הלחיצה ישמשו ככניסה להגדרת האזעקה לזמן הנדרש. אז קצה אחד של כל לחצני הלחיצה מחובר לקרקע והקצוות האחרים מחוברים לסיכת PORTB, נגד סיכות פנימי ישמש על סיכות אלה כדי למנוע את סיכות הצף. הבאזר ישמש כפלט וייתן לנו צפצוף כאשר האזעקה מופעלת ומחוברת לסיכה PORT S. הזמן הנוכחי נשמר תמיד במעקב על ידי מודול RTC DS3231 ממנו ה- PIC מקבל את הנתונים דרך אוטובוס I2C, כך שסיכות SCL ו- SDA של מודול RTC מחוברות לסיכת SCL ו- SDA של בקר ה- PIC. תצוגת LCD מחוברת ל- PORTD של ה- PIC המשמשת להצגת השעה הנוכחית והגדרת הזמן. למידע נוסף על השימוש במודול DS3231 RTC עם PIC כאן.

ניתן לבנות את המעגל השלם מעל קרש לחם. מכיוון שיש כמה עשרות חוטים לחיבור, אז פשוט יש סבלנות וודא שהחיבורים נכונים. הגדרת החומרה שלי נראתה ככה למטה ברגע שסיימתי את החיבורים

השתמשתי במודול קרש לחם ובמתאם 12V להפעלת המודול. זהו המקור שלי למתח +5 וולט. כמו כן, עלי להשתמש בשתי קרש לחמים כדי לשמור על ניקיון המעגל. אתה יכול גם להלחין את כל המעגל ללוח perf אם אתה מעוניין ליצור פרויקט חזק יותר.

תכנות לשעון מעורר:

את תוכנית ה- PIC המלאה עבור פרויקט שעון מעורר זה תוכלו למצוא בתחתית עמוד זה. פרויקט זה דורש גם שלוש ספריות לשימוש ב- LCD, I2C ו- RTC עם PIC. את הקוד השלם עם קבצי הכותרת ניתן להוריד מקובץ ה- ZIP כאן וניתן לפתוח אותו באמצעות MPLABX לאחר החילוץ. בהמשך אני רק מסביר את קובץ c הראשי כקטעים קטנים. אתה יכול לחזור למדריכים שהוזכרו לעיל אם אתה רוצה לדעת כיצד פועלים קבצי הכותרת.

לפני שנכנס לתוכנית הראשית, עלינו להגדיר את הסיכות בהן השתמשנו בשם משמעותי יותר. בדרך זו יהיה קל להשתמש בהם במהלך התכנות. הסיכות שהוגדרו בתוכנית שלנו מוצגות להלן

// הגדר את סיכות LCD # הגדר RS RD2 // אפס סיכה של LCD # הגדר EN RD3 // אפשר סיכה של LCD # הגדר D4 RD4 // נתונים נתונים 0 של LCD # הגדר D5 RD5 // נתונים נתונים 1 של LCD # הגדר D6 RD6 // סיבית נתונים 2 של LCD # הגדר D7 RD7 // סיבית נתונים 3 של LCD // הגדר לחצנים # הגדר MB RB1 // הכפתור האמצעי # הגדר LB RB0 // כפתור שמאל # הגדר RB RB2 // כפתור ימני # הגדר UB RB3 // לחצן עליון # הגדר BB RB4 // לחצן תחתון // הגדר באז # הגדר BUZZ RD1 // Buzzer מחובר ל- RD1

בתוך הפונקציה הראשית אנו מתחילים בהכרזה על סיכות הקלט והפלט. בפרויקט שלנו ה- PORTB משמש ללחצני כפתור שהוא מכשיר קלט ולכן אנו מגדירים את הסיכות שלהם ככניסות ו- PORTD משמש עבור LCD וזמזם ולכן הגדרנו את הסיכות שלהם כ- Output. כמו כן אסור להשאיר סיכה צפה כלומר, סיכות הקלט / פלט תמיד צריכות להיות מחוברות לקרקע או למתח +5 וולט. במקרה שלנו עבור כפתורי הלחיצה הפינים לא יחוברו לשום דבר כאשר הכפתור לא נלחץ ולכן אנו משתמשים בנגיף משיכה פנימי המכוון את הסיכה ל- High כאשר אינו בשימוש. זה נעשה באמצעות רישומי הבקרה כפי שמוצג להלן

TRISD = 0x00; // הפוך סיכות יציאה D כ- outptu עבור ממשק LCD TRISB = 0xFF; // Switchs מוכרזים כמו סיכות קלט OPTION_REG = 0b00000000; // אפשר נגן pull up ביציאה B למתגים BUZZ = 0; // סיבוב של זמזם

מכיוון שיש לנו את קובץ הכותרת LCD ו- I2C המקושר לתוכנית הראשית, אנו יכולים להתחיל את אתחול ה- LCD על ידי קריאה לפונקציה פשוטה. ניתן לעשות זאת גם לצורך אתחול I2C. כאן אנו מתחילים את תקשורת I2C ב 100kHz שכן מודול RTC עובד עם 100kHz.

Lcd_Start (); // אתחל את מודול ה- LCD I2C_Initialize (100); // אתחל את I2C Master עם שעון 100KHz

הפונקציה שלהלן משמשת לקביעת השעה והתאריך במודול RTC, לאחר הגדרת השעה והתאריך הסר שורה זו. אחרת בכל פעם שתתחיל את התוכנית השעה והתאריך ייקבעו שוב ושוב

// הסר את מתחת לקו פעם שעה ותאריך היא להגדיר בפעם הראשונה. Set_Time_Date (); // הגדר שעה ותאריך במודול ה- RTC

כדי לציין כי התוכנית מתחילה אנו מציגים מסך מבוא קטן המציג את שם הפרויקט ושם האתר כמוצג להלן

// תן הודעת מבוא ב- LCD Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("שעון מעורר"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __השהיית_מס (1500);

הבא בתוך בעוד לולאה אנחנו צריכים לקרוא את השעה והתאריך הנוכחי ממודול RTC, זה יכול להיעשות רק על ידי קריאה מתחת פונקציה.

Update_Current_Date_Time (); // קרא את התאריך והשעה הנוכחיים ממודול RTC

קריאה לפונקציה שלעיל תעדכן את המשתנים שניות, דקות ושעה עם הערך הנוכחי. על מנת להציג אותם על גבי מסך ה- LCD עלינו לפצל אותם לתווים בודדים באמצעות הקוד שלמטה.

// פצל את ה- char לתצוגה ב- lcd char sec_0 = sec% 10; char sec_1 = (sec / 10); char min_0 = min% 10; char min_1 = min / 10; שעה char_0 = שעה% 10; שעה char_1 = שעה / 10;

לאחר מכן אנו מעדכנים את הערכים על גבי מסך ה- LCD. השעה הנוכחית תוצג בשורה הראשונה והזמן שנקבע בו יש להפעיל את האזעקה מוצג בשורה השנייה. הקוד שעושה את אותו הדבר מוצג להלן.

// הצג את השעה הנוכחית על גבי מסך LCD Lcd_Clear (); Lcd_Set_Cursor (1, 1); Lcd_Print_String ("TIME:"); Lcd_Print_Char (שעה_1 + '0'); Lcd_Print_Char (שעה_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'); // הצג את התאריך על גבי מסך ה- LCD Lcd_Set_Cursor (2, 1); Lcd_Print_String ("אזעקה:"); 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');

כעת, הצגנו את השעה והגדרנו את זמן ה- LCD עלינו לבדוק אם המשתמש מנסה להגדיר את זמן האזעקה. לשם כך המשתמש צריך ללחוץ על הכפתור האמצעי, ולכן נבדוק אם לחצן האמצעי נלחץ ונחליף משתנה כדי להיכנס למצב הגדרת אזעקה. אותו לחצן יוחץ שוב כדי לאשר שהערכים מוגדרים ובמקרה זה עלינו לצאת ממצב הגדרת האזעקה. לכן אנו משתמשים בשורת הקוד שלמטה כדי לשנות את סטטוס המשתנה set_alarm .

// השתמש בלחצן האמצעי כדי לבדוק אם יש להגדיר אזעקה אם (MB == 0 && set_alarm == 0) {// אם לחצן האמצעי נלחץ והאזעקה אינה מופעלת בזמן (! MB); // לחכות לחצן ישוחרר set_alarm = 1; // התחל להגדיר ערך אזעקה } אם (MB == 0 && set_alarm == 1) {// אם לחצן האמצעי נלחץ והאזעקה אינה כבויה בזמן (! MB); // לחכות לחצן ישוחרר set_alarm = 0; // הפסק להגדיר את ערך האזעקה }

אם המשתמש לחץ על הכפתור האמצעי, המשמעות היא שהוא מנסה להגדיר את זמן האזעקה. במקרה זה התוכנית נכנסת למצב הגדרת אזעקה באמצעות הקוד לעיל. בתוך מצב הגדרת האזעקה אם המשתמש לוחץ על כפתור שמאל או ימין זה אומר שעלינו להזיז את הסמן שמאלה או ימינה. לשם כך אנו פשוט מגדילים את הקטנת ערך המיקום בו יש להציב את הסמן

אם (LB == 0) {// אם לחצן שמאל נלחץ בזמן (! LB); // המתן עד שהכפתור ישוחרר pos--; // ואז הזז את הסמן שמאלה } אם (RB == 0) {// אם לחצן ימין נלחץ בזמן (! RB); // המתן עד שהכפתור ישוחרר pos ++; // העבר את הסמן ימינה }

בעת שימוש בלחיצת כפתור עם מיקרו-בקר או מעבד ישנה בעיה נפוצה אחת לטיפול. בעיה זו נקראת כמתג מקפץ. זה כאשר הלחצן נלחץ הוא עלול לתת דופקים רועשים ל- MCU / MPU שעלולים לזייף את ה- MCU עבור מספר ערכים. ניתן לפתור בעיה זו על ידי הוספת קבלים מעבר למתג או באמצעות פונקציית השהיה ברגע שמתגלה לחיצת הכפתור. סוג זה של פתרון נקרא דה-הקפצה. כאן השתמשנו בלולאת זמן כדי להחזיק את התוכנית עד לשחרור הכפתור. זה לא הפיתרון הכי טוב להקפצה אבל מבחינתנו זה יעבוד בסדר גמור.

בעוד (! RB);

בדומה לכפתור שמאל וימין, יש לנו גם את הלחצנים העליונים והתחתונים שניתן להשתמש בהם כדי להגדיל או להקטין את ערך זמן האזעקה. הקוד לעשות את אותו הדבר מוצג להלן. שים לב שכל תו בזמן האזעקה שהוגדר מתייחס לפי ערך האינדקס של המערך. זה היה שנוכל לגשת בקלות לדמות הנדרשת שיש לשנות את הערכים שלה.

אם (UB == 0) {// אם לוחצים על הכפתור העליון בזמן (! UB); // לחכות לחצן ישוחרר alarm_val ++; // הגדל את ערך הסימן המסוים הזה } אם (BB == 0) {// אם לחצן התחתון נלחץ בזמן (! UB); // המתן עד שהכפתור ישוחרר alarm_val--; // הפחת את ערך הסימן המסוים הזה }

לאחר הגדרת זמן האזעקה המשתמש ילחץ שוב על הכפתור האמצעי. אז נוכל להתחיל להשוות את הזמן הנוכחי עם הזמן שנקבע. ההשוואה באמצעות בדיקה אם כל תו בזמן הנוכחי שווה לאופי הזמן שנקבע. אם הערכים שווים אז נפעיל את האזעקה על ידי הגדרת המשתנה trigger_alarm אחרת רק נשווה עד שהיא תהיה שווה.

// אם אזעקה מוגדרת בדוק אם הערך שנקבע שווה לערך הנוכחי אם (set_alarm == 0 && alarm_val == hour_1 && alarm_val == hour_0 && alarm_val == min_1 && alarm_val == min_0) trigger_alarm = 1; // הפעל את ההדק אם הערך תואם

אם האזעקה מוגדרת עלינו לצפצף על הבאזר כדי להתריע בפני המשתמש על אזעקה. ניתן לעשות זאת פשוט על ידי החלפת זמזם במרווח קבוע כמוצג להלן.

אם (trigger_alarm) {// אם מופעלת אזעקה // צפצוף לזמזם BUZZ = 1; __השהיית_מס (500); BUZZ = 0; __השהיית_מס (500); }

סימולציה:

ניתן לדמות תוכנית זו גם באמצעות תוכנת הפרוטאוס. פשוט צור מחדש את המעגל המוצג לעיל וטען את קובץ ה- hex ל- PIC. הקוד הקוד עבור פרויקט זה נמצא בקובץ ה- ZIP המקושר כאן. צילום מסך שצולם במהלך הסימולציה מוצג להלן

הסימולציה הופכת להיות שימושית מאוד כאשר אתה מנסה להוסיף תכונות חדשות לפרויקט. ניתן גם להשתמש במודול הבאגים של I2C כדי לבדוק אילו נתונים נכנסים ויוצאים דרך אוטובוס I2C. אתה יכול לנסות ללחוץ על הכפתורים וגם להגדיר את זמן האזעקה. כאשר הזמן שנקבע שווה לזמן הנוכחי אז הבאזר יעלה גבוה.

עבודה של שעון מעורר דיגיטלי באמצעות PIC16F877A:

בנה את המעגל על ​​לוח הלוח, קבל את הקוד מקישור ההורדה ורכיב אותו באמצעות מהדר MplabX ו- XC8. אם הורדת את הקוד מקובץ ה- ZIP שסופק כאן, לא תהיה לך שום בעיה להרכיב אותו מכיוון שקבצי הכותרת כבר צורפו.

לאחר הידור, העלה את התוכנית לחומרה שלך באמצעות מתכנת PicKit3. החיבור לחיבור המתכנת הפיקיט ל- PIC IC מוצג גם בתרשים המעגל. לאחר העלאת התוכנית אתה אמור לראות את מסך המבוא ואז את השעה המוצגת תוכל להשתמש בלחצני הלחיצה כדי להגדיר את זמן האזעקה. הגדרת החומרה שלי במצב מופעל נראית כך למטה.

כאשר זמן האזעקה תואם לזמן הנוכחי הבאזר יתחיל לצפצף כדי להבהיר את המשתמש. את העבודה המלאה תוכלו למצוא בסרטון למטה. לפרויקט שפע של אפשרויות לבנות עליהן. מודול ה- RTC יכול לעקוב אחר כל זמן ותאריך, כך שתוכל לבצע משימה מתוזמנת בכל זמן / תאריך שנדרש. ניתן גם לחבר מכשיר זרם חילופין כמו מאוורר או נורה ולתזמן להפעלה או כיבוי במידת הצורך. עדיין יש הרבה יותר שתוכל לבנות על הפרויקט הזה, תן לי לדעת איזה רעיון עולה בראשך כשדרוג לפרויקט זה ואשמח לשמוע ממך.

מקווה שהבנתם את הפרויקט ולמדתם משהו שימושי מהתהליך. אם יש לך ספקות בפרויקט זה השתמש בסעיף ההערות כדי לפרסם אותם או השתמש בפורומים לעזרה טכנית כלשהי.

קוד PIC מלא עם קבצי כותרת ניתן למצוא כאן