VHDLwhiz UART טעסט צובינד גענעראַטאָר באַניצער מאַנואַל

דער פּראָדוקט אַלאַוז איר צו דזשענערייט מנהג ינטערפייסיז פֿאַר לייענען און שרייבן FPGA רעגיסטרירן וואַלועס ניצן UART. די דזשענערייטאַד VHDL מאָדולע און פּיטהאָן שריפט צושטעלן די פיייקייט צו ינטעראַקט מיט פאַרשידן טייפּס פון רעדזשיסטערז אין דיין FPGA פּלאַן.

רעקווירעמענץ

פּיטהאָן 3 יבערזעצער
פּיסעריאַל פּעקל

פּראָטאָקאָל

דער פּראָדוקט ניצט אַ דאַטן פראַמינג פּראָטאָקאָל מיט פיר קאָנטראָל אותיות:

נאָמען: READ_REQ, ווערט: 0x0A - באַפֿעל פון דער באַלעבאָס צו די FPGA צו אָנהייבן אַ שרייַבן סיקוואַנס צו שיקן אַלע רעדזשיסטערז צוריק איבער UART
נאָמען: START_WRITE, ווערט: 0x0B - מאַרקס די אָנהייב פון אַ שרייַבן סיקוואַנס אין יעדער ריכטונג

נאָמען: END_WRITE, ווערט: 0x0C - מאַרקס די סוף פון אַ שרייַבן סיקוואַנס אין יעדער ריכטונג
נאָמען: אנטלאפן, ווערט: 0x0D - אַנטלויפן כאַראַקטער געניצט פֿאַר יסקייפּינג קאָנטראָל ווערטער

פּראָדוקט באַניץ אינסטרוקציעס

לויפן די סקריפּס

צו נוצן דעם פּראָדוקט, מאַכן זיכער אַז Python 3 איז אינסטאַלירן און די Pyserial פּעקל. לויפן די סקריפּס דורך אַ פּיטהאָן 3 יבערזעצער.

דזשענערייטינג מנהג ינטערפייסיז

ניצן די gen_uart_regs.py שריפט צו דזשענערייט מנהג ינטערפייסיז פֿאַר לייענען און שרייבן FPGA רעגיסטרירן וואַלועס. איר קענען ספּעציפיצירן דעם זאַץ פון אַרייַנשרייַב און רעזולטאַט רעדזשיסטערז און טייפּס ווען דזשענערייטינג די רעזולטאַט files.

ינטעראַקטינג מיט רעדזשיסטערז

איר קענען לייענען פון אָדער שרייַבן צו קיין נומער פון רעדזשיסטערז אין דיין FPGA פּלאַן מיט די דזשענערייטאַד VHDL מאָדולע און פּיטהאָן שריפט. די צוטריטלעך רעדזשיסטערס קענען האָבן טייפּס אַזאַ ווי std_logic, std_logic_vector, געחתמעט אָדער ונסיגנעד.

ליסענסע

די MIT דערלויבעניש קאָווערס די קאַפּירייט רעקווירעמענץ און טערמינען פון נוצן פון די מקור קאָד. אָפּשיקן צו די LICENSE.txt file אין די זיפּ file פֿאַר פרטים.

טשאַנגעלאָג

די ענדערונגען אָפּשיקן צו די פּרויעקט files, און דעם דאָקומענט איז דערהייַנטיקט אַקאָרדינגלי

ווערסיע	באמערקונגען
1.0.0	ערשט מעלדונג
1.0.1	פאַרפעסטיקט פעלנדיק "זיך" רעפֿערענץ זשוק ווען ימפּאָרטינג ווי uart_regs.py ווי אַ פּיטהאָן מאָדולע. פארענדערט שרייבן דורכפאַל פּרינטאַוט צו ויסנעם צו ויסמיידן דרוקן צו די קאַנסאָול ווען פליסנדיק ווי אַ ימפּאָרטיד מאָדולע.
1.0.2	פאַרריכטן פֿאַר Vivado [Synth 8-248] טעות ווען עס זענען קיין אַוט מאָדע רעגס.
1.0.3	פאַרריכטן Vivado Linter ווארענונג: רעדזשיסטער האט געבן געטריבן דורך סינטשראָנאָוס באַשטעטיק
1.0.4	פאַרריכטן די ווינקל פאַל ווען איר באַקומען אַ מאַלפאָרמעד וואָרט מיט די אַנטלויפן כאַראַקטער ווי די לעצטע בייט. דער ווייַטער וואָרט וואָלט אויך זיין פאַרפאַלן ווייַל מיר האָבן נישט ויסמעקן recv_data_prev_is_escape ווען מיר צוריקקומען צו IDLE. די gen_uart_regs.py שריפט איצט אַלאַוז בלויז יינציק רעג נעמען.

באַשרייַבונג

דעם דאָקומענט באשרייבט די פאלגענדע files און פאָלדערס:
gen_uart_regs.py

דזשענערייטאַד/uart_regs.vhd
דזשענערייטאַד/uart_regs.py
generated/instantiation_template.vho
rtl/uart_regs_backend.vhd
rtl/uart_rx.vhd
rtl/uart_tx.vhd
דעמאָ/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, געחתמעט אָדער אַנסיינד.
איר קענען באַשליסן די גענוי זאַץ פון אַרייַנשרייַב און רעזולטאַט רעדזשיסטערז און טייפּס ווען דזשענערייטינג די רעזולטאַט fileניצן די gen_uart_regs.py שריפט.
די פּיטהאָן סקריפּס זענען באשאפן טייל מיט די הילף פון די ChatGPT קינסטלעך סייכל געצייַג, בשעת די VHDL קאָד איז כאַנדקראַפטיד.

רעקווירעמענץ

די סקריפּס אין דעם פּרויעקט מוזן זיין לויפן דורך אַ פּיטהאָן 3 יבערזעצער און די פּיסעריאַל פּעקל מוזן זיין אינסטאַלירן.
איר קענען ינסטאַלירן פּיסעריאַל דורך פּיפּ ניצן דעם באַפֿעל: פּיפּ ינסטאַלירן פּיסעריאַל

פּראָטאָקאָל

די VHDL files און Python שריפט נוצן אַ דאַטן-פראַמינג פּראָטאָקאָל מיט פיר קאָנטראָל

נאָמען	ווערט	באַמערקונג
READ_REQ	0x0A	באַפֿעלן פֿון דער באַלעבאָס צו די FPGA צו אָנהייבן אַ שרייַבן סיקוואַנס צו שיקן אַלע רעדזשיסטערז צוריק איבער UART
START_WRITE	0 קס 0 ב	מאַרקס די אָנהייב פון אַ שרייַבן סיקוואַנס אין יעדער ריכטונג
END_WRITE	0 קס 0 ק	מאַרקס די סוף פון אַ שרייַבן סיקוואַנס אין יעדער ריכטונג
אַנטלויפן	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, ונסיגנעד און געחתמעט.
די פעליקייַט מאָדע (ריכטונג) איז אין און די פעליקייַט טיפּ איז std_logic_vector סייַדן די רעגיסטרירן איז פון לענג: 1. דערנאָך, עס וועט פעליקייַט צו std_logic.

אזוי, אויב איר ווילן צו שאַפֿן אַ סטד_לאָגיק אַרייַנשרייַב סיגנאַל, איר קענען נוצן קיין פון די אַרגומענטן:
מיין_סל=1
מיין_סל=1:אין

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

דזשענערייטאַד files

א געראָטן לויפן פון די gen_uart_regs.py שריפט וועט פּראָדוצירן אַ רעזולטאַט טעקע געהייסן דזשענערייטאַד מיט די דריי fileס ליסטעד אונטן. אויב זיי שוין עקסיסטירן, זיי וועלן זיין אָוווערריטאַן.
דזשענערייטאַד/uart_regs.vhd

דזשענערייטאַד/uart_regs.py
generated/instantiation_template.vho
uart_regs.vhd

דאָס איז דער מנהג צובינד מאָדולע דזשענערייטאַד דורך די שריפט. איר דאַרפֿן צו ינסטאַנטייט עס אין דיין פּלאַן, ווו עס קענען אַקסעס די רעדזשיסטערז איר ווילן צו קאָנטראָלירן מיט UART.
אַלץ אויבן די "- UART צוטריטלעך רעדזשיסטערס" אָפּטיילונג וועט זיין יידעניקאַל פֿאַר יעדער uart_regs מאָדולע, בשעת דער זאַץ פון פּאָרט סיגנאַלז ונטער דער שורה דעפּענדס אויף די אַרגומענטן געגעבן צו די גענעראַטאָר שריפט.
די רשימה אונטן ווייזט די ענטיטי פֿאַר די uart_regs מאָדולע ריזאַלטינג פון די דזשענערייט באַפֿעל עקסampעס איז געוויזן אין די gen_uart_regs.py סעקטי

איר טאָן ניט דאַרפֿן צו סינגקראַנייז די uart_rx סיגנאַל, ווייַל דאָס איז כאַנדאַלד אין די uart_rx. מאָדולע.
ווען דער מאָדולע באקומט אַ לייענען בעטן, עס וועט כאַפּן די וואַלועס פון אַלע אַרייַנשרייַב און רעזולטאַט סיגנאַלז אין דעם קראַנט זייגער ציקל. די ינסטאַנטאַניאַס מאָמענטבילד איז דערנאָך געשיקט צו דער באַלעבאָס איבער UART.
ווען אַ שרייַבן כאַפּאַנז, אַלע רעזולטאַט רעדזשיסטערז זענען דערהייַנטיקט מיט די נייַע וואַלועס אין דער זעלביקער זייגער ציקל. עס איז ניט מעגלעך צו טוישן די רעזולטאַט סיגנאַל וואַלועס ינדיווידזשואַלי.

אָבער, די uart_regs.py שריפט אַלאַוז דער באַניצער צו דערהייַנטיקן בלויז אויסגעקליבן אַוטפּוץ דורך ערשטער לייענען צוריק די קראַנט וואַלועס פון אַלע רעדזשיסטערז. דערנאָך, עס שרייבט צוריק אַלע וואַלועס, אַרייַנגערעכנט די דערהייַנטיקט אָנעס.
uart_regs.py
די דזשענערייטאַד /uart_regs.py file איז דזשענערייטאַד צוזאַמען מיט די uart_regs VHDL מאָדולע און כּולל די מנהג רעגיסטרירן אינפֿאָרמאַציע אין די כעדער פון די 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
יעדער לייענען ווייזט אַ ינסטאַנטאַניאַס מאָמענטבילד פון אַלע אַרייַנשרייַב און רעזולטאַט רעדזשיסטערז. זיי זענען אַלע סampגעפירט בעשאַס די זעלבע זייגער ציקל

דיבאַגינג

ניצן די -d באַשטימען מיט קיין פון די אנדערע סוויטשיז אויב איר דאַרפֿן צו דיבאַגינג די קאָמוניקאַציע פּראָטאָקאָל. דערנאָך, דער שריפט וועט דרוקן אַלע געשיקט און באקומען ביטעס און tag זיי אויב זיי זענען קאָנטראָל אותיות, ווי געוויזן אונטן.

ניצן די צובינד אין אנדערע פּיטהאָן סקריפּס

די uart_regs.py שריפט כּולל אַ UartRegs קלאַס וואָס איר קענען לייכט נוצן ווי די קאָמוניקאַציע צובינד אין אנדערע מנהג פּיטהאָן סקריפּס. סימפּלי אַרייַנפיר די קלאַס, שאַפֿן אַ כייפעץ פון עס און אָנהייבן ניצן די מעטהאָדס ווי געוויזן אונטן.

אָפּשיקן צו די דאָקסטרינגס אין די 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 קאָמוניקאַציע מיט דער באַלעבאָס.

דעמאָ פּראַדזשעקס

עס זענען דריי דעמאָ פּראַדזשעקס אַרייַנגערעכנט אין די זיפּ file. זיי לאָזן איר קאָנטראָלירן די פּעריפעראַלס אויף די פאַרשידענע באָרדז און עטלעכע גרעסערע ינערלעך רעדזשיסטערס.
די דעמאָ פאָלדערס אַרייַננעמען פאַר-דזשענערייטאַד uart_regs.vhd און uart_regs.py fileס געמאכט ספּאַסיפיקלי פֿאַר די דיזיינז.

לאַטאַס ייססטיקק

די דעמאָ / icecube2_icestick טעקע כּולל אַ רעגיסטרירט אַקסעס דעמאָ ימפּלאַמענטיישאַן פֿאַר די Lattice iCEstick FPGA ברעט.
צו לויפן דורך די ימפּלאַמענטיישאַן פּראָצעס, עפֿענען די דעמאָ/lattice_icestick/icecube2_proj/uart_regs_sbt.project file אין די Lattice iCEcube2 פּלאַן ווייכווארג.
נאָך לאָודינג די פּרויעקט אין די iCEcube2 GUI, גיט מכשירים → לויפן אַלע צו דזשענערייט די פּראָגראַממינג ביטמאַפּ file.

איר קענט נוצן די סטאַנדאַלאָנע לאַטאַס דיאַמאָנד פּראָגראַמיסט געצייַג צו קאַנפיגיער די FPGA מיט די דזשענערייטאַד ביטמאַפּ file. ווען דיאַמאָנד פּראָגראַמיסט אָפּענס, גיט עפֿן אַ יגזיסטינג פּראָגראַמיסט פּרויעקט אין די באַגריסונג דיאַלאָג קעסטל.
אויסקלייַבן פּרויעקט file געפונען אין די פאַרשלעסלען: demo/lattice_icestick/diamond_programmer_project.xcf און גיט OK.
נאָך די פּרויעקט לאָודז, גיט די דריי דאַץ אין די File נאָמען זייַל, ווי געוויזן אויבן. בלעטער צו סעלעקטירן דעם ביטמאַפּ file אַז איר דזשענערייטאַד אין iCEcube2

דעמאָ/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
צום סוף, מיט די iCEstick ברעט פּלאַגד אין אַ וסב פּאָרט אויף דיין קאָמפּיוטער, סעלעקטירן פּלאַן → פּראָגראַם צו פּראָגראַם די SPI בליץ און קאַנפיגיער די FPGA.
איר קענט איצט פאָרזעצן צו לייענען און שרייַבן רעדזשיסטערז דורך ניצן די דעמאָ/lattice_icestick/uart_regs.py שריפט ווי דיסקרייבד אין די uart_regs.py אָפּטיילונג.

Xilinx Digilent Arty A7-35T

איר קענען געפֿינען די דעמאָ ימפּלאַמענטיישאַן פֿאַר די Artix-7 35T Arty FPGA אפשאצונג קיט אין די דעמאָ/arty_a7_35 טעקע.
עפֿן Vivado און נאַוויגירן צו די יקסטראַקטיד fileניצן די Tcl קאַנסאָול געפֿונען אין די דנאָ פון די GUI צובינד. טיפּ דעם באַפֿעל צו אַרייַן די דעמאָ פּרויעקט טעקע:

cd /demo/arty_a7_35/vivado_proj/
ויספירן די create_vivado_proj.tcl Tcl שריפט צו רידזשענערייט די Vivado פּרויעקט:
מקור ./create_vivado_proj.tcl

דריקט גענעראַטע ביטסטרים אין די סיידבאַר צו לויפן דורך אַלע די ימפּלאַמענטיישאַן סטעפּס און דזשענערייט די פּראָגראַממינג ביטסטרים file.
צום סוף, גיט עפֿן ייַזנוואַרג מאַנאַגער און פּראָגראַם די FPGA דורך די GUI.
איר קענט איצט פאָרזעצן צו לייענען און שרייַבן רעדזשיסטערז דורך ניצן די דעמאָ/arty_a7_35/uart_regs.py שריפט ווי דיסקרייבד אין די uart_regs.py אָפּטיילונג.

Xilinx Digilent Arty S7-50

איר קענען געפֿינען די דעמאָ ימפּלאַמענטיישאַן פֿאַר די Arty S7: Spartan-7 FPGA אַנטוויקלונג ברעט אין די דעמאָ/arty_s7_50 טעקע.
עפֿן Vivado און נאַוויגירן צו די יקסטראַקטיד fileניצן די Tcl קאַנסאָול געפֿונען אין די דנאָ פון די GUI צובינד. טיפּ דעם באַפֿעל צו אַרייַן די דעמאָ פּרויעקט טעקע:

cd /demo/arty_s7_50/vivado_proj/
ויספירן די create_vivado_proj.tcl Tcl שריפט צו רידזשענערייט די Vivado פּרויעקט:
מקור ./create_vivado_proj.tcl

דריקט גענעראַטע ביטסטרים אין די סיידבאַר צו לויפן דורך אַלע די ימפּלאַמענטיישאַן סטעפּס און דזשענערייט די פּראָגראַממינג ביטסטרים file.
צום סוף, גיט עפֿן ייַזנוואַרג מאַנאַגער און פּראָגראַם די FPGA דורך די GUI.
איר קענט איצט פאָרזעצן צו לייענען און שרייַבן רעדזשיסטערז דורך ניצן די דעמאָ/arty_s7_50/uart_regs.py שריפט ווי דיסקרייבד אין די uart_regs.py אָפּטיילונג.

ימפּלעמענטאַטיאָן

עס זענען קיין ספּעציפיש ימפּלאַמענטיישאַן באדערפענישן.

קאַנסטריינץ

קיין ספּעציפיש טיימינג קאַנסטריינץ זענען דארף פֿאַר דעם פּלאַן ווייַל די UART צובינד איז פּאַמעלעך און באהאנדלט ווי אַ ייסינגקראַנאַס צובינד.

די uart_rx אַרייַנשרייַב צו די uart_regs מאָדולע איז סינגקראַנייזד אין די uart_rx מאָדולע. אַזוי, עס דאַרף ניט זיין סינגקראַנייזד אין די שפּיץ-מדרגה מאָדולע.

באקאנט ישוז

איר קען דאַרפֿן צו באַשטעטיק די מאָדולע איידער עס קענען זיין געוויינט, דיפּענדינג אויף צי דיין FPGA אַרקאַטעקטשער שטיצט פעליקייַט רעגיסטרירן וואַלועס.

מער אינפֿאָרמאַציע

דרוקרעכט VHDLwhiz.com

FAQ

ק: וואָס איז דער ציל פון די UART פּרובירן צובינד גענעראַטאָר?

א: די UART פּרובירן צובינד גענעראַטאָר אַלאַוז די שאַפונג פון מנהג ינטערפייסיז צו ינטעראַקט מיט FPGA רעגיסטרירן וואַלועס ניצן UART קאָמוניקאַציע.

ק: ווי טאָן איך ינסטאַלירן די פּיסעריאַל פּעקל?

א: איר קענען ינסטאַלירן Pyserial דורך Pip ניצן די באַפֿעל: pip install pyserial

דאָקומענטן / רעסאָורסעס

VHDLwhiz UART טעסט צובינד גענעראַטאָר [pdfבאַניצער מאַנואַל
UART טעסט צובינד גענעראַטאָר, טעסט צובינד גענעראַטאָר, צובינד גענעראַטאָר, גענעראַטאָר

רעפערענצן

באַניצער מאַנואַל

VHDLwhiz UART טעסט צובינד גענעראַטאָר

פּראָדוקט אינפֿאָרמאַציע