מדריך PIC - מרשמים להפסקות

לפני שנכנס לפרטים הקטנים של תכנות PIC, יהיה חשוב ללמוד כמה שיטות תכנות טובות.

הבנת רושמים

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

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

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

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

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

2. המרשמים.

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

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

אתה יכול לראות שהוא בעצם מחולק לבנק 0 ולבנק 1. בנק 1 אחראי על השליטה בפועל של ה- PIC, למשל הוא מציין את ה- PIC אילו סיביות ביציאה A מוקצות ככניסות ואילו הן כמוצאות.

בנק 2 נועד רק לתמרן את המידע.

בואו נבין זאת באמצעות הדוגמה הבאה:

נניח שברצוננו להקצות ביט אחד בגובה PortA. לשם כך נצטרך תחילה לעבור לבנק 1 לצורך הגדרת הסיב או הסיכה שצוינו ביציאה A בצורה של פלט. לאחר מכן אנו חוזרים לבנק 0 ומספקים לוגיקה 1 (ביט 1) לסיכה הספציפית הזו.

המרשמים הנפוצים ביותר שאנו רוצים להשתמש בבנק 1 הם STATUS, TRISA ו- TRISB.

STATUS עוזר לנו לחזור לבנק 0, TRISA מאפשרת לנו לבחור אילו פינים ביציאה A הם יציאות ואילו יכולות להיות תשומות, בעוד ש- TRISB מאפשר לבחור בין פלט קלט לסיכה ביציאה B. רישום ה- SELECT בבנק 0 מאפשר למשתמש. לדלג לבנק 1.

בואו נסכם את כל המושג בתיאור הבא:

סטָטוּס:

על מנת לעבור מבנק 0 לבנק 1 אנו מפקדים על רישום STATUS. זה מיושם על ידי הגדרת סיבית מס '5 של רישום STATUS ל- 1. כדי לחזור לבנק 0, אנו מקצים את סיבית 5 של רישום STATUS ל- 0. רישום STATUS ממוקם בכתובת 03h, כאן h מסמל את המספר. עשוי להיות בהקסדצימלי.

TRISA ו- TRISB:

אלה ממוקמים בכתובת 85h ו- 86h בהתאמה. לתכנות סיכה כפלט או כקלט, אנו מספקים אפס או אחד לסיבית המסוימת ברשומה. עכשיו זה יכול להיעשות בשתי דרכים, באמצעות בינארי, או Hex. במקרה שאיננו מצליחים להמיר את הפרמטר הוא יכול ללכת למחשבון מדעי ליישום הערכים.

עכשיו יש לנו 5 פינים בנמל A, שמתאים ל -5 פינים. אם בכוונתנו לתקן את אחד הפינים ככניסות, אנו מספקים '1' לסיבית מסוימת.

במקרה שרצינו להקצות את אחד הפינים ליציאות, היינו מגדירים את הסיכה הספציפית ל '0'. הסיביות מסייעות במדויק המקביל לסיביות, או יותר מדויק ביט 0 הוא RA0, סיבית 1 תהיה RA1, סיבית 2 = RA2 וכן הלאה. בואו נבין את זה בצורה כזו:

נניח שברצונך לתקן את RA0, RA3 ו- RA4 כפלטים, ואילו RA1 / RA2 כ- i / ps, תעשה זאת על ידי שליחת 00110 (06h). בדוק שקצת 0 נמצאת ימינה כפי שמצוין כאן:

פורט A פין RA4 RA3 RA2 RA1 RA0

מספר ביט 4 3 2 1 0

בינארי 0 0 1 1 0

כנ'ל לגבי TRISB.

פורטה ופורטב

על מנת להעביר את אחד מסיכות הפלט גבוהות, אנו פשוט מציעים '1' לסיבית בהתאמה ברישום PORTA או PORTB שלנו. ניתן לנקוט בהליך זהה גם לרישומי TRISA ו- TRISB. לפני שנעביר את קידוד הדוגמה הראשונה שלנו, בואו ונבין קופה של עוד רושמים, כלומר: w ו- f.

W ו- F

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

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

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

נתחיל בתיקון יציאה A כפי שפורט לעיל.

לשם כך עלינו לעבור מבנק 0 לבנק 1, זה נעשה על ידי הגדרת מרשם STATUS שנמצא בכתובת 03h, סיבית 5 ל -1.

BSF 03h, 5

BSF פירושו ערכת סיביות F. אנו משתמשים בשני מספרים לאחר הוראה זו - 03h, שהיא כתובת הרישום STATUS, והמספר 5 המתאים למספר הסיביות.

אז מה שאנחנו אומרים הוא 'הגדר את סיבית 5 בכתובת 03h ל -1'.

אנחנו עכשיו בבנק 1.

MOVLW 00110b

אנו מכניסים את הערך הבינארי 00110 (האות b פירושו שהמספר הוא בינארי) לרשום המטרה הכללית שלנו W. הייתי יכול כמובן לעשות זאת בהקס, ובמקרה זה ההוראה שלנו תהיה:

MOVLW 06h

או שעובד. פירוש ה- MOVLW הוא 'העבר ערך מילולי ל- W', שפירושו באנגלית הכניס את הערך הבא ישירות לרישום ה- W.

כעת עלינו להכניס ערך זה לרשום ה- TRISA שלנו כדי להגדיר את הנמל:

MOVWF 85 שעות

הוראה זו מציינת 'העבר את תוכן ה- W לכתובת הרישום הבאה', במקרה זה הכתובת מתייחסת ל- TRISA.

רישום ה- TRISA שלנו בשלב זה נושא את הדמות 00110, או מוצג בצורה גרפית:

פורט A פין RA4 RA3 RA2 RA1 RA0

בינארי 0 0 1 1 0

קלט / פלט O O I I O

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

BCF 03h, 5

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

סטטוס נרשם ל -0

בשלב זה חזרנו בבנק 0.
להלן הקוד הכל בבלוק אחד:

BSF 03h, 5 עבור לבנק 1
MOVLW 06h הכניס את 00110 ל W
MOVWF 85h העבר 00110 ל- TRISA
BCF 03h, 5 חזור לבנק 0

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

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

שליחת נתונים לנמלים

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

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

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

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

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

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

אנו מקלידים מונח, נגיד START, מקלידים את הקוד:

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

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

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

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

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

למרות שההערות עשויות להיות ממוקמות עדיין היא עשויה להיות קצת עמוסה. זה ידרוש מתן שמות למספרים ואולי יתבצע על ידי הוראה נוספת: 'equ' ההוראה 'equ' מציעה שחלק מהדברים עשויים להיות שווים לדברים אחרים.

זה לא יכול להיות הוראה ל- PIC, אלא למאסף. הוראה זו מאפשרת הקצאת שם למיקום כתובת רישום, או קבוע למונח תכנות.

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

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

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

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

יכול להיות שיש חסרון קל של תוכנית ה- LED המהבהבת שלנו.
לכל הוראה צריך רצף שעון אחד כדי לסיים. במקרה שאנו משתמשים בגביש 4 מגה-הרץ, אז כל הוראה קוראת לסיום של 1/4 מגה-הרץ או 1uS.

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

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

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

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

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

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

אם אולי נקבע את ה- COUNT שלנו לכתובת 08h, למשל, זה יציין יעד רישום אובייקטיבי בסיסי. כברירת מחדל, האזורים שלא נגועים בהם מוגדרים ל- FFh. כתוצאה מכך, אם COUNT מוביל לשעה 08h, תיתקל בערך FFh בזמן הפעלתנו לראשונה. עם זאת, אני אתה, כיצד נוכל לתקן COUNT למספר אחר? כל שנחיל הוא 'להעביר' תחילה הערכת שווי ליעד זה.

להמחשה, נניח שרצינו של- COUNT יהיה ערך של 85 שעות, איננו יכולים להזכיר את COUNT שווה ל- 85 שעות מכיוון שזו המיקום של הרישום התלת-ממדי החוצה עבור נמל A. בדיוק מה שאנו משיגים הוא הדבר הבא: movlw 85h הערך של 85 שעות במרשם W movwf 08h

עכשיו העבירו אותו לרשום השעה 08:00 שלנו. בהמשך, אם אנו מבטאים COUNT שווה ל -8 שעות, COUNT יתאים לערך 85h. עדין, לא! לכן, בתחילה אנו קובעים את הקבוע שלנו: COUNT equ 08h לאחר מכן עלינו להקטין את COUNT זה באחד עד שיהפוך לאפס.

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

ההוראה שאנו הולכים להחיל היא: DECFSZ COUNT, 1 הוראה זו קובעת 'דחה את הרישום (כאן זה COUNT) לפי המספר העוקב אחר הפסיק. אם נגיע לאפס, קפץ שני נקודות קדימה. 'בואו ונמצא אותו בפעולה לפני שנכניס אותו למסלול שלנו.

מה שביצענו הוא בהתחלה לקבוע את COUNT הקבוע שלנו עד 255. הקטע הבא ממקם תג, שנקרא LABEL קרוב להוראות decfsz שלנו.

ה- COUNT decfsz 1 מפחית את הערך של COUNT באחד ושומר על התוצאה הסופית ישר ל- COUNT. יתר על כן, זה מאמת לבדוק אם ל- COUNT יש ערך 0.

אם לא, זה במקרה זה גורם לתוכנית לעבור לשורה שלאחר מכן. עכשיו יש לנו הצהרת 'גוטו' שמחזירה אותנו להוראות decfsz שלנו.

במקרה שהערך של COUNT מבצע שווה, ההוראה decfsz תביא לתוכנית שלנו לזנק 2 נקודות קדימה, והיא נשלחת למקום בו טענו 'המשך כאן'.

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

הבנת לולאות עיכוב

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

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

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

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

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

מהן תת-דרכים

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

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

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

אנו נשקול זאת לעומק מעט יותר. ברגע שנגיע לקטע של התוכנית שלנו ש- CALL xxx, שבו xxx הוא שם תת-הדרכה שלנו, התוכנית מזנקת לכל מקום שבו מותקנת ה- x-subutine. ההוראות בתוך תת-הפעולה מתבצעות.

בכל פעם שההוראה RETURN מתבצעת, התוכנית מזנקת לחזור לתוכנית העיקרית שלנו להוראות שלאחר הוראת ה- CALL שלנו.

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

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

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

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

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

בסופו של דבר, אתה יכול לראות כי על ידי שימוש בתת-דרך עבור לולאת העיכוב שלנו, אולי צמצמנו את ממדי התוכנית.

בכל פעם שאנחנו רוצים עיכוב, אולי כאשר נורית ה- LED דולקת או מכבה, בעצם אנו מכנים את עיכוב המשנה. בסיום תת-התוכנית, התוכנית מובילה חזרה לקו בעקבות הוראות 'השיחה' שלנו. באיור לעיל, אנו מדליקים את נורית הנורית.

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

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

במסגרת ההוראות הבאות, הבה נבדוק קריאה מהיציאות.

עד כה, התחברנו ליציאה A על מנת שנוכל להדליק ולכבות נורית. בשלב זה נראה כיצד אנו קוראים את סיכות ה- I / O על היציאות.

קריאת יציאות קלט / פלט

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

אם תזכור בעל פה מהקורסים הקודמים שלנו, אם ברצונך להקים את יציאות ה- I / O, היינו צריכים לקפוץ מבנק 0 לבנק 1. אנו נשיג זאת בתחילה:

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

BTFSC ו- BTFSS.

ההוראה של BTFSC מסמלת 'בצע בדיקת סיביות במרשם, כמו גם סיבית שאנו מייעדים.

במקרה שזה 0, במקרה זה אנו משמיטים את ההוראה הבאה '. BTFSS מרמז 'בצע בדיקת סיביות במרשם ובסיס שאנו מקימים. במקרה שהוא מוגדר ל- 1, אנו עוקפים את ההוראה הבאה.

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

קוד כאן:

BTFSS PortA, 0 התחל המשך כאן:
:

התוכנית פשוט תעבור אל 'המשך כאן' בתנאי שסיבית 0 ב- PortA מתוכננת ל -1.

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

אפשר אולי לממש את התוכנית לבד, ובכל זאת שילבנו את הרישום איכשהו.

אתה יכול לנסות ולכתוב את התוכנית כולה, כדי לבדוק אם במקרה הבנת את העקרונות. אנו נשתמש במעגל המקביל כבעבר, עם הכללת מתג המחובר ל- RA0 של ה- PIC והמסילה החיובית של האספקה ​​שלנו.

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

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

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

האם עברת אחר השיעורים האלה מההתחלה, ייתכן שאתה מבקש להבין שגילית כרגע עשר מתוך 35 ההוראות עבור PIC 16F84! וכל חלק מאלה במקרה נלמד רק על ידי הפעלה וכיבוי של נורית.

עד כה, חיברנו את PIC מהבהב נורית לסירוגין.

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

שימוש בשטח זיכרון ביעילות

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

movlw 02hmovwf PORTAmovlw 00hmovlw PORTA

בהתחלה מילאנו את רישום ה- w שלנו בשעה 02:00, לאחר מכן העברנו אותו לרישום ה- PortA שלנו כדי להדליק את הנורית. כדי לכבות אותו, ארזנו w עם 00h ואחריו העבירו אותו לרישום ה- PortA שלנו.

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

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

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

A B F0 0 00 1 11 0 11 1 0

בשלב זה נבדוק מה קורה אם נהפוך את B לדומה לפלט הקודם שלנו, ופשוט נשנה את הערך של A:

A B F
0 0 0
0 0 0
1 0 1
1 1 0
1 0 1

אם נשמור על הערך A זהה ל -1, ואנחנו בלעדיים או אותו עם הפלט, הפלט יתחלף. אם אינך יכול להבחין בכך מטבלת האמת, מתחתיה ניתן לראות שימוש בינארי:

0 תפוקה נוכחית
EX-OR עם פלט 1 1 חדש
EX-OR עם פלט 1 0 חדש

אולי אתה יכול לגלות שבאמצעות ORing בלעדי של הפלט עם 1, נעבור כעת את הפלט בין 0 ל -1 ל -0.
לפיכך, כדי להדליק ולכבות את נוריתנו, אנו נדרשים רק כמה משפטים:

MOVLW 02h
דלת XORWF, 1

מה בדיוק נשיג הוא הוספת רישום ה- w שלנו בשעה 02h. אנו במקרה זה בלעדי או להזמין מספר זה ללא קשר למה שיש ב- PortA שלנו. אם ביט 1 הוא 1, הוא ישתנה ל- 0. אם ביט 1 הוא 0, הוא ישתנה ל- 1. בואו נבדוק את הקוד הזה פעם או פעמיים, כדי להציג כיצד הוא פועל בינארי:

דלת
00010
xorwf 00000
xorwf 00010
xorwf 00000
xorwf 00010

אנחנו לא צריכים למעשה לטעון את הערך הזהה לרישום ה- w שלנו בכל פעם, לכן ניתן לבצע זאת בפעם אחת בהתחלה, ופשוט לקפוץ בחזרה לפקודת המעבר שלנו. בנוסף, איננו צריכים לתקן ערך במרשם PortA שלנו. הסיבה? אין ספק, מכיוון שבמקרה בהפעלתו הוא 1, אנו יכולים להחליף אותו בקלות. אני, לחלופין 0 בהפעלה, היינו אפילו מחליפים אותו עכשיו.

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

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

תכנת שינוי מידות (בתים)
נורית מהבהבת מקורית 120
נוהל LED מהבהב נוסף 103
פונקצית LED XOR מהבהבת בשימוש 91
נורית עם מתג מקורי 132
נורית LED עם מתג XOR משמש 124.

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

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

מנהלים הגיוניים

במסגרת ההדרכה האחרונה הצגתי את פעולת OR הבלעדית. הפונקציה ExOR מובנת כמפעיל לוגי.

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

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

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

11001011
וגם 10110011
שווה 10000011

אני מקווה שאתה מסכים, התוצאה תהיה פשוט עם 1 בכל 2 יד ביד אחת עם השנייה בצמד המילים. אנו מסוגלים להשתמש בפונקציית AND כדי לאמת את היציאות, למשל.

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

ה- PIC מספק לנו שני מרכיבים ל- AND.
הם ANDLW ו- ANDWF. ANDLW מאפשרת לנו לבצע פונקציית AND עם פרטי רישום W, וסכום שאנו קובעים.

התחביר הוא: ANDLW שבו בדיוק אנחנו הולכים ותוכן ה- W עם.

התוצאה של פונקציית AND תישמר ישירות במרשם ה- W.
ANDWF מאפשר לנו לבצע פונקציית AND במרשם ה- W ובמרשם אחר, למשל PORT. התחביר הוא: ANDWF, d בו נמצא המרשם שאנחנו מתלהבים ממנו, למשל. PORTA, ו- d מראה את ה- PIC היכן כדאי למקם את התוצאה. אם d = 0, התוצאה מוכנסת לרשום W, ו- d = 1 התוצאה הסופית נשמרת במרשם שקבענו. שני חלקי הקוד שלהלן מציגים דוגמה טובה לכל פונקציית AND.

הראשוני הוא בחינת מצב ה- PORTA, בו עלינו לבדוק אם התשומות הן 1100. אנו יכולים להחזיר את התוצאה לרשם W

1100
ANDWF 05h, 0 האיור השני עשוי כעת לאמת את תוכן מרשם ה- W:
ANDLW 1100

אוֹ

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

A B O / P
0 0 0
0 1 1
1 0 1
1 1 1

מהם מפעילי חשבון

לְהוֹסִיף

פונקציה זו ממלאת את מה שבדרך כלל היא טוענת. זה תורם שתי דמויות! במקרה שהתוצאה של הוספת שתי הדמויות תעלה על 8 סיביות, במקרה זה כנראה יוגדר דגל CARRY. דגל ה- CARRY ממוקם בכתובת 03h bit 0.

כאשר סיבית זו מתוזמנת, אז שתי הדמויות עלו על 8 סיביות. כאשר מדובר ב- 0, במקרה זה התוצאה ממוקמת בתוך 8 סיביות. כמו בעבר, ה- PIC מספק לנו שני סגנונות של ADD, במיוחד ADDLW ו- ADDWF. כפי שאפשר להניח, זה ממש כמו הפונקציה שלעיל. ADDLW מציע את תוכן מרשם ה- W כפי שאנו קובעים. התחביר הוא: ADDLW ADDWF הוסף את תוכן מרשם ה- W ועוד איזה רישום אחר שאנו מייעדים.

התחביר הוא: ADDWF, d הוא איפה

תַת

בשלב זה, אני מניח שאתה לא יכול לשער מה פונקציה זו מבצעת! אכן, חשדת בכך, פונקציה זו
גורע קצת אחד מהשני. שוב ה- PIC מספק לנו 2 טעמים: SUBLW ו- SUBWF. התחביר דומה בדיוק לפונקציה ADD, מלבד ברור שאתה מקליד SUB במקום ADD!

תוספת במקרה שרצינו לכלול 1 למספר ב- PIC, נוכל בהחלט להשתמש בפונקציה ADD ולהשתמש במספר אחד. ~ הקושי בכך הוא שעלינו למקם את הדמות לראשונה במרשם ה- W, ולאחר מכן להשתמש בבקרת ADDLW 1 כדי להגדיל אותה. במקרה שרצינו לכלול 1 לרשום, זה עדיין יכול להיות גרוע יותר. ראשית עלינו למקם את המספר 1 במרשם ה- W, לאחר מכן להשתמש ב- ADDWF, 1. לכן, למשל, לכלול 1 למיקום 0C, נניח שנצטרך להחזיק את החלק הבא של התסריט:

movlw 01
addwf 0c, 1

קיימת שיטה קלה יותר לניהול זה. אנחנו יכולים לממש את הפקודה INCF. התחביר הוא: INCF, d איפה, הוא הרישום, או המקום שאנחנו עוסקים בו, ו- d מראה ל- PIC היכן כדאי למקם את התוצאה. במקרה d = 0, התוצאה היא בתוך המרשם W, ובמקרה d = 1, התוצאה נקבעת במרשם שקבענו.

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

קיימת פקודת תוספת. זה INCFSZ. פקודה זו עשויה להגדיל את הרישום שנקבע, אולם אם אנו הרישום שווה 0 לאחר התוספת (שתתרחש בזמן שנכלול 1 עד 127) לאחר מכן, ה- PIC יעבור ככל הנראה את ההוראה הבאה. חלק הקוד שלמטה משקף זאת:

לולאה incfsz 0C
עיין בלופ
:
:
יתרת התוכנית.

בחלק הקוד שלעיל, 0C יוגדל על ידי 1. הבא בבעלותנו הוראה שתודיע ל- PIC לחזור לתג שלנו בשם Loop, ולהגדיל 0C ב -1 שוב. זה נמשך עד ש- 0C יהיה שווה ל- 127. בנסיבה זו, כאשר אנו מגדילים 0C ב -1, 0C עומד כעת להתאים 0. הוראת INCFSZ שלנו יכולה מאוד להודיע ​​ל- PIC להשמיט את ההוראה הבאה, שהיא במקרה זה הצהרת ההטבה, מכאן ש- PIC ימשיך קדימה עם שארית התוכנית.

ירידה

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

מַשׁלִים

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

הבנת פעולות ביט

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

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

הרשו לי לחזור על השימוש בהם כאן.

BCF

הוראה זו תנגב מעט שאנו קובעים במרשם אותו אנו מייעדים. התחביר
הוא:
BCF,

השתמשנו בזה קודם כדי לשנות מדף 1 לעמוד 0 על ידי הסרת מעט מהמרשם STATUS. אנו יכולים להשתמש בו גם כדי לתקן קצת ל 0 בכל רישום / מיקום אחר. למשל, אם נרצה להגדיר את הסיבית השלישית ב- 11001101 שנשמרה בסעיף 0C ל 0, אנו עשויים
לְהַכנִיס:

BCF 0C, 03

BSF

הוראה זו תתקן את כל הסיביות שנקבע ל -1 בכל רישום שנציין. השתמשנו בזה קודם כדי לעבור מעמוד 0 לעמוד 1. התחביר הוא: BSF ,, והוא משמש באותה שיטה בדיוק כמו BCF לעיל.

עד כה נוכל להגדיר או לנקות קצת במרשם. עם זאת, דמיין אם עלינו לבדוק בעצם אם קצת הוא 1 או 0 במרשם?

אין ספק שאפשר להשתמש ב- BTFSC. זה מציין את רישום בדיקת הסיביות F, ודלג אם זה ברור. הוראה זו תנתח את החלק שאנו מייעדים במרשם. במקרה שהסיבית היא 0, ההוראה תודיע ל- PIC לעבור את ההוראה הבאה.

אנו עשויים להשתמש בהוראה זו אם נרצה לבדוק דגל, למשל דגל הנשיאה. זה חוסך מאיתנו צורך לקרוא את רישום STATUS ולחפש את הסיביות הבודדות כדי ללמוד אילו דגלים קבועים. 29 למשל, אם נרצה לבדוק אם דגל ה- Carry הוגדר ל- 1 לאחר שהוספנו 2 דמויות, נוכל להקליד את הדברים הבאים:

BTFSC 03h, 0
המשך כאן אם מוגדר ל -1
או כאן אם מוגדר כ- 0

במקרה שמצב הביט הוא 1, במקרה זה ההוראה שלאחר BTFSC תושלם. במקרה שהוא מוגדר ל- 0, במקרה זה ההדרכה הבאה מדלגת. החלק הבא של הקוד מציג בו הוא עשוי להיות מועסק:

לולאה:
:
:
BTFSC 03,0
עיין בלופ

בקוד שלעיל, ה- PIC פשוט ייצא מהלולאה למקרה שמספר 0 של רישום STATUS (או דגל ה- Carry) מוגדר ל- 0. אחרת, פקודת ה- goto תיערך.

BTFSS

הוראה זו קובעת את רישום בדיקת הסיביות F ודלג אם הוא מוגדר. ניתן להשוות זאת להוראות BTFSC, מלבד זאת ה- PIC ישמיט את ההוראה הבאה אם ​​הסיב שהערכנו מוגדר ל- 1, במקום 0.

CLRF

הוראה זו תתקן את כל הפרטים של רישום ל- 0. התחביר הוא:

CLRF
השתמשנו בזה קודם כדי להגדיר את תפוקת הנמלים ל- 0, על ידי יישום CLRF 85h. בנוסף, השתמשנו בו כדי לתקן את הנמלים כך שיכללו את כל הפינים להפקה באמצעות CLRF
05h.

CLRW

זה יכול להיות דומה להוראות CLRF, למעט ניקוי מרשם ה- W. התחביר הוא די פשוט:

CLRW

RLF ו- RRF

כיוונים אלה היו מעבירים מעט ברושם חריץ יחיד שמאלה (RLF) או ימינה (RRF) ברושמה. למשל, אם היינו זקוקים ל 00000001 והיינו מעסיקים RLF, במקרה כזה ייתכן שנחזיק ב- 00000010. בשלב זה, מה קורה במקרה שיש 10000000 ויישם את הוראות RLF? אין ספק שה -1 יהיה ממוקם בדגל הנשיאה. במקרה שיישמנו את הוראת ה- RLF פעם נוספת, ה- 1 יופיע שוב בהתחלה. האחד מתרחש, לעומת זאת, להוראות RRF. המקרה בנקודה למטה מראה זאת להוראות RLF, בהן אנו יכולים לראות את 8 סיביות של רישום, כמו גם את דגל הנשיאה:

ג 87654321
0 00000001
RLF 0 00000010
RLF 0 00000100
RLF 0 00001000
RLF 0 00010000
RLF 0 00100000
RLF 0 01000000
RLF 0 10000000
RLF 1 00000000
RLF 0 00000001

תוכנית לדוגמא

כעת נראה קוד לדוגמא שניתן לקמפל ולהניע. זה ייצור אור רצף המתחיל ב- PortA bit 0, ועובר ל- PortB bit 8 ו-
ואז חוזר.
חבר נוריות לכל אחד מסיכות הנמל. יהיה לנו קצת
נהלים שצוינו במדריך זה.

TIME EQU 9FH משתנה לולאת העיכוב.
PORTB EQU 06H כתובת יציאה B.
TRISB EQU 86H יציאה B כתובת Tristate.
פורטה EQU 05H כתובת יציאה.
יציאת TRISA EQU 85H כתובת Tristate.
STATUS EQU 03H בחר הרשמה לדף.
COUNT1 EQU 0CH רישום לולאה.
COUNT2 EQU 0DH רישום לולאה.

סטטוס BSF, 5 עבור לדף 1
MOVLW 00H והגדר
MOVWF TRISB הן יציאות A ו- B
MOVLW 00H לפלט,
MOVWF TRISA ואז חזור ל
סטטוס BCF, 5 עמוד 0.
MOVLW 00H נמל נקי A.
דלת MOVWF

תחילת התוכנית הראשית

RUNMOVLW
01H הגדר את bitMOVWF הראשון
פורטב בנמל B.CALL
עיכוב המתן זמן התקשר
לְעַכֵּב
הזז את הסיבוב ביציאה B שמאלה, ואז השהה
פורטב, 1CALL
DELAYCALL
DELAYRLF
פורטב, 1CALL
DELAYCALL
DELAYRLF
פורטב, 1CALL
DELAYCALL
DELAYRLF
פורטב, 1CALL
DELAYCALL
DELAYRLF
פורטב, 1CALL
DELAYCALL
DELAYRLF
פורטב, 1CALL
DELAYCALL
DELAYRLF
פורטב, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1 זה מעביר את החלק לדגל ה- carry
עכשיו עבור לנמל A, והזז את החלק שמאלה
PORTA, 1 זה מעביר את הסיבית מדגל האפס לתוך PortACALL
DELAY התקשר DELAYRLF
דלת, 1 שיחה
DELAYCALL
DELAYRLF
דלת, 1 שיחה
DELAYCALL
DELAYRLF
דלת, 1 שיחה
DELAYCALL
לְעַכֵּב
הזז את הסיבוב לאחור בנמל ARRF
דלת, 1 שיחה
DELAYCALL
DELAYRRF
דלת, 1 שיחה
DELAYCALL
DELAYRRF
דלת, 1 שיחה
DELAYCALL
DELAYRRF
PORTA, 1 זה מעביר את הסיבית לדגל האפס. עכשיו הזז את הסיבית
בחזרה בנמל BRRF
פורטב, 1CALL
DELAYCALL
DELAYRRF
פורטב, 1CALL
DELAYCALL
DELAYRRF
פורטב, 1CALL
DELAYCALL
DELAYRRF
פורטב, 1CALL
DELAY התקשר DELAYRRF
פורטב, 1CALL
DELAYCALL
DELAYRRF
פורטב, 1CALL
DELAYCALL
DELAYRRF
פורטב, 1CALL
DELAYCALL
עיכוב עכשיו חזרנו לאן שהתחלנו, GOTO
רוץ בוא נלך שוב.

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

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

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

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

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

10 שנים K = 0
11 K = K + 1
12 אם K> 10 ואז GOTO 20 ELSE GOTO 11
20 הדפס ק
21 END

התוכנית מתחילה בשורה 10. ברגע ש- K מתוכננת ל- 0, היא תעבור בהמשך לשורה 11. לאחר שכללנו 1 ל- K, לאחר מכן נמשיך לקו 12.

בנקודה זו אנו עשויים להיות סקרנים אם K גבוה מ- 10. במקרה כזה, הבא לקו 20, אחרת נחזור לקו 11.

קו 20 מתעד את ה- K, ושורה 21 מסיימת את התוכנית. BASIC משתמשת בסטטיסטיקה של קווים כדי לסייע למתכנת לנהל רישום היכן הנושאים נמצאים, מכיוון שלא ניתן להשתמש בתוויות. ה- PIC מעסיק תוויות כדי לברוח בין יעדים - או שמא באמת?

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

בדיוק מה שקורה הוא ש- PIC מנצל מונה קו פנימי שנקרא Program Counter. מסלול מונה התוכנית (בקיצור המחשב האישי) של יעד הזיכרון בו נמצאת ההוראה הנוכחית.

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

הוראות למחשב 0000 movlw 03
0001 movwf 0C
0002 לולאה decfsc 0C
0003 לוטו לוטו
0004 סוף

בהדגמה לעיל תיקנו את המחשב ל 0000. על כך יש לנו את ההוראה movlw 03. כאשר ה- PIC יישם נתונים אלה, הוא מגדיל את המחשב על מנת שההוראה הבאה תיסרק. בשלב זה ה- PIC צופה ב- movwf 0C. המחשב מצטבר שוב.

עכשיו PIC לומד decfsc 0C. במקרה והפרטים של 0C אינם 0, במקרה זה המחשב מוגדל ב- 1, כמו גם ההוראה הבאה, goto Loop, מודיעה למחשב לחזור למצב 0003, שם נמצא הלולאה האמורה. אם הפרטים של 0C הם 0, אז מומלץ למחשב להגדיל ב -2, פשוט השמיט את ההוראה הבאה.

הבנת טבלאות נתונים

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

מחשב שווה 02
03
טבלת שיחות
:
מחשב addwf שולחן
שוב 01
שוב 02
שוב 03
שוב 04
ממשיכה 05
ממשיכה 06
שוב 07
לַחֲזוֹר

ההוראה הראשונית היא הקצאת התווית PC עם הכתובת של דלפק התוכנית (02h). אנו נהיה זמן קצר לאחר שנכניס את הערך של 03h לרשם w. אנחנו אחרי זה מתקשרים לשולחן. השורה העיקרית בטבלת תת התהליכים מגדילה את פרטי מרשם ה- W (03h) לדלפק התוכנית.

זה מפעיל את מונה התוכנית להעלות ב -3, או לנסח זאת בצורה אחרת, מגרה את מונה התוכנית להמשיך במורד 3 שורות. בעוד הדלפק מגיע 3 שורות למטה, ה- PIC מזהה את ההוראה retlw. פקודה זו שולחת את הערך העוקב אחריו לרישום W, שאחריו חוזר מתת-הפעולה. RETLW בעצם מסמל Return, מילולי ל- W.

ראה הנחתי פסיק אחרי המילה Return. מכיוון שאנו נמצאים בתת-דרך, אנו זקוקים להנחיית חזרה על פניו. לכן ה- RET בהוראה. אחרי ההוראה RETLW זה מספר, וזה בדיוק מה שמכניסים לרשם W.

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

נושא ההפרעות עשוי להיות הארוך והקשה ביותר לעבור.

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

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

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

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

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

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

הבנת הפרעות

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

אם תבדוק את ה- pin-out של ה- PIC, תבחין כי pin 6 זה RB0 / INT. בשלב זה, RB0 הוא בבירור נמל B ביט 0. ה- INT מייצג שהוא יכול להיות מוגדר כמו סיכת הפסקה חיצונית. יתר על כן, סיכות יציאה B 4 עד 7 (סיכות 10 עד 13) עשויות לשמש גם להפסקות. לפני שנוכל להעסיק את INT או סיכות יציאה B אחרות, עלינו לבצע שתי משימות. ראשית עלינו להודיע ​​ל- PIC שנשתמש בהפרעות.

לאחר מכן, עלינו לקבוע איזה סיכה של יציאה B נשתמש בהפסקה ולא כסיכת קלט / פלט. בתוך ה- PIC תוכלו למצוא מרשם המכונה INTCON ונמצא בכתובת 0Bh. במרשם זה תגלה 8 סיביות שעשויות להיות מופעלות או מושבתות. ביט 7 של INTCON מכונה GIE. זהו הפעלת ה- Interrngupt הגלובלית. תיקון זה ל- 1 מודיע ל- PIC כי נשתמש בהפרעה.

ביט 4 של INTCON מכונה INTE, INTerrupt Enable. העמדת הסיבית הזו ל -1 מעבירה ל- PIC כי RB0 עומד להיות סיכת הפסקה. קביעת התצורה של סיבית 3, הנקראת RBIE, מודיעה ל- PIc שאנחנו הולכים להשתמש בסיביות יציאה B 4 עד 7. בשלב זה ה- PIC מבין מתי הסיכה הזו יכולה להיות גבוהה או נמוכה, צריך לעצור את מה שהיא מבצעת ולהמשיך בהפסקה. שגרה. בשלב זה, עלינו ליידע את ה- PIC האם ההפרעה תהיה ככל הנראה בקצה העולה (0V ל- + 5V) או בשינוי הקצה הנפילה (+5V ל- 0V) של האות.

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

הקצה 'מפעיל' מתוזמן לרישום נוסף הנקרא OPTION register, בכתובת 81h. הסיבית שאנחנו מתלהבים ממנה היא סיבית 6, המכונה לעתים קרובות INTEDG.

הגדרת זה ל- 1 מפעילה את שיבוש ה- PIC בקצה ההרכבה (מצב ברירת מחדל) והגדרתו ל- 0 מגרה את ה- PIC להפרעה בקצה ההזזה. אם תרצה ש- PIC יופעל בקצה העולה, אז בהחלט לא צריך לעשות שום דבר למעט זה.

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

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

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

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

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

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

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

לכן, בזמן שאנחנו מחברים את התוכנית שלנו עם הפרעות, ראשית עלינו להודיע ​​ל- PIC לדלג על כתובת 0004h ולשמור על שגרת ההפרעה שמתחילה בכתובת 0004h בדידה משאר התוכנית.

זה יכול להיות ללא טרחה לביצוע. בתחילה, אנו מתחילים את התוכנית שלנו בפקודה המכונה ORG. פקודה זו מציינת מקור, או התחל. אנחנו דבקים בזה עם כתובת. מכיוון שה- PIC מתחיל בכתובת 0000h, אנו מקלידים ORG 0000h. לאחר מכן עלינו לעקוף את כתובת 0004h. אנו משיגים זאת על ידי הצבת הוראות GOTO, בליווי תווית העצות לתכנית העיקרית שלנו.

לאחר מכן אנו מקפידים על פקודת GOTO זו עם ORG אחד נוסף, הרגע הזה עם הכתובת 0004h. לאחר פקודה זו נכניס את שגרת ההפרעה שלנו. בשלב זה, אולי נוכל להקליד את שגרת ההפרעה שלנו היישר בעקבות פקודת ה- ORG השנייה, או שנוכל להציב הצהרת GOTO המצביעה על שגרת ההפרעה.

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

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

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

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

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

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

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

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

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

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

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

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

התוכנית תספור בין 0 ל -9, וניתן יהיה לצפייה על 4 נוריות בצורה בינארית, יחד עם הקלט או ההפרעה יהיו ככל הנראה ב- RB0.

הדבר הראשון שעלינו לבצע הוא להודיע ​​ל- PIC לזנק מעל הכתובת אליה מצביע מונה התוכנית בכל פעם שמתרחשת הפרעה.

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

עכשיו אנחנו צריכים לומר ל- PIC שאנחנו הולכים להשתמש בהפרעות, ואנחנו משתמשים בסיכה RB0 6 כסיכת הפסקה:

bsf INTCON, 7GIE - הפעלת הפרעה גלובלית (1 = הפעלה)
bsf INTCON, 4INTE - הפעלת הפסקת RB0 (1 = הפעלה)
אני הולך לנקות את דגל ההפרעה לכל מקרה (אני אף פעם לא סומך על שום דבר!)
bcf INTCON, 1INTF - קצת דגל ברור לכל מקרה

נכון לעכשיו עלינו להקים את 2 היציאות שלנו. זכור שכאשר אנו משתמשים כעת ב- RB0 כסיכת הפסקה, יש לקבוע זאת כקלט:

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

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

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

בתחילה נשתמש במסך בן 7 קטעים שיכול לכל היותר לעבור בין 0 ל -15 (0 ל- F בהקס). בהמשך, ברצוני להראות לכם כמה מפקודות החשבון אשר נקלעתם אליהן בשיעורים האחרונים.

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

בשלב זה אנו מבינים אם הערך של COUNT הוא 9 ומעלה. בדיוק מה שעלינו להשיג כעת הוא אם COUNT הוא יותר מ- 9, הצב אותו בחזרה ל- 0, או אחר חזור לתוכנית הראשית כדי להבטיח שנוכל להעביר אותו ליציאה A. הפקודה BTFSS מכיוון שאתה מבין שהמעקב הבא
הוראות למקרה שדגל הנשיאה מתוזמן כלומר COUNT = 10:

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

בכל פעם שאתה מפעיל את המתג, נוריות הנוריות יספרו בינארי מ 0000 ל 1010 ואז חזרה ל 0000.

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

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

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