איך להכין את ארני: 11 שלבים

2025 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2025-01-23 14:46

זהו הדרכה כיצד לבנות את ארני, הצליל האוטונומי שלך בעקבות הרובוט, באמצעות לוח זיבו. הוא יסקור כיצד: ליצור פרויקט ב- Vivado, ליצור מנהלי מנוע סרוו דמויי PWM ב- FPGA, ממשק עם שני חיישני קול, ליצור הפרש זמן של IP הגעה, להשתמש ב- freeRTOS ולהפעיל את ה- zybo מארז סוללות. זה היה פרויקט הגמר שלנו עבור שיעור מערכות הפעלה בזמן אמת (CPE 439) ב- Cal Poly SLO.

רשימת ציוד:

• 1 - מועצת הפיתוח של ZYBO Zynq 7000
• 2 - סרוו סיבוב רציף של Parallax
• 2 - חיישן קול (גלאי קול SparkFun)
• 1 - סוללת ליתיום יון USB של 5V (ללוח)
• 4 - סוללות AA (עבור סרוווס)
• 1 - מארז סוללות AA (עם 4 חריצי סוללה)
• 1 - כבל מיקרו USB
• 1 - לוח לחם
• רבים - חוטי זכר לזכר
• 1 - מארז סרוו

דרישות תוכנה:

• סוויטת עיצוב Xilinx Vivado 2016.2
• Digilent Adept 2.16.1

שלב 1: הקמת פרויקט ב- Vivado עבור ארני

1. אשף יופיע
2. הקש "הבא

3. שם הבא לפרויקט

   1. לעולם אל תשתמש בשם הפרויקט או בנתיב ספרייה שיש בו רווחים !!!!!
   2. זה יהיה פרויקט RTL.
4. איננו רוצים לפרט מקורות

5. לחיצה על הבא, נגיע לדף החלק. אנו משתמשים ב- ZYNQ XC7Z010-1CLG400C.

   1. ל- Vivado אין את ה- Zybo רשום כאחד הלוחות שהוגדרו מראש. בחר: "חלקים" ואז חפש xc7z010clg400-1.
   2. אם תבחר את החלק הלא נכון בטעות תוכל להחליף שבבים בקלות: כלים -> הגדרות פרויקט -> כללי ולחץ על הנקודות מימין ל"התקן הפרויקט"

6. לחץ על צור עיצוב בלוק.

   תן לזה עיצוב_1 לעת עתה

7. תראה סרגל ירוק שאומר הוסף IP, לחץ עליו.

8. חפש את Zynq.

   1. לחץ פעמיים על מערכת עיבוד ZYNQ7,
   2. בלוק זה יופיע בעיצוב הבלוק שלנו.
9. תראה סרגל ירוק שאומר Run Block Automation, לחץ עליו.
10. הורד להלן zybo_zynq_def.xml.

11. ב- Vivado, לחץ על "ייבא הגדרות XPS" ובחר "zybo_zynq_def.xml"

    זה מאכלס מראש את תצורת בלוק Vivado עם כל הציוד ההיקפי המובנה של לוח Zybo והקצאות סיכות

12. לחץ פעמיים על בלוק ZYNQ.

    1. תצורת MIO

       1. אפשר טיימר 0 (תחת יחידת מעבד היישומים - תמונה 1)
       2. אפשר כלב שמירה (תחת יחידת מעבד יישומים- תמונה 1)
       3. אפשר GPIO-> GPIO MIO (תחת יחידת מעבד יישומים - תמונה 2)
       4. הפעל איפוס GPIO-> ENET (תחת ציוד היקפי לקלט/פלט- img 2)

    2. תצורת שעון

       השבת FCLK0 (תחת שעוני בד PL - img 3)

13. לחץ על אישור.

14. "הפעל אוטומציה של בלוק" כעת.

    יהיו כמה שאלות בנוגע לאותות, אמור אישור

15. לחץ על "צור עטיפת HDL".

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

16. לחץ על אישור.

שלב 2: יצירת ה- PWM של ארני ב- Vivado

שלב זה ייצר IP PWM עם תשומות שנשלחות דרך ספריית AXI.

1. צור בלוק AXI GPIO על ידי לחיצה ימנית על הרקע ולחיצה על "הוסף IP"

   הקלד "AXI_GPIO" בשורת החיפוש ובחר חבילה זו

2. התאם מחדש את ה- IP על ידי לחיצה כפולה על הבלוק axi_gpio_0 החדש

   1. תחת GPIO, הגדר את רוחב GPIO ל- 2. סיביות אלה יהיו האות PWM_ON להנעת כל מופע מודול PWM.
   2. לחץ על "הפעל ערוץ כפול"
   3. תחת GPIO 2, הגדר את רוחב GPIO ל- 2. סיביות אלה יהיו האות PWM_FW לקביעת הכיוון של כל מופע מודול PWM.

3. לחץ באמצעות לחצן העכבר הימני על יציאת הפלט axi_gpio_0 שכותרתה GPIO ובחר "צור חיצוני"

   1. לחץ על הפלט החדש שכותרתו GPIO, ועבור לכרטיסייה "מאפיינים" בסרגל הכלים השמאלי, ושנה את השם ל- PWM_ON
   2. לחץ על הפלט החדש שכותרתו GPIO2, ועבר לכרטיסייה "מאפיינים" בסרגל הכלים השמאלי, ושנה את השם ל- PWM_FW

4. בחר הפעל אוטומציה של חיבור בבאנר הירוק שמעל תרשים החסימה.

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

5. בחלונית ניווט Flow, בחר מנהל פרויקטים -> הוסף מקורות ליצירת בלוק IP מותאם אישית חדש

   1. בחר "הוסף או צור מקורות עיצוב" ולחץ על הבא
   2. לחץ על "צור קובץ", שנה את סוג הקובץ ל- "SystemVerilog" והקלד "pwm" בשדה שם הקובץ ולאחר מכן לחץ על אישור
   3. לחץ על סיום

   4. התעלם מחלון הגדרת המודול על ידי לחיצה על אישור (אנו נחליף אותם מאוחר יותר)

      אם הוא שואל אם אתה בטוח, לחץ על כן

6. בכרטיסיה מקורות, לחץ פעמיים על pwm.sv (הממוקם ב"מקורות עיצוב/design_1_wrapper ")

   העתק/הדבק את כל קוד SystemVerilog מהקובץ pwm.txt המצורף למטה

שלב 3: יצירת ה- TDOA של Ernie ב- Vivado

שלב זה ייצר IP TDOA שניתן לקרוא את הפלט שלו באמצעות ספריית AXI

1. צור בלוק AXI GPIO על ידי לחיצה ימנית על הרקע ולחיצה על "הוסף IP"

   הקלד "AXI_GPIO" בשורת החיפוש ובחר חבילה זו

2. התאם מחדש את ה- IP על ידי לחיצה כפולה על הבלוק axi_gpio_1 החדש

   1. תחת GPIO, סמן את התיבה "כל הכניסות" והגדר את רוחב GPIO ל- 32. אוטובוס זה יהיה הפרש זמן ההגעה בין שני החיישנים.
   2. בתוך הבלוק axi_gpio_1, לחץ על ה + לצד יציאת GPIO כדי לחשוף gpio_io_i [31: 0].

3. לחץ לחיצה ימנית על יציאת הפלט axi_gpio_1 שכותרתה gpio_io_i [31: 0] ובחר "צור חיצוני"

   לחץ על הקלט החדש שכותרתו gpio_io_i [31: 0], ועבור לכרטיסייה "מאפיינים" בסרגל הכלים השמאלי, ושנה את השם ל- TDOA_val

4. בחר הפעל אוטומציה של חיבור בבאנר הירוק שמעל תרשים החסימה.

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

5. בחלונית ניווט Flow, בחר מנהל פרויקטים -> הוסף מקורות ליצירת בלוק IP מותאם אישית חדש

   1. בחר "הוסף או צור מקורות עיצוב" ולחץ על הבא
   2. לחץ על "צור קובץ", שנה את סוג הקובץ ל- "SystemVerilog" והקלד "tdoa" בשדה שם הקובץ ולאחר מכן לחץ על אישור
   3. לחץ על סיום

   4. התעלם מחלון הגדרת המודול על ידי לחיצה על אישור (אנו נחליף אותם מאוחר יותר)

      אם הוא שואל אם אתה בטוח, לחץ על כן

6. בכרטיסיה מקורות, לחץ פעמיים על tdoa.sv (נמצא ב "מקורות עיצוב/design_1_wrapper")

   העתק/הדבק את כל קוד SystemVerilog מהקובץ tdoa.txt המצורף למטה

שלב 4: עטיפה ויצוא של ארני

1. ודא שתרשים החסימה נראה כמו צילום המסך המצורף

2. בכרטיסיה מקורות, לחץ באמצעות לחצן העכבר הימני על design_1.bd ובחר "צור עטיפת HDL …"

   1. בחר "העתק פלט שנוצר כדי לאפשר עריכות משתמשים" ולאחר מכן לחץ על "אישור"
   2. העתק את הקוד מתוך design_1_wrapper.txt המצורף למטה והדבק אותו במקום קוד design_1_wrapper.v שנוצר
   3. שמור design_1_wrapper.v

3. בכרטיסיה מקורות, לחץ פעמיים על הקובץ ZYBO_Master.xdc תחת אילוצים/הגבלות 1

   1. העתק את הקוד מתוך ZYBO_Master.txt המצורף למטה והדבק אותו במקום הקוד ZYBO_Master.xdc הקיים

   2. שימו לב לסיכות הקלט/פלט הבאות:

      1. L15: אות PWM עבור המנוע השמאלי (Pmod JA2 ב- Zybo)
      2. L14: אות PWM עבור המנוע הימני (Pmod JA8 ב- Zybo)
      3. V12: כניסת שער מחיישן קול 1 (Pmod JE1 ב- Zybo)
      4. K16: כניסת שער מחיישן הקול 2 (Pmod JE2 ב- Zybo)

4. בחלונית ניווט Flow, לחץ על "צור Bitstream" תחת תוכנית וניפוי באגים

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

5. לחץ על קובץ-> ייצוא-> צור חומרה

   סמן את "כלול Bitstream" ולחץ על אישור

6. לחץ על קובץ-> הפעל SDK

שלב 5: בניית ארני

1. הרכבו את הסרוויים לשלדת הסרוו.

2. עקוב אחר גליון הנתונים של סרוווס, בצע את הפעולות הבאות:

   1. חבר את קרקע הסרוווס לסיכות הארקה ב- JA Pmod של ה- Zybo (ראה תמונת pinout המצורפת)
   2. חבר את פין ההפעלה של סרוווס לסוללת AA

      גילינו שכאשר הסרוו מחוברים ל- Vdd של ה- Zybo, הלוח שואב יותר מדי זרם וגורם ללוח להתאפס ללא הרף

   3. חבר את סיכות אות הכניסה לסיכות הפלט המתאימות של ה- Zybo (משמאל: JA2, מימין: JA8)
3. הרכיבו את חיישני הקול בחזית המארז, כשהם פונים קדימה, שמרו אותם קרוב ככל האפשר

4. השתמש במדריך החיבור של חיישן הקול כדי לשלב את חיישני הקול

   1. חברו את סיכות הקרקע וה- Vdd של כל חיישן קול לקרקע וסיכות Vdd על ה- JE Pmod של ה- Zybo (ראו תמונת pinout המצורפת)
   2. חבר את סיכת השער של חיישן הקול השמאלי ל- JE1
   3. לחבר את סיכת השער הנכונה של חיישן הקול ל- JE2

שלב 6: ה- BSP הראשון של ארני

1. צור BSP כדי לסכם את הפלטפורמה שיצרנו זה עתה.

   אתה יכול להשיג זאת באמצעות קובץ -> חדש -> חבילת תמיכה בלוח

2. אשף יצוץ שיעזור לך ליצור את ה- BSP.

   1. אנחנו רוצים לקשור את ה- BSP הזה עם הפלטפורמה שלנו שיצרנו זה עתה
   2. פלטפורמת החומרה צריכה להתיישר עם זו שיצרנו זה עתה (ראה תמונה 1)
   3. המעבד שלנו יהיה המעבד _0.
   4. לחץ על סיום
   5. הקפד לסמן את lwip141 להכללה עם ה- bsp שלך בחלון שיופיע (ראה תמונה 2)

שלב 7: FreeRTOS'ing Ernie

1. הורד את המהדורה האחרונה של FreeRTOS מ- Sourceforge.

   אם ההורדה ניתנת להפעלה, הפעל אותה כדי לחלץ את קבצי FreeRTOS לספריית הפרויקטים שלך

2. שמור את ה- SDK פתוח ולחץ על קובץ -> ייבוא.
3. אנו רוצים ללחוץ על כללי-> מסביבת עבודה קיימת, ולאחר מכן נרצה לנווט לאן שהורדנו את FreeRTOS.

4. ההדגמה שלנו תמוקם ב- FreeRTOS/Demo/CORTEX_A9_Zynq_ZC702. בבחירת התיקיה הזו, אנו אמורים לראות שלושה פרויקטים צצים (הקוד שלנו (OS), זה BSP ופלטפורמת HW).

   ייבא רק RTOSDemo לסביבת העבודה הנוכחית שלך

5. בכל פרויקטי התיקיות "הכחולים" משנים את ה- BSP שהוזכר

   1. לחץ באמצעות לחצן העכבר הימני ובחר "שנה BSP שהוזכר".
   2. בחר את ה- BSP שיצרת זה עתה עבור ה- Zybo שלך
   3. עריכת קוד בתיקיות ה- SDK Blue של Xilinx הן פרויקטי הקוד בפועל.

שלב 8: ייבוא קוד C של ארני

1. בספריית RTOSDemo/src, החלף את main.c הקיים עם קובץ main.c המצורף כאן.
2. העתק את הגירסה main_sound.c לספריית RTOSDemo/src.

שלב 9: איתור באגים לארי

1. בחר הפעלה -> תצורות באגים
2. בחלונית השמאלית צור הפעלה חדשה של Debugger System

3. בכרטיסייה הגדרת יעד,

   בחר "אפס את כל המערכת" כך שגם זה וגם ps7_init ייבחרו

4. כעת בחר בכרטיסייה יישום.

   1. בחר "הורד יישום"
   2. הגדר את ליבת cortexa9_0 ל"עצור בכניסת התוכנית"
   3. לחץ על Apply and Debug.
5. ודא כי אין שגיאות בתהליך איתור באגים
6. תוך שמירה מקרוב על הרובוט, לחץ על לחצן המשך עד שהתוכנית פועלת מבלי לפגוע בנקודות שבירה
7. כעת הרובוט צריך להסתובב ולהתקדם לכיוון רעשים חזקים. יש!

שלב 10: הפיכת ארני לאוטונומית

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

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

   1. בחר: קובץ-> חדש-> פרויקט יישומים והחלון הבא אמור להופיע.
   2. תן לזה מה שאתה רוצה (כלומר "FSBL")
   3. וודא שפלטפורמת החומרה היא זו שאתה עובד איתה
   4. הקש על הבא (אל תלחץ על סיום)
   5. בחר את תבנית Zynq FSBL
   6. לחץ על סיום.
3. לאחר השלמת תהליך היצירה תדע אם הכל עבד אם תראה את שתי התיקיות החדשות הבאות בחלון סייר הפרויקט.

4. צור תמונת אתחול כעת יהיה עליך ליצור את תמונת האתחול.

   1. קליק ימני על תיקיית הפרויקט שלך (במקרה זה שלי נקרא "RTOSDemo")
   2. לחץ על "צור תמונת אתחול" מהתפריט הנפתח

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

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

   4. לחץ על כפתור "צור תמונה"

5. השלב האחרון לביצוע בתוכנה הוא להבהב כעת את התמונה שנוצרה בעבר לזיכרון הלוח

   1. בחר מסרגל הכלים הראשי של SDK בחר בכלי Xilinx-> תכנת זיכרון פלאש
   2. וודא שנבחרה פלטפורמת החומרה הנכונה וכי נתיב קובץ התמונה מצביע כראוי לקובץ. BIN שנוצר בשלב הקודם.
   3. בחר "qspi single" מסוג Flash
   4. סמן את האפשרות "אמת לאחר הבזק" כדי להבטיח את התקינות אך אין בכך צורך
6. הגדר את הלוח שלך לבסוף עליך לוודא שמגשר מצב התכנות של לוחות (JP5) מוגדר כראוי לבחור לאתחול מה- qspi (המכיל את מה שהבזקת זה עתה) כאשר BootROM מופעל.
7. כעת פשוט הפעל את המכשיר והפעל כי "נורית ה- Logic Configuration Done" (נורית 10) מוארת בירוק.

שלב 11: להפוך את ארני לחמוד

1. פרווה
2. הרבה פרווה
3. עיניים גדולות!
4. … כובע עליון