เครื่องกำเนิดอินเทอร์เฟซการทดสอบ VHDLwhiz UART

ข้อมูลสินค้า

ข้อมูลจำเพาะ:

• ชื่อผลิตภัณฑ์: VHDL ลงทะเบียนเครื่องกำเนิดอินเทอร์เฟซการทดสอบ UART
• เวอร์ชัน : 1.0.4
• วันที่ : 18 สิงหาคม 2024
• ผู้เขียน : โจนาส จูเลียน เจนเซน
• ผลิตภัณฑ์ URL: ลิงค์สินค้า
• อีเมลติดต่อ: jonas@vhdlwhiz.com

คำอธิบาย

ผลิตภัณฑ์นี้ช่วยให้คุณสร้างอินเทอร์เฟซแบบกำหนดเองสำหรับการอ่านและเขียนค่ารีจิสเตอร์ FPGA โดยใช้ UART โมดูล VHDL ที่สร้างขึ้นและสคริปต์ Python ช่วยให้สามารถโต้ตอบกับรีจิสเตอร์ประเภทต่างๆ ในการออกแบบ FPGA ของคุณได้

ความต้องการ

• ล่ามภาษา Python 3
• แพ็คเกจ pyserial

โปรโตคอล

ผลิตภัณฑ์ใช้โปรโตคอลการจัดกรอบข้อมูลโดยมีอักขระควบคุมสี่ตัว:

• ชื่อ: อ่าน REQ, ค่า: 0x0A – คำสั่งจากโฮสต์ไปยัง FPGA เพื่อเริ่มลำดับการเขียนเพื่อส่งรีจิสเตอร์ทั้งหมดกลับผ่าน UART
• ชื่อ: เริ่มเขียน, ค่า: 0x0B – ทำเครื่องหมายจุดเริ่มต้นของลำดับการเขียนในทั้งสองทิศทาง
• ชื่อ: END_เขียน, ค่า: 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 ในซิป file สำหรับรายละเอียดเพิ่มเติม

บันทึกการเปลี่ยนแปลง

• การเปลี่ยนแปลงเหล่านี้อ้างถึงโครงการ fileและเอกสารนี้ได้รับการปรับปรุงให้ทันสมัยตามนั้น

เวอร์ชัน	หมายเหตุ
1.0.0	การเปิดตัวครั้งแรก
1.0.1	แก้ไขข้อบกพร่องการอ้างอิง "self" ที่ขาดหายไปเมื่อนำเข้าเป็น uart_regs.py เป็นโมดูล Python แก้ไขการพิมพ์ที่ล้มเหลวในการเขียนเป็นข้อยกเว้น หลีกเลี่ยงการพิมพ์ไปที่คอนโซลเมื่อทำงานเป็นโมดูลที่นำเข้า
1.0.2	แก้ไขข้อผิดพลาด Vivado [Synth 8-248] เมื่อไม่มีการควบคุมโหมดออก
1.0.3	แก้ไขคำเตือน Vivado Linter: การลงทะเบียนเปิดใช้งานโดย รีเซ็ตแบบซิงโครนัส
1.0.4	แก้ไขกรณีพิเศษเมื่อได้รับคำที่มีรูปแบบไม่ถูกต้องโดยมีอักขระ escape เป็นไบต์สุดท้าย คำถัดไปจะสูญหายไปด้วยเนื่องจากเราไม่ได้ล้าง recv_data_prev_is_escape เมื่อกลับสู่ IDLE สคริปต์ gen_uart_regs.py อนุญาตให้มีเฉพาะชื่อ reg ที่ไม่ซ้ำกันเท่านั้น

คำอธิบาย

• เอกสารนี้อธิบายดังต่อไปนี้ files และโฟลเดอร์:
• gen_uart_regs.py
• สร้าง/uart_regs.vhd
• สร้าง/uart_regs.py
• สร้าง/instantiation_template.vho
• rtl/uart_regs_backend.vhd
• rtl/uart_rx.vhd
• rtl/uart_tx.vhd
• สาธิต/lattice_icestick/
• สาธิต/xilinx_arty_a7_35/
• สาธิต/xilinx_arty_s7_50/
• สคริปต์ gen_uart_regs.py และ VHDL ที่รองรับ fileในโปรเจ็กต์นี้อนุญาตให้คุณสร้างอินเทอร์เฟซที่กำหนดเองสำหรับการอ่านและเขียนค่ารีจิสเตอร์ FPGA ประเภทและความกว้างต่างๆ โดยใช้ UART
• คุณสามารถใช้โมดูล VHDL ที่สร้างขึ้นและสคริปต์ Python เพื่ออ่านหรือเขียนไปยังรีจิสเตอร์จำนวนเท่าใดก็ได้ในการออกแบบของคุณ การลงทะเบียนที่เข้าถึงได้ของ UART สามารถมีประเภท std_logic, std_logic_vector, ลงนามหรือไม่ได้ลงนาม
• คุณสามารถเลือกองค์ประกอบที่แม่นยำของรีจิสเตอร์อินพุตและเอาท์พุตและประเภทเมื่อสร้างเอาต์พุต fileกำลังใช้สคริปต์ gen_uart_regs.py
• สคริปต์ Python ถูกสร้างขึ้นบางส่วนด้วยความช่วยเหลือของเครื่องมือปัญญาประดิษฐ์ ChatGPT ในขณะที่โค้ด VHDL นั้นถูกสร้างขึ้นด้วยมือ

ความต้องการ

• สคริปต์ในโปรเจ็กต์นี้ต้องทำงานผ่านล่าม Python 3 และต้องติดตั้งแพ็คเกจ Pyserial
• คุณสามารถติดตั้ง pyserial ผ่าน Pip ได้โดยใช้คำสั่งนี้: pip install pyserial

โปรโตคอล

• วีเอชดีแอล files และสคริปต์ Python ใช้โปรโตคอลการจัดกรอบข้อมูลที่มีการควบคุมสี่ประการ

ชื่อ	ค่า	ความคิดเห็น
อ่าน REQ	0x0A	คำสั่งจากโฮสต์ไปยัง FPGA เพื่อเริ่มการเขียน ลำดับการส่งรีจิสเตอร์ทั้งหมดกลับผ่าน UART
START_เขียน	0x0B	ทำเครื่องหมายจุดเริ่มต้นของลำดับการเขียนใน ทิศทาง
END_เขียน	0x0C	ทำเครื่องหมายจุดสิ้นสุดของลำดับการเขียนในทิศทางใดทิศทางหนึ่ง
หนี	0x0D	อักขระ Escape ใช้สำหรับ Escape คำควบคุมใดๆ รวมถึงอักขระ ESCAPE ด้วย เมื่อปรากฏเป็นข้อมูลระหว่างเครื่องหมาย START_WRITE และ END_WRITE

ไบต์ READ_REQ ที่ไม่ได้ใช้ Escape ที่ส่งไปยัง FPGA คือคำสั่งให้ส่งรีจิสเตอร์ที่เข้าถึงได้ของ UART ทั้งหมด (อินพุตและเอาต์พุต) กลับไปยังโฮสต์ผ่าน UART โดยปกติคำสั่งนี้จะออกโดยสคริปต์ uart_regs.py เท่านั้น
เมื่อได้รับคำสั่งนี้ FPGA จะตอบสนองโดยส่งเนื้อหาของรีจิสเตอร์ทั้งหมดกลับไปยังโฮสต์ ขั้นแรก สัญญาณอินพุต จากนั้นสัญญาณเอาท์พุต หากความยาวรวมกันไม่เป็นทวีคูณของ 8 บิต บิตล่างของไบต์สุดท้ายจะถูกเติมด้วยศูนย์
ลำดับการเขียนจะเริ่มต้นด้วยไบต์ START_WRITE และสิ้นสุดด้วยไบต์ END_WRITE ไบต์ใดๆ ระหว่างไบต์เหล่านี้จะถือเป็นไบต์ข้อมูล หากไบต์ข้อมูลใดๆ มีค่าเท่ากับอักขระควบคุม ไบต์ข้อมูลนั้นจะต้องถูกเอสเคป ซึ่งหมายความว่าจะต้องส่งอักขระ ESCAPE เพิ่มเติมก่อนไบต์ข้อมูลเพื่อระบุว่าเป็นข้อมูลจริง
หาก START_WRITE ที่ไม่ได้ใช้ Escape มาถึงที่ใดก็ได้ในสตรีมไบต์ จะถือเป็นจุดเริ่มต้นของลำดับการเขียน โมดูล 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:ใน
• my_sl=1:in:std_logic
• ตัวแปรข้างต้นทั้งหมดจะส่งผลให้สคริปต์สร้างสัญญาณที่เข้าถึง UART ได้:
• ให้รันสคริปต์ที่มีอาร์กิวเมนต์เพื่อสร้างอินเทอร์เฟซที่มีรีจิสเตอร์หลายตัวที่มีทิศทาง ความยาว และประเภทต่างกัน

สร้างขึ้น files

• การรันสคริปต์ gen_uart_regs.py ที่ประสบความสำเร็จจะสร้างโฟลเดอร์เอาต์พุตชื่อที่สร้างด้วยทั้งสาม fileดังรายการด้านล่าง หากมีอยู่แล้ว พวกเขาจะถูกเขียนทับ
• สร้าง/uart_regs.vhd
• สร้าง/uart_regs.py
• สร้าง/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 หากเป็นอักขระควบคุม ดังที่แสดงด้านล่าง

การใช้อินเทอร์เฟซในสคริปต์ Python อื่น

• สคริปต์ uart_regs.py มีคลาส UartRegs ที่คุณสามารถใช้เป็นอินเทอร์เฟซการสื่อสารในสคริปต์ Python ที่กำหนดเองอื่นๆ ได้อย่างง่ายดาย เพียงนำเข้าคลาส สร้างอ็อบเจ็กต์ของคลาสนั้น และเริ่มใช้วิธีการดังที่แสดงด้านล่าง
• อ้างถึงเอกสารในโค้ด Python สำหรับวิธีการและคำอธิบายและประเภทค่าส่งคืน

Instantiation_template.vho

• เทมเพลตการสร้างอินสแตนซ์จะถูกสร้างขึ้นพร้อมกับโมดูล uart_regs เพื่อความสะดวกของคุณ เพื่อประหยัดเวลาในการเขียนโค้ด คุณสามารถคัดลอกการสร้างอินสแตนซ์ของโมดูลและการประกาศสัญญาณลงในการออกแบบของคุณได้

RTL แบบคงที่ files

• คุณต้องมีสิ่งต่อไปนี้ fileในโปรเจ็กต์ 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 มีการดำเนินการสาธิตการเข้าถึงการลงทะเบียนสำหรับบอร์ด Lattice iCEstick FPGA
• หากต้องการดำเนินการตามขั้นตอนการใช้งาน ให้เปิด demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file ในซอฟต์แวร์ออกแบบ Lattice iCEcube2
• หลังจากโหลดโปรเจ็กต์ใน iCEcube2 GUI แล้ว คลิก Tools→Run All เพื่อสร้างบิตแมปการเขียนโปรแกรม file.
• คุณสามารถใช้เครื่องมือ Lattice Diamond Programmer Standalone เพื่อกำหนดค่า FPGA ด้วยบิตแมปที่สร้างขึ้น file. เมื่อ Diamond Programmer เปิดขึ้น ให้คลิก Open an existing programmer project ในกล่องโต้ตอบต้อนรับ
• เลือกโครงการ file พบใน Zip: demo/lattice_icestick/diamond_programmer_project.xcf แล้วคลิกตกลง
• หลังจากโหลดโปรเจ็กต์แล้ว ให้คลิกจุดสามจุดใน File คอลัมน์ชื่อตามที่แสดงด้านบน เรียกดูเพื่อเลือกบิตแมป file ที่คุณสร้างใน iCEcube2
• เดโม่/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
• สุดท้าย เมื่อเสียบบอร์ด iCEstick เข้ากับพอร์ต USB บนคอมพิวเตอร์ของคุณ ให้เลือก Design → Program เพื่อตั้งโปรแกรมแฟลช SPI และกำหนดค่า FPGA
• ขณะนี้คุณสามารถดำเนินการอ่านและเขียนรีจิสเตอร์ได้โดยใช้สคริปต์ demo/lattice_icestick/uart_regs.py ตามที่อธิบายไว้ในส่วน uart_regs.py

Xilinx ดิจิเลนท์ อาร์ตี้ A7-35T

• คุณสามารถดูการใช้งานสาธิตสำหรับชุดประเมินผล Artix-7 35T Arty FPGA ได้ในโฟลเดอร์ demo/arty_a7_35
• เปิด Vivado แล้วไปที่ไฟล์ที่แยกออกมา fileกำลังใช้คอนโซล Tcl ที่ด้านล่างของอินเทอร์เฟซ GUI พิมพ์คำสั่งนี้เพื่อเข้าสู่โฟลเดอร์โครงการสาธิต:
• ซีดี /สาธิต/อาร์ตี้_a7_35/วีวาโด_โปรเจกต์/
• ดำเนินการสคริปต์ create_vivado_proj.tcl Tcl เพื่อสร้างโปรเจ็กต์ Vivado ใหม่:
• ที่มา ./create_vivado_proj.tcl
• คลิกสร้าง Bitstream ในแถบด้านข้างเพื่อดำเนินการตามขั้นตอนการใช้งานทั้งหมด และสร้างบิตสตรีมการเขียนโปรแกรม file.
• สุดท้าย คลิก Open Hardware Manager และตั้งโปรแกรม FPGA ผ่าน GUI
• ตอนนี้คุณสามารถอ่านและเขียนรีจิสเตอร์ได้โดยใช้สคริปต์ demo/arty_a7_35/uart_regs.py ตามที่อธิบายไว้ในส่วน uart_regs.py

Xilinx ดิจิเลนท์ อาร์ตี้ S7-50

• คุณสามารถดูการใช้งานสาธิตสำหรับ Arty S7: Spartan-7 FPGA development board ได้ในโฟลเดอร์ demo/arty_s7_50
• เปิด Vivado แล้วไปที่ไฟล์ที่แยกออกมา fileกำลังใช้คอนโซล Tcl ที่ด้านล่างของอินเทอร์เฟซ GUI พิมพ์คำสั่งนี้เพื่อเข้าสู่โฟลเดอร์โครงการสาธิต:
• ซีดี /สาธิต/อาร์ตี้_s7_50/vivado_proj/
• ดำเนินการสคริปต์ create_vivado_proj.tcl Tcl เพื่อสร้างโปรเจ็กต์ Vivado ใหม่:
• ที่มา ./create_vivado_proj.tcl
• คลิกสร้าง Bitstream ในแถบด้านข้างเพื่อดำเนินการตามขั้นตอนการใช้งานทั้งหมด และสร้างบิตสตรีมการเขียนโปรแกรม file.
• สุดท้าย คลิก Open Hardware Manager และตั้งโปรแกรม FPGA ผ่าน GUI
• ตอนนี้คุณสามารถอ่านและเขียนรีจิสเตอร์ได้โดยใช้สคริปต์ demo/arty_s7_50/uart_regs.py ตามที่อธิบายไว้ในส่วน uart_regs.py

การนำไปปฏิบัติ

• ไม่มีข้อกำหนดการใช้งานเฉพาะ

ข้อจำกัด

• ไม่จำเป็นต้องมีข้อจำกัดด้านเวลาที่เฉพาะเจาะจงสำหรับการออกแบบนี้ เนื่องจากอินเทอร์เฟซ UART ทำงานช้าและถือเป็นอินเทอร์เฟซแบบอะซิงโครนัส
• อินพุต uart_rx ไปยังโมดูล uart_regs ได้รับการซิงโครไนซ์ภายในโมดูล uart_rx ดังนั้นจึงไม่จำเป็นต้องซิงโครไนซ์ในโมดูลระดับบนสุด

ปัญหาที่ทราบ

• คุณอาจต้องรีเซ็ตโมดูลก่อนจึงจะสามารถใช้งานได้ ขึ้นอยู่กับว่าสถาปัตยกรรม FPGA ของคุณรองรับค่ารีจิสเตอร์เริ่มต้นหรือไม่

ข้อมูลเพิ่มเติม

• ลิขสิทธิ์ VHDLwhiz.com

คำถามที่พบบ่อย

ถาม: จุดประสงค์ของเครื่องสร้างอินเทอร์เฟซการทดสอบ UART คืออะไร

A: เครื่องสร้างอินเทอร์เฟซการทดสอบ UART ช่วยให้สามารถสร้างอินเทอร์เฟซแบบกำหนดเองเพื่อโต้ตอบกับค่ารีจิสเตอร์ FPGA โดยใช้การสื่อสาร UART

ถาม: ฉันจะติดตั้งแพ็คเกจ Pyserial ได้อย่างไร

A: คุณสามารถติดตั้ง Pyserial ผ่าน Pip ได้โดยใช้คำสั่ง: pip install pyserial

เอกสาร / แหล่งข้อมูล

เครื่องกำเนิดอินเทอร์เฟซการทดสอบ VHDLwhiz UART [พีดีเอฟ] คู่มือการใช้งาน เครื่องกำเนิดอินเทอร์เฟซการทดสอบ UART เครื่องกำเนิดอินเทอร์เฟซการทดสอบ เครื่องกำเนิดอินเทอร์เฟซ เครื่องกำเนิดไฟฟ้า

อ้างอิง

• คู่มือการใช้งาน