מדריך למשתמש של מחולל ממשק בדיקת UART VHDLwhiz UART

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

דרישות

מתורגמן Python 3
חבילה פיסיריאלית

פּרוֹטוֹקוֹל

המוצר משתמש בפרוטוקול מסגור נתונים עם ארבעה תווי בקרה:

שֵׁם: READ_REQ, עֵרֶך: 0x0A - פקודה מהמארח ל-FPGA כדי ליזום רצף כתיבה כדי לשלוח את כל האוגרים בחזרה דרך UART
שֵׁם: START_WRITE, עֵרֶך: 0x0B - מסמן את תחילתו של רצף כתיבה בכל כיוון

שֵׁם: END_WRITE, עֵרֶך: 0x0C - מסמן את סוף רצף הכתיבה בכל כיוון
שֵׁם: לִברוֹחַ, עֵרֶך: 0x0D - תו Escape המשמש ליציאה למילות בקרה

הוראות שימוש במוצר

הפעלת הסקריפטים

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

יצירת ממשקים מותאמים אישית

השתמש בסקריפט gen_uart_regs.py כדי ליצור ממשקים מותאמים אישית לקריאה ולכתיבה של ערכי אוגר FPGA. ניתן לציין את הרכב אוגרי הקלט והפלט והסוגים בעת יצירת הפלט files.

אינטראקציה עם רישום

אתה יכול לקרוא או לכתוב לכל מספר אוגרים בעיצוב ה-FPGA שלך באמצעות מודול VHDL וסקריפט Python שנוצר. לרשמים הנגישים יכולים להיות סוגים כגון std_logic, std_logic_vector, signed או unsigned.

רִשָׁיוֹן

רישיון MIT מכסה את דרישות זכויות היוצרים ותנאי השימוש של קוד המקור. עיין בקובץ LICENSE.txt file ב-Zip file לפרטים.

יומן שינויים

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

גִרְסָה	הערות
1.0.0	שחרור ראשוני
1.0.1	תוקן באג ההתייחסות "עצמי" חסר בעת ייבוא בתור uart_regs.py כמודול Python. השתנה תדפיס כתיבה נכשל לחריגה ל הימנע מהדפסה למסוף בעת הפעלה כמודול מיובא.
1.0.2	תקן עבור שגיאת Vivado [Synth 8-248] כאשר אין תקנות של מצב יציאה.
1.0.3	תקן את אזהרת Vivado Linter: Register יש הפעלה מונעת על ידי איפוס סינכרוני
1.0.4	תקן את האותיות בפינה בעת קבלת מילה בעלת מבנה שגוי עם תו ה-escape בתור הבית האחרון. גם המילה הבאה תאבד מכיוון שלא ניקינו את recv_data_prev_is_escape כשחזרנו ל-IDLE. הסקריפט gen_uart_regs.py מאפשר כעת רק שמות reg ייחודיים.

תֵאוּר

מסמך זה מתאר את הדברים הבאים files ותיקיות:
gen_uart_regs.py

genered/uart_regs.vhd
generated/uart_regs.py
genered/instantiation_template.vho
rtl/uart_regs_backend.vhd
rtl/uart_rx.vhd
rtl/uart_tx.vhd
demo/lattice_icestick/
demo/xilinx_arty_a7_35/
demo/xilinx_arty_s7_50/
הסקריפט gen_uart_regs.py ו-VHDL התומך files בפרויקט זה מאפשרים לך ליצור ממשקים מותאמים אישית לקריאה ולכתיבה של ערכי אוגר FPGA מסוגים ורוחב שונים באמצעות UART.
אתה יכול להשתמש במודול VHDL שנוצר ובסקריפט של Python כדי לקרוא או לכתוב לכל מספר אוגרים בעיצוב שלך. האוגרים הנגישים של UART יכולים להיות עם הסוגים std_logic, std_logic_vector, חתום או לא חתום.
אתה יכול להחליט על ההרכב המדויק של אוגרי קלט ופלט וסוגים בעת יצירת הפלט files באמצעות הסקריפט gen_uart_regs.py.
הסקריפטים של Python נוצרו בחלקם בעזרת כלי הבינה המלאכותית ChatGPT, בעוד שקוד VHDL מיוצר בעבודת יד.

דרישות

יש להפעיל את הסקריפטים בפרויקט זה דרך מתורגמן Python 3 ויש להתקין את החבילה Pyserial.
אתה יכול להתקין pyserial דרך Pip באמצעות הפקודה הזו: pip install pyserial

פּרוֹטוֹקוֹל

ה-VHDL files וסקריפט Python משתמשים בפרוטוקול מסגור נתונים עם ארבע בקרה

שֵׁם	עֵרֶך	הֶעָרָה
READ_REQ	0x0A	פקודה מהמארח ל-FPGA כדי ליזום כתיבה רצף כדי לשלוח את כל האוגרים בחזרה דרך UART
START_כתוב	0x0B	מסמן את תחילתו של רצף כתיבה בכל אחד מהם כיוון
END_WRITE	0x0C	מסמן את סוף רצף הכתיבה בכל כיוון
לִברוֹחַ	0x0D	תו בריחה המשמש ליציאה מכל אחת ממילות הבקרה, כולל התו ESCAPE עצמו, כשהן מופיעות כנתונים בין הסמנים START_WRITE ו-END_WRITE.

כל בתים READ_REQ לא נמלטים שנשלחים ל-FPGA הוא הוראה לשלוח את כל האוגרים (כניסות ויציאות) הנגישים ל-UART שלו בחזרה אל המארח דרך UART. פקודה זו ניתנת בדרך כלל רק על ידי הסקריפט uart_regs.py.
עם קבלת פקודה זו, ה-FPGA יגיב על ידי שליחת התוכן של כל הרשמים בחזרה למארח. ראשית, אותות הקלט, ולאחר מכן אותות המוצא. אם האורכים שלהם אינם מסתכמים לכפולה של 8 סיביות, הסיביות התחתונות של הביט האחרון יהיו מרופדות באפסים.
רצף כתיבה מתחיל תמיד בבייט START_WRITE ומסתיים בבייט END_WRITE. כל בתים בין אלה נחשבים לבייטים של נתונים. אם לביטים כלשהם יש ערך זהה לתווית בקרה, יש לבצע אסקייפ של בייט הנתונים. משמעות הדבר היא שליחת תו ESCAPE נוסף לפני בייט הנתונים כדי לציין שזה למעשה נתונים.
אם START_WRITE לא נמלט מגיע למקום כלשהו בזרם הבתים, הוא נחשב להתחלה של רצף כתיבה. המודול uart_regs_backend משתמש במידע זה כדי לסנכרן מחדש במקרה שהתקשורת יוצאת מסונכרנת.

gen_uart_regs.py

זהו הסקריפט שעליך להתחיל איתו כדי ליצור את הממשק. להלן צילום מסך של תפריט העזרה שתוכל לקבל על ידי הפעלת: python gen_uart_regs.py -h
כדי ליצור ממשק מותאם אישית, עליך להפעיל את הסקריפט כאשר כל אחד מהאוגרים הרצויים לשליטה ב-UART מופיע כארגומנטים. הסוגים הזמינים הם std_logic, std_logic_vector, unsigned ו-signed.
מצב ברירת המחדל (כיוון) נמצא וסוג ברירת המחדל הוא std_logic_vector אלא אם הרגיסטר הוא באורך: 1. לאחר מכן, הוא יקבע כברירת מחדל ל-std_logic.

לפיכך, אם אתה רוצה ליצור אות קלט std_logic, אתה יכול להשתמש בכל אחד מהארגומנטים הבאים:
my_sl=1
my_sl=1:in

my_sl=1:in:std_logic
כל הגרסאות שלעיל יגרמו לכך שהתסריט יפיק את האות הנגיש ל-UART:
בואו נריץ את הסקריפט עם ארגומנטים כדי ליצור ממשק עם מספר אוגרים של כיוונים, אורכים וסוגים שונים

נוצר files

הפעלה מוצלחת של הסקריפט gen_uart_regs.py תייצר תיקיית פלט בשם שנוצרה עם השלושה files המפורטים להלן. אם הם כבר קיימים, הם יוחלפו.
genered/uart_regs.vhd

generated/uart_regs.py
genered/instantiation_template.vho
uart_regs.vhd

זהו מודול הממשק המותאם אישית שנוצר על ידי הסקריפט. אתה צריך להפעיל אותו בעיצוב שלך, שם הוא יכול לגשת לרישומים שבהם אתה רוצה לשלוט באמצעות UART.
כל מה שמעל לקטע "- UART נגיש אוגרים" יהיה זהה עבור כל מודול uart_regs, בעוד הרכב אותות יציאה מתחת לקו זה תלוי בטיעונים שניתנו לסקריפט המחולל.
הרשימה למטה מציגה את הישות עבור מודול uart_regs הנובעת מפקודת gener exampהמוצג ב-gen_uart_regs.py secti

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

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

תפריט עזרה

הקלד python uart_regs.py -h כדי להדפיס את תפריט העזרה:

הגדרת יציאת UART

לסקריפט יש אפשרויות להגדיר את יציאת UART באמצעות מתג -c. זה עובד על Windows ו-Linux. הגדר אותו לאחת מהיציאות הזמינות המפורטות בתפריט העזרה. כדי להגדיר יציאת ברירת מחדל, אתה יכול גם לערוך את המשתנה UART_PORT בסקריפט uart_regs.py.

רישומי רישום

מידע על מיפוי הרישום ממוקם בכותרת של הסקריפט uart_regs.py על ידי הסקריפט gen_uart_regs.py. אתה יכול לרשום את האוגרים הזמינים עם המתג -l, כפי שניתן לראות להלן. זוהי פקודה מקומית ולא תקיים אינטראקציה עם FPGA היעד

כתיבה לפנקסים

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

קריאת רישומים

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

איתור באגים

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

שימוש בממשק בסקריפטים אחרים של Python

הסקריפט uart_regs.py מכיל מחלקה UartRegs שתוכל להשתמש בה בקלות כממשק התקשורת בסקריפטים מותאמים אישית אחרים של Python. כל שעליך לעשות הוא לייבא את המחלקה, ליצור אובייקט שלה ולהתחיל להשתמש בשיטות, כפי שמוצג להלן.

עיין במחרוזות ה-docstrings בקוד Python עבור שיטה ותיאורים וסוגי ערכי החזרה.

instantiation_template.vho

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

RTL סטטי files

אתה צריך לכלול את הדברים הבאים files בפרויקט VHDL שלך כך שהם יורכבו לאותה ספרייה כמו המודול uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
המודול uart_regs_backend מיישם את מכונות המצב הסופי שמכניסות ומוציאות את נתוני האוגר. הוא משתמש במודולים uart_rx ו-uart_tx כדי לטפל בתקשורת UART עם המארח.

פרויקטי הדגמה

ישנם שלושה פרויקטי הדגמה הכלולים ב-Zip file. הם מאפשרים לך לשלוט בציוד ההיקפי על הלוחות השונים, כמו גם בכמה אוגרים פנימיים גדולים יותר.
תיקיות ההדגמה כוללות uart_regs.vhd ו-uart_regs.py שנוצרו מראש fileנוצר במיוחד עבור אותם עיצובים.

סריג iCEstick

התיקיה demo/icecube2_icestick מכילה מימוש הדגמה של גישה לרשום עבור לוח ה-ICEstick FPGA של Lattice.
כדי לעבור את תהליך ההטמעה, פתח את ה-demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file בתוכנת העיצוב Lattice iCEcube2.
לאחר טעינת הפרויקט ב-iCEcube2 GUI, לחץ על כלים → הפעל הכל כדי ליצור את מפת הסיביות של התכנות file.

אתה יכול להשתמש בכלי העצמאי של מתכנת יהלומי Lattice כדי להגדיר את ה-FPGA עם מפת הסיביות שנוצרה file. כאשר יהלום מתכנת נפתח, לחץ על פתח פרויקט מתכנת קיים בתיבת הדו-שיח ברוכים הבאים.
פרויקט בחר file נמצא ב-Zip: demo/lattice_icestick/diamond_programmer_project.xcf ולחץ על אישור.
לאחר טעינת הפרויקט, לחץ על שלוש הנקודות ב- File עמודת שם, כפי שמוצג לעיל. עיין כדי לבחור את מפת הסיביות file שיצרת ב-iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
לבסוף, כאשר לוח ה-iCEstick מחובר ליציאת USB במחשב שלך, בחר עיצוב → תוכנית כדי לתכנת את הבזק SPI ולהגדיר את ה-FPGA.
כעת תוכל להמשיך לקרוא ולכתוב אוגרים על ידי שימוש בסקריפט demo/lattice_icestick/uart_regs.py כמתואר בסעיף uart_regs.py.

Xilinx Digilent Arty A7-35T

אתה יכול למצוא את יישום ההדגמה עבור ערכת ההערכה Artix-7 35T Arty FPGA בתיקיית demo/arty_a7_35.
פתח את Vivado ונווט אל הקובץ שחולץ files באמצעות קונסולת Tcl שנמצאת בתחתית ממשק ה-GUI. הקלד פקודה זו כדי להיכנס לתיקיית פרויקט ההדגמה:

CD /demo/arty_a7_35/vivado_proj/
בצע את הסקריפט create_vivado_proj.tcl Tcl כדי ליצור מחדש את פרויקט Vivado:
מקור ./create_vivado_proj.tcl

לחץ על Generate Bitstream בסרגל הצד כדי לעבור את כל שלבי ההטמעה וליצור את זרם הסיביות של התכנות file.
לבסוף, לחץ על פתח את מנהל החומרה ותכנת את ה-FPGA דרך ה-GUI.
כעת תוכל להמשיך לקרוא ולכתוב רישומים על ידי שימוש בסקריפט demo/arty_a7_35/uart_regs.py כמתואר בסעיף uart_regs.py.

Xilinx Digilent Arty S7-50

אתה יכול למצוא את יישום ההדגמה עבור לוח הפיתוח של Arty S7: Spartan-7 FPGA בתיקיית demo/arty_s7_50.
פתח את Vivado ונווט אל הקובץ שחולץ files באמצעות קונסולת Tcl שנמצאת בתחתית ממשק ה-GUI. הקלד פקודה זו כדי להיכנס לתיקיית פרויקט ההדגמה:

CD /demo/arty_s7_50/vivado_proj/
בצע את הסקריפט create_vivado_proj.tcl Tcl כדי ליצור מחדש את פרויקט Vivado:
מקור ./create_vivado_proj.tcl

לחץ על Generate Bitstream בסרגל הצד כדי לעבור את כל שלבי ההטמעה וליצור את זרם הסיביות של התכנות file.
לבסוף, לחץ על פתח את מנהל החומרה ותכנת את ה-FPGA דרך ה-GUI.
כעת תוכל להמשיך לקרוא ולכתוב רישומים על ידי שימוש בסקריפט demo/arty_s7_50/uart_regs.py כמתואר בסעיף uart_regs.py.

יישום

אין דרישות יישום ספציפיות.

אילוצים

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

הקלט uart_rx למודול uart_regs מסונכרן בתוך מודול uart_rx. לפיכך, אין צורך לסנכרן אותו במודול ברמה העליונה.

בעיות ידועות

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

מידע נוסף

זְכוּת יְוֹצרִים VHDLwhiz.com

שאלות נפוצות

ש: מה המטרה של מחולל ממשק בדיקת UART?

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

ש: כיצד אוכל להתקין את חבילת Pyserial?

ת: אתה יכול להתקין את Pyserial דרך Pip באמצעות הפקודה: pip install pyserial

מסמכים / משאבים

מחולל ממשק בדיקת VHDLwhiz UART [pdfמדריך למשתמש
מחולל ממשק בדיקה UART, מחולל ממשק בדיקה, מחולל ממשק, מחולל

הפניות

מדריך למשתמש

מחולל ממשק בדיקת VHDLwhiz UART

מידע על המוצר