7 תצוגות קטע ממשק עם מיקרו-בקר

זוהי ההדרכה השמינית שלנו בנושא למידת PIC מיקרו-בקרים באמצעות MPLAB ו- XC8. עלינו כל הדרך מהתקנת MPLABX לשימוש ב- LCD עם PIC MCU. אם אתה חדש כאן, עיין בהדרכות קודמות שבהן אתה יכול ללמוד טיימרים, נורית מהבהבת, ממשק LCD וכו '. תוכל למצוא את כל מדריכי PIC שלנו כאן. במדריך האחרון שלנו ראינו כיצד נוכל ליצור תווים מותאמים אישית עם תצוגת LCD 16 * 2 שלנו, כעת בואו נצייד את עצמנו בסוג אחר של מודול תצוגה הנקרא תצוגת 7 קטעים ונממשק אותו עם PIC Microcontroller.

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

מודול תצוגה בן 7 קטעים וארבע ספרות:

תצוגת 7 קטעים כוללת שבעה קטעים ובכל קטע יש LED אחד לתצוגה של המספרים על ידי הארת הקטעים המתאימים. כמו אם ברצונך שהמקטע בן 7 יציג את המספר "5" אז עליך להאיר את קטע a, f, g, c ו- d על ידי כך שהסיכות המתאימות שלהם יהיו גבוהות. ישנם שני סוגים של תצוגות בעלות 7 קטעים: קתודה משותפת ואנודה משותפת, כאן אנו משתמשים בתצוגה של קטע משותף בשבעה קטעים. למידע נוסף על תצוגת 7 קטעים כאן.

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

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

כדי להבין כיצד פועל מודול בן 7 ספרות קטע, עלינו לבדוק את התרשימות שלעיל, כפי שמוצג סיכות A של כל ארבע התצוגה מחוברות כדי להתאסף כ- A זהה עבור B, C…. עד DP. אז, בעצם אם ההדק A פועל, אז כל ארבעת ה- A צריכים לעבור גבוה נכון?

אבל, זה לא קורה. יש לנו ארבעה פינים נוספים מ- D0 ל- D3 (D0, D1, D2 ו- D3), בהם ניתן להשתמש כדי לשלוט באיזו תצוגה מתוך הארבע צריכה להיות גבוהה. לדוגמא: אם אני צריך שהפלט שלי יהיה נוכח רק בתצוגה השנייה, אז רק D1 צריך להיות גבוה תוך שמירה על סיכות אחרות (D0, D2 ו- D3) נמוכות. פשוט נוכל לבחור איזו תצוגה צריכה להיות פעילה באמצעות הפינים מ D0 ל- D3 ואיזה תו להציג באמצעות הפינים מ- A ל- DP.

חיבור מודול בן 7 ספרות עם 4 ספרות עם מיקרו-בקר PIC:

כאן השתמשנו במיקרו-בקר PIC16F877A והתרשים למעגל מוצג להלן.

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

הערה: יש לחבר את פין הקרקע של המודול לאדמת ה- MCU שאינה מוצגת כאן.

תכנות באמצעות PIC16F877A:

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

# תצורת פרגמה FOSC = HS // סיביות בחירת מתנד (מתנד HS) תצורת פרגמה WDTE = OFF // טיימר כלב שמירה הפעלת סיבוב (WDT מושבת) # תצורת pragma PWRTE = ON // טיימר הפעלה למעלה ביט (מופעל PWRT) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) # pragma config LVP = OFF // מתח נמוך (אספקה ​​יחידה) תכנות סידורי במעגל אפשר Bit (RB3 הוא Digital I / O, HV פועל יש להשתמש ב- MCLR לצורך תכנות) # config config CPD = OFF // Data EEPROM Memory Code Protection Protection (Data EEPROM code code off) # pragma config WRT = OFF // Flash Programm Memory Memory כתוב אפשר ביטים (הגנת כתיבה כבויה; כל זיכרון התוכנית עשוי להיכתב על ידי בקרת EECON) # config config CP = OFF // Flash Bit Memory Code Protection Code (Code code off)

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

לאחר מכן נגדיר את סיכות הפלט למעבר בין כל ספרה בתצוגה.

// *** הגדר את סיכות האות של כל ארבע התצוגות *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** סוף ההגדרה ** ////

כאן הפינים RC0, RC1, RC2 ו- RC3 משמשים לבחירה בין ארבע הספרות של מודול התצוגה בן 7 הקטעים שלנו. סיכות אלה מוגדרות כ- s1, s2, s3 ו- s4 בהתאמה.

לאחר מכן נקפוץ אל main () ריק, שבתוכו יש לנו את ההצהרה המשתנה הבאה:

int i = 0; // הערך בן 4 הספרות שאמור להיות מוצג int flag = 0; // ליצירת עיכוב לא חתום int a, b, c, d, e, f, g, h; // פשוט משתנים לא חתומים int seg = {0X3F, // ערך Hex להצגת המספר 0 0X06, // ערך Hex להצגת המספר 1 0X5B, // ערך Hex להצגת המספר 2 0X4F, // ערך Hex להצגה המספר 3 0X66, // ערך Hex להצגת המספר 4 0X6D, // ערך Hex להצגת המספר 5 0X7C, // ערך Hex להצגת המספר 6 0X07, // ערך Hex להצגת המספר 7 0X7F, / / ערך Hex להצגת המספר 8 0X6F // ערך Hex להצגת המספר 9}; // סוף מערך להצגת מספרים מ -0 עד 9

הנה המשתנים i ו הדגל משמשים לאחסון הערכים שיוצגו יוצרת שהייה בהתאמה. משתנה שלמת חתום A ל- h משמשים לשבור את מספרי הארבעה ספר לתוך ספרות יחידה ולאחסן אותם (שיוסבר בהמשך כאן).

דבר מרכזי אחד שיש לציין כאן הוא הצהרת המערך "seg" . בתוכנית זו אנו משתמשים בסוג נתונים חדש בשם Array. מערך אינו אלא אוסף של ערכים דומים מסוג נתונים. כאן השתמשנו במערך זה כדי לאחסן את כל ערכי ה- hex המקבילים להצגת מספר בין 0 ל -9.

כתובת המערך מתחילה תמיד מאפס. אז למערך זה יהיה ערך ה- hex של מספר מספרי (0-9) בכתובת זהה לזה של המספר כמוצג להלן.

מִשְׁתַנֶה:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
קוד משושה:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
שווה ערך מספר מספרי:	0	1	2	3	4	5	6	7	8	9

אז פשוט, אם ברצונך להציג את המספר 0 בקטע 7 שלך, אתה יכול להתקשר ל- seg, כמו כן אם ברצונך להציג את המספר 6 אתה פשוט צריך להשתמש ב- seg.

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

עכשיו, נעבור לחלק הבא של הקוד שהוא תצורת ה- I / O:

// ***** תצורת קלט / פלט **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; פורט = 0X00; // *** סוף תצורת קלט / פלט ** ///

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

עכשיו בואו נקפוץ לולאה האינסופית שלנו (בזמן (1)). כאן עלינו לפצל את הערך של "i" לארבע ספרות ולהציג אותם בקטע 7. ראשית נתחיל בפיצול הערך על "i"

// *** פיצול "i" לארבע ספרות *** // a = i% 10; // הספרה הרביעית נשמרת כאן b = i / 10; c = b% 10; // הספרה השלישית נשמרת כאן d = b / 10; e = d% 10; // הספרה השנייה נשמרת כאן f = d / 10; g = f% 10; // הספרה הראשונה נשמרת כאן h = f / 10; // *** סוף הפיצול *** //

על ידי שימוש במודולוס פשוט ופעולת חלוקה המספר בן 4 הספרות (i) מופרד למספרים בודדים. במקרה שלנו הבה ניקח דוגמא כאשר הערך של "i" הוא 4578. ואז בסוף תהליך זה המשתנה g = 4, e = 5, c = 7 ו- a = 8. אז עכשיו יהיה קל להציג כל ספרה פשוט באמצעות המשתנה הזה.

PORTD = seg; s1 = 1; // הפעל את תצוגת 1 והדפס את הספרה הרביעית __השהיה_מס (5); s1 = 0; // כבה את התצוגה 1 לאחר עיכוב של 5 ms. PORTD = seg; s2 = 1; // הפעל את תצוגת 2 והדפס את הספרה השלישית __השהיה_מס (5); s2 = 0; // כבה את תצוגת 2 לאחר עיכוב של 5 ms PORTD = seg; s3 = 1; // הפעל את התצוגה 3 והדפס את הספרה השנייה __השהיה_מס (5); s3 = 0; // כבה את התצוגה 3 לאחר עיכוב של 5 ms PORTD = seg; s4 = 1; // הפעל את תצוגת 4 והדפס ספרה 1 __השהה_מס (5); s4 = 0; // כבה את התצוגה 4 לאחר עיכוב של 5 ms

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

אז איך נלך עם זה?

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

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

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

אם (דגל> = 100) // המתן עד שהדגל יגיע ל 100 {i ++; דגל = 0; // רק אם הדגל הוא מאה "אני" יוגדל} דגל ++; // דגל תוספת לכל פלאש

נעשה שימוש בעיכוב כך שהזמן שנדרש לשינוי ממספר אחד למשנהו מספיק זמן כדי שנוכל להבחין בשינוי.

הקוד השלם הוא כדלקמן והתהליך גם מוסבר הווידאו בסוף.

התקנת ובדיקת חומרה:

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

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