AVRSH: מעטפת מתורגמן פיקודי עבור Arduino/AVR: 6 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:18

תמיד רצית להיות "מחובר" למיקרו -בקר ה- AVR שלך? חשבת פעם שזה יהיה מגניב "לחתול" רישום כדי לראות את תוכנו? האם תמיד רצית דרך להפעיל ולכבות מערכות משנה היקפיות בודדות של ה- AVR או Arduino שלך בזמן אמת *? גם אני אז כתבתי את מעטפת AVR, מעטפת דמוית UNIX. הוא דומה ל- UNIX מכיוון שהוא מזכיר את חשבון הפגז שיצאת וקנית כדי להריץ את הרובוטים שלך בהתנגשות irc nick, כמו גם שיש לו פקודה או שתיים במשותף. יש לה גם מערכת קבצים הדומה ל- extix של UNIX, תוך שימוש ב- EEPROM חיצוני, אך זה הפך לפרויקט בפני עצמו, כך שאוציא את המודול בנפרד תחת הוראה אחרת כאשר הוא מוכן לייצור. להלן רשימה של הדברים שאתה יכול לעשות כרגע עם מעטפת AVR:

• קרא את כל רשימות כיוון הנתונים (DDRn), יציאות וסיכות בזמן אמת
• כתוב לכל ה- DDRn, היציאות והסיכות שלך כדי להפעיל מנועים, נוריות LED או לקרוא חיישנים בזמן אמת
• רשום את כל הרישומים הידועים במערכת
• צור ושמור ערכים במשתנים המוגדרים על ידי משתמשים המגובים על ידי EEPROM.
• צור סיסמת שורש ואימות נגדה (משמש לגישה Telnet)
• קרא את מהירות שעון המעבד המוגדרת
• שנה את מהירות השעון של המעבד על ידי הגדרת מכשיר קבוע מראש
• התחל ועצור טיימרים של 16 סיביות לתזמון של דברים שונים
• הפעלה ו/או כיבוי של מערכות משנה היקפיות: ממירים אנלוגיים לדיגיטליים (ADC), ממשק היקפי סידורי (SPI), ממשק דו חוטי (TWI/I2C), UART/USART. שימושי כאשר אתה רוצה להפחית את צריכת החשמל של המיקרו -בקר או לאפשר פונקציות מסוימות.
• כתוב ב- C ++ עם אובייקטים לשימוש חוזר.

מדריך זה יעבור בהתקנה, בשימוש ובהתאמה אישית של avrsh.

שלב 1: מה שאתה צריך

הוראה זו אינה דורשת הרבה פרט לכך שאתה:

• יש Arduino או ATmega328P. AVR אחרים עשויים לעבוד, אך ייתכן שיהיה עליך לשנות את הקוד כדי להציג את כל הרישומים הייחודיים ל- MCU שלך. השמות צריכים להתאים רק את מה שרשום בקובץ הכותרת הייחודי ל- MCU שלך. רבים משמות הרישומים זהים בין מכשירי AVR, כך שהקילומטראז 'שלך עשוי להשתנות בעת העברה.
• יש דרך להתחבר ל- USART הטורי של ה- Arduino/AVR שלך. המערכת נבדקה בהרחבה ביותר עם מסוף AVR, אפליקציית Windows המחברת חיבור טורי באמצעות יציאת ה- USB או ה- COM שלך. עובד עם Arduinos באמצעות חיבור ה- USB וכל AVR באמצעות ה- USB-BUB של Moderndevice.com. אפשרויות מסוף אחרות כוללות: מרק, minicom (Linux ו- FreeBSD), מסך (Linux/FreeBSD), Hyperterminal, Teraterm. גיליתי שפכטל וטרטרם שולחים קצת זבל בעת החיבור כדי שהפקודה הראשונה שלך עלולה להתבלבל.
• התקן את הקושחה של AVR Shell ותפעיל אותה, שתוכל להוריד מדפים אלה, או שתוכל תמיד לקבל את הגירסה העדכנית ביותר ב- BattleDroids.net.

כדי להתקין את מסוף ה- AVR, פשוט פרק אותו והפעל אותו. כדי להתקין את קושחת AVR Shell, הורד אותה או העלה ישירות את קובץ ה- hex וחבר את הטרמינל הטורי שלך ב- 9600 baud, או הידור אותו בעצמך עם "make" ולאחר מכן "צור תוכנית" להעלאת ה- hex. שים לב, ייתכן שיהיה עליך לשנות את הגדרות AVRDUDE כך שישקפו את יציאת ה- COM שלך. הערה: התכונה PROGMEM נשברת ביישום AVR GCC הנוכחי עבור C ++ וזה באג ידוע. אם אתה אוסף אותו, צפה לקבל הודעות אזהרה רבות האומרות "אזהרה: ניתן להכניס רק משתנים מאוזנים לאזור זיכרון התוכנית". מלבד היותו מעצבן לראות, אזהרה זו אינה מזיקה. מאחר ש- C ++ בפלטפורמה המשובצת אינו גבוה ברשימת העדיפויות של AVR GCC, לא ידוע מתי זה יתוקן. אם תבדוק את הקוד, תראה היכן עשיתי דרכים לעקוף את האזהרה הזו על ידי יישום הצהרות התכונות שלי. די פשוט. הורד והתקן כל דבר שתצטרך, ואז הפוך את הדף ובוא נתחיל לפצח.

שלב 2: קריאה וכתיבה של פנקסים

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

להדפיס רשימות ותקבל תדפיס שנראה כך

אני יודע על הרישומים הבאים:

TIFR0 PORTC TIFR1 PORTD TIFR2 DDRD PCIFR DDRB EIFR DDRC EIMSK PINB EECR Pinc EEDR Pind SREG EEARL GPIOR0 EEARH GPIOR1 GTCCR GPIOR2 TCCR0A TCCR0B TCNT0 OCR0A OCR0B SPCR SPDR ACSR SMCR MCUSR MCUCR SPMCSR WDTCSR CLKPR PRR OSCCAL PCICR EICRA PCMSK0 PCMSK1 TIMSK0 TIMSK1 TIMSK2 ADCL ADCH ADCSRA ADCSRB ADMUX DIDR0 DIDR1 TCCR1A TCCR1B TCCR1C TCNT1L TCNT1H ICR1L ICR1H OCR1AL OCR1AH OCR1BL OCR1BH TCCR2A TCCR2B TCNT2 OCR2A OCR2B ASSR TWBR TWSR TWR0 UR0 UR0 UR0 UR0 UR כדי לראות כיצד נקבעות הביטים הבודדים בכל רגיסטר, השתמש בפקודה cat או echo

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

GPIOR0 (0x0) מוגדר ל- [00000000] הפלט מציג את שם הרשמה, את הערך ההקסדצימלי שנמצא ברגיסט ואת הייצוג הבינארי של הרשמה (מציג כל סיביה כ- 1 או 0). כדי להגדיר ביט מסוים בכל רישום, השתמש באופרטור "אינדקס של" . לדוגמה, נניח שאני רוצה את הסיביות השלישית ל- 1

%GPIOR0 [3] = 1 והמעטפת תיתן לך תגובה המצביעה על הפעולה והתוצאה

GPIOR0 (0x0) מוגדר ל- [00000000] (0x8) מוגדר ל- [00001000] אל תשכח את סימן האחוזים לספר לקליפה שאתה עובד עם רישום. שים לב גם על ידי הגדרת הסיביות השלישית, זה 4 סיביות פנימה מכיוון שה- AVR שלנו משתמש באינדקס מבוסס אפס. במילים אחרות, לספור לביט השלישי אתה סופר 0, 1, 2, 3, שהוא המקום הרביעי, אבל הקטע השלישי. אתה יכול לנקות קצת באותו אופן על ידי הגדרת קצת לאפס. על ידי הגדרת סיביות מסוג זה תוכל לשנות את תפקוד ה- AVR שלך תוך כדי תנועה. לדוגמה, על ידי שינוי ערך ההתאמה של טיימר ה- CTC שנמצא ב- OCR1A. זה גם מאפשר לך להציץ להגדרות מסוימות שתצטרך לבדוק את הקוד שלך באופן תוכניתי, כגון ערך UBBR עבור קצב השידור שלך. עבודה עם DDRn, PORTn ו- PINn סיכות הקלט/פלט מוקצות גם לרשמים וניתן להגדיר אותן בדיוק באותו אופן, אך נוצר תחביר מיוחד לעבודה עם סוגים אלה של רגיסטרים. בקוד, יש תהליך רגיל להפעלת נורת LED או מכשיר אחר הדורש שיא דיגיטלי גבוה או נמוך. זה דורש הגדרת רשם כיוון הנתונים כדי לציין שהסיכה מיועדת לפלט ולאחר מכן כתיבת 1 או 0 לביט המסוים ביציאה הנכונה. בהנחה שיש לנו נורית מחוברת לפין דיגיטלי 13 (PB5) ואנו רוצים להדליק אותה, כך תוכל לעשות זאת בזמן שה- AVR פועל

הגדר סיכה pb5 פלט כתב סיכה pb5 גבוה הפלט, מלבד היכולת לראות את ה- LED שלך נדלק, ייראה כך

root@ATmega328p> set pin pb5 output Set pb5 for outputroot@ATmega328p> כתיבת פין pb5 גבוה כתוב לוגיקה גבוהה לפין pb5 "Root@ATmega328p>" הוא הנחיה של הקליפה המצביעה על כך שהיא מוכנה לקבל פקודות ממך. כדי לכבות את הנורית, פשוט היית כותב שפל לסיכה. אם ברצונך לקרוא את הקלט הדיגיטלי מתוך סיכה, השתמש בפקודת read. באמצעות הדוגמא שלנו לעיל

root@ATmega328p> קרא סיכה pb5Pin: pb5 הוא גבוה לחלופין, פשוט מהדהד את רישום הסיכות השולט ביציאת הסיכה הזו. לדוגמה, אם יש לנו מתגי טבילה המחוברים לסיכה 7 ו -8 דיגיטלית (PD7 ו- PD8), תוכל לשלוח את הפקודה

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

שלב 3: קריאה וכתיבה של נתיכים

נתיכים הם סוגים מיוחדים של רישומים. הם שולטים בכל דבר, החל ממהירות השעון של המיקרו-בקר שלך ועד לאילו שיטות תכנות זמינות ועד EEPROM להגנה על כתיבה. לפעמים יהיה עליך לשנות הגדרות אלה, במיוחד אם אתה יוצר מערכת AVR עצמאית. אני לא בטוח שעליך לשנות את הגדרות הפתיל שלך ב- Arduino. היזהר עם הנתיכים שלך; אתה יכול לנעול את עצמך אם אתה מגדיר אותם בצורה לא נכונה. בהוראה קודמת, הדגמתי כיצד אתה יכול לקרוא ולהגדיר את הנתיכים שלך באמצעות המתכנת וה- avrdude. כאן, אראה לך כיצד להחזיר את הנתיכים שלך בזמן הריצה כדי לראות כיצד ה- MCU שלך הגדיר אותם בפועל. שים לב שזו לא הגדרת זמן הידור שאתה מקבל מההגדרות, אלא הנתיכים בפועל כאשר ה- MCU קורא אותם בזמן ההפעלה. מטבלה 27-9 בגיליון הנתונים של ATmega328P (קובץ נתונים, יותר דומה לו) הביטים של ה- Byte Low Byte הם כדלקמן:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0דבר מעניין לציין הוא שעם נתיכים, 0 פירושו מתוכנת ו -1 פירושו שהביט המסוים הזה אינו מתוכנת. קצת אינטואיטיבי, אבל ברגע שאתה יודע את זה אתה יודע את זה.

• CKDIV8 מגדיר את שעון המעבד שלך לחלק ב- 8. ה- ATmega328P מגיע מהמפעל המתוכנת להשתמש במתנד הפנימי שלו במהירות 8MHz כאשר CKDIV8 מתוכנת (כלומר מוגדר ל- 0) ונותן לך תדר F_CPU סופי או מעבד של 1MHz. ב- Arduino זה משתנה מכיוון שהם מוגדרים לשימוש במתנד חיצוני במהירות 16MHz.
• CKOUT כשהוא מתוכנת יפיק את שעון המעבד שלך על PB0, שהוא פין 8 דיגיטלי ב- Arduinos.
• SUT [1..0] מציין את זמן ההפעלה של ה- AVR שלך.
• CKSEL [3..0] קובע את מקור השעון, כגון מתנד RC פנימי, מתנד חיצוני וכו '.

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

root@ATmega328p> קרא lfuse נתיך תחתון: 0xffאז, כל הביטים מוגדרים ל 1. עשיתי את אותו הליך על שיבוט Arduino וקיבלתי את אותו ערך. בבדיקת אחת ממערכות ה- AVR העומדות בפני עצמי, קיבלתי 0xDA שזה הערך שהגדרתי זמן מה בעת קביעת התצורה של השבב. אותו הליך משמש לבדיקת בייט נתיכים גבוהים, בייט נתיבים מורחבים ונעילה. בתים הכיול ופיוז החתימה הושבתו בקוד עם הנחיית מעבד מראש של #if 0, שתוכל לשנות אם אתה מרגיש גרוע.

שלב 4: פקודות אחרות

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

root@ATmega328p> תדירות fcpuCPU: 16000000זה 16 מיליון, או 16 מיליון הרץ, הידוע יותר בשם 16 מגה -הרץ. אתה יכול לשנות זאת במהירות, מכל סיבה שהיא, באמצעות פקודת השעון. לפקודה זו נדרש טיעון אחד: מכשיר ההרשמה לשימוש בעת חלוקת מהירות השעון שלך. פקודת השעון מבינה את ערכי המדידה הבאים:

• ckdiv2
• ckdiv4
• ckdiv8
• ckdiv16
• ckdiv32
• ckdiv64
• ckdiv128
• ckdiv256

שימוש בפקודה:

שעון ckdiv2 כאשר מהירות המעבד שלך היא 16MHz תגרום לשינוי מהירות השעון שלך ל- 8MHz. שימוש במכשיר טעינה מראש של ckdiv64 עם מהירות שעון ראשונית של 16MHz יביא למהירות שעון סופית של 250 KHz. למה לכל הרוחות אתה רוצה להפוך את ה- MCU שלך לאט יותר? ובכן, ראשית, מהירות שעון נמוכה יותר צורכת פחות חשמל ואם המערכת שלך פועלת מתוך סוללה במתחם הפרויקט ייתכן שלא תזדקק לה להפעלה במהירות הגבוהה ביותר, ולכן תוכל להוריד את המהירות ולהפחית את צריכת החשמל שלה., הגדלת חיי הסוללה. כמו כן, אם אתה משתמש בשעון עבור כל סוג של בעיות תזמון עם MCU אחר, נניח, יישום UART תוכנה או דבר כזה, ייתכן שתרצה להגדיר אותו לערך מסוים שקל להשיג קצב שידור יפה אפילו עם שיעורי שגיאות נמוכים יותר. הפעלה והפעלה של מערכות משנה היקפיות באותו הערה של הפחתת צריכת החשמל שהוזכרה קודם לכן, ייתכן שתרצה להפחית עוד יותר את החשמל על ידי כיבוי חלק מהציוד ההיקפי המשולב שאינך משתמש בו. מתורגמן הפקודה ומעטפת יכולים כעת להפעיל ולכבות את הציוד ההיקפי הבא:

• ממיר אנלוגי לדיגיטלי (ADC). ציוד היקפי זה משמש כאשר יש לך חיישן אנלוגי המספק נתונים (כמו טמפרטורה, אור, תאוצה וכו ') וצריך להמיר אותו לערך דיגיטלי.
• ממשק היקפי סידורי (SPI). האוטובוס SPI משמש לתקשורת עם התקנים אחרים התומכים ב- SPI, כמו זיכרונות חיצוניים, מנהלי התקני LED, חיבורי ADC חיצוניים וכו '. חלקים מה- SPI משמשים לתכנות ספק שירותי אינטרנט, או לפחות הפינים, אז היזהר בעת כיבוי זה. אם אתה מתכנת באמצעות ספק שירותי אינטרנט.
• ממשק דו חוטי. התקנים חיצוניים מסוימים משתמשים באוטובוס I2C כדי לתקשר, אם כי אלה מוחלפים במהירות בהתקנים התומכים ב- SPI מכיוון של- SPI יש תפוקה גדולה יותר.
• USART. זהו הממשק הטורי שלך. אתה כנראה לא רוצה לכבות את זה אם אתה מחובר ל- AVR דרך החיבור הטורי! עם זאת, הוספתי את זה כאן כשלד ליציאה למכשירים עם מספר USART כמו ATmega162 או ATmega644P.
• את כל. טיעון זה לפקודת ההפעלה או ההפעלה מפעיל את כל הציוד ההיקפי שהוזכר או מכבה את כולם באמצעות פקודה אחת. שוב, השתמש בפקודה זו בתבונה.

root@ATmega328p> powerdown twi Powerdown of twi complete.root@ATmega328p> powerup twi Powerup of twi complete.

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

טיימר התחלהועצור את הטיימר עם טיעון העצירה

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

root@ATmega328p> התחלת טיימר התחיל timer.root@ATmega328p> עצירת טיימר זמן שחלף: ~ 157 שניות אימות המעטפת יכולה לאחסן סיסמה בת 8 תווים ב- EEPROM. מנגנון סיסמה זה נוצר כדי לתמוך ביכולות ההתחברות של telnet, אך ניתן להרחיבו כדי להגן על דברים אחרים. לדוגמה, תוכל לדרוש פקודות מסוימות, כגון שינוי ערכי רישום, באמצעות מנגנון האימות. הגדר את הסיסמה באמצעות פקודת הסיסמה

root@ATmega328p> passwd blah כתוב סיסמת שורש ל- EEPROMאשר את הסיסמה שלו (או דרוש הרשאה באופן תכנותי באמצעות הקוד) באמצעות פקודת האימות. שים לב שאם אתה מנסה לשנות את סיסמת השורש וכבר קיימת סיסמת שורש, עליך לאשר את עצמך כנגד הסיסמה הישנה לפני שתאפשר לשנות אותה לסיסמה חדשה.

root@ATmega328p> passwd blinky עליך לאשר את עצמך first.root@ATmega328p> auth blahAuthorized.root@ATmega328p> passwd blinky כתוב סיסמת שורש חדשה ל- EEPROMכמובן שתצטרך לטעון את קובץ avrsh.eep אם תמחק את הקושחה כדי לשחזר את הערכים והמשתנים הישנים שלך. Makefile ייצור עבורך את קובץ ה- EEPROM. משתנים המעטפת מבינה את הרעיון של משתנים שהוגדרו על ידי המשתמש. הקוד מגביל את זה ל -20, אך תוכל לשנות זאת אם תרצה בכך על ידי שינוי הגדרת MAX_VARIABLES ב- script.h. אתה יכול לשמור כל ערך של 16 סיביות (כלומר, כל מספר עד 65, 536) למשתנה שייזכר מאוחר יותר. התחביר דומה לרשמים למעט סימן דולר ($) משמש לציון משתנים לקליפה. רשום את כל המשתנים שלך באמצעות הפקודה משתני הדפסה

משתנה הדפסה משתנים מוגדרים על ידי משתמש: שם אינדקס -> ערך (01): $ FREE $ -> 0 (02): $ FREE $ -> 0 (03): $ FREE $ -> 0 (04): $ FREE $ -> 0 (05): $ FREE $ -> 0 (06): $ FREE $ -> 0 (07): $ FREE $ -> 0 (08): $ FREE $ -> 0 (09): $ FREE $ -> 0 (10): $ FREE $ -> 0 (11): $ FREE $ -> 0 (12): $ FREE $ -> 0 (13): $ FREE $ -> 0 (14): $ FREE $ -> 0 (15): $ FREE $ -> 0 (16): $ FREE $ -> 0 (17): $ FREE $ -> 0 (18): $ FREE $ -> 0 (19): $ FREE $ -> 0 (20): $ FREE $ -> 0 מלא.הגדר משתנה

$ newvar = 25 $ פסק זמן = 23245קבל את הערך של משתנה נתון

root@ATmega328p> הד $ newvar $ newvar 25אתה יכול לראות מה כל המשתנים שיצאת כרגע באמצעות פקודת ההדפסה שאתה כבר מכיר

משתנים שהוגדרו על ידי המשתמש: שם אינדקס -> ערך (01): newvar -> 25 (02): פסק זמן -> 23245 (03): $ FREE $ -> 0 (04): $ FREE $ -> 0 (05): $ FREE $ -> 0 (06): $ FREE $ -> 0 (07): $ FREE $ -> 0 (08): $ FREE $ -> 0 (09): $ FREE $ -> 0 (10): $ FREE $ -> 0 (11): $ FREE $ -> 0 (12): $ FREE $ -> 0 (13): $ FREE $ -> 0 (14): $ FREE $ -> 0 (15): $ FREE $ -> 0 (16): $ FREE $ -> 0 (17): $ FREE $ -> 0 (18): $ FREE $ -> 0 (19): $ FREE $ -> 0 (20): $ FREE $ -> 0 מלא.השם $ FREE $ רק מציין שמיקום המשתנה הזה הוא חינמי וטרם הוקצה לו שם משתנה.

שלב 5: התאמה אישית של המעטפת

אתה חופשי לפרוץ את הקוד ולהתאים אותו לצרכים שלך, אם תרצה. אם הייתי יודע שאני משחרר את הקוד הזה, הייתי יוצר מחלקה ומפרק פקודה נפרדים של פקודות ופשוט חוזר על ידי קריאה זו מצביע פונקציות. זה היה מקטין את כמות הקוד, אך כפי שהוא עומד המעטפת מנתחת את שורת הפקודה וקוראת לשיטת הפגז המתאימה. כדי להוסיף פקודות מותאמות אישית משלך, בצע את הפעולות הבאות: 1. הוסף את הפקודה שלך לרשימת הניתוח מנתח הפקודה לנתח את שורת הפקודה ולתת לך את הפקודה וכל הארגומנטים בנפרד. הטיעונים מועברים כמצביעים להצבעות, או כמערך של מצביעים, אולם אתה אוהב לעבוד איתם. זה נמצא ב- shell.cpp. פתח את shell.cpp ומצא את שיטת ExecCmd של מחלקת AVRShell. ייתכן שתרצה להוסיף את הפקודה לזיכרון התכנות. אם כן, הוסף את הפקודה ב- progmem.h ו- progmem.cpp. אתה יכול להוסיף את הפקודה לזיכרון התכנות ישירות באמצעות המאקרו PSTR (), אך תיצור אזהרה נוספת מהסוג שהוזכר קודם לכן. שוב, זהו באג ידוע שעובד עם C ++, אך תוכל לעקוף זאת על ידי הוספת הפקודה ישירות בקבצי התוכנה.* כפי שעשיתי. אם לא אכפת לך להוסיף לשימוש ב- SRAM שלך, תוכל להוסיף את הפקודה כפי שהדגמתי באמצעות הפקודה "שעון". נניח שרצית להוסיף פקודה חדשה בשם "newcmd". עבור אל AVRShell:: ExecCmd ומצא מקום נוח להכניס את הקוד הבא:

אחרת אם (! strcmp (c, "newcmd")) cmdNewCmd (args);זה יוסיף את הפקודה שלך ויתקשר לשיטת cmdNewCmd שתכתוב בשלב הבא. 2. כתוב את קוד הפקודה המותאם אישית שלך באותו קובץ, הוסף את קוד הפקודה המותאם אישית שלך. זוהי הגדרת השיטה. עדיין תרצה להוסיף את ההצהרה ל- shell.h. פשוט צרף אותו לפקודות האחרות. בדוגמה הקודמת, הקוד עשוי להיראות בערך כך

voidAVRShell:: cmdNewCmd (char ** args) {sprintf_P (buff, PSTR ("הפקודה שלך היא %s / r / n", args [0]); WriteRAM (buff);}יש כאן כמה דברים. ראשית, "buff" הוא מאגר מערך בן 40 תווים המסופק בקוד לשימושך. אנו משתמשים בגרסת זיכרון התוכנית של sprintf מכיוון שאנו מעבירים לה PSTR. אתה יכול להשתמש בגרסה הרגילה אם תרצה, אך הקפד שלא להעביר את הפורמט ב- PSTR. כמו כן, הטיעונים נמצאים במערך args. אם הקלדת "newcmd arg1 arg2" תוכל לקבל טיעונים אלה באמצעות כתובות החתימות args [0] ו- args [1]. תוכל להעביר מקסימום MAX_ARGS ארגומנטים, כהגדרתם בקוד. אל תהסס לשנות ערך זה בעת הידור מחדש אם אתה זקוק לעוד טיעונים רבים בבת אחת. ה- WriteLine ו- WriteRAM הן פונקציות גלובליות המחזירות את שיטות ה- UART בעלות אותו שם. הטיעון השני לפונקציה זו הוא מרומז. אם לא תעביר דבר, לאחר מכן תיכתב שורת פקודה. אם אתה מעביר 0 כארגומנט השני, לא תיכתב הודעה. הדבר שימושי כאשר ברצונך לכתוב מספר מחרוזות נפרדות לפלט לפני שורת הפקודה מוחזרת למשתמש. 3. בקש מהפגז לבצע את קוד הפקודה כבר אמרת למנהל המעטפת לבצע את השיטה cmdNewCmd בעת הגדרת הפקודה החדשה, אך הוסף אותה לקובץ shell.h כדי שתבין אותה על ידי אובייקט המעטפת. פשוט הוסף אותו מתחת לפקודה האחרונה או מול הפקודה הראשונה, או בכל מקום שם. וזהו. הידור מחדש והעלה את הקושחה ל- Arduino שלך והפקודה החדשה שלך זמינה מהקליפה בהנחיה.

שלב 6: סיכום

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