FPGA तक पहुंच के उदाहरण पर केंद्रीय प्रोसेसर रेड के लिए कार्यक्रमों का विकास

पिछले लेख में, मैंने कहा कि हमारे लिए स्ट्रीमिंग प्रोटोकॉल पर आगे बढ़ने का समय है। लेकिन मैंने उनके बारे में एक कहानी तैयार करना शुरू कर दिया, मैंने महसूस किया कि मैं खुद एक बहुत महत्वपूर्ण विषय में तैर रहा हूं। जैसा कि पहले ही उल्लेख किया गया है, लिनक्स के साथ मेरा संबंध काफी अजीब है। सामान्य तौर पर, मुझे एहसास हुआ कि मैं खुद एक सी ++ एप्लिकेशन को खरोंच से नहीं बना सकता हूं जो रेडड के लिए प्रोग्रामिंग के सभी सिद्धांतों को पूरा करेगा। आप किसी को ऐसा करने के लिए कह सकते हैं, और फिर बस तैयार किए गए टेम्पलेट का उपयोग कर सकते हैं, लेकिन लेखों की श्रृंखला सभी को यह सिखाने के लिए डिज़ाइन की गई है कि कैसे खरोंच से रेड के तहत विकसित किया जाए। इसलिए, मैंने अपने बॉस (एक महान लिनक्स विशेषज्ञ) से पूछा, और उन्होंने मुझे समझाया कि किस पर क्लिक करना है। फिर मैंने उनके शब्दों पर थोड़ा पुनर्विचार किया और अब मैं लिखित रूप में सभी ज्ञान को ठीक करना आवश्यक मानता हूं। यह मेरे जैसे लोगों को दर्दनाक विचारों से बचाएगा: "तो ... उन्होंने जो किया वह समझ में आता है, लेकिन मैं इसे कैसे दोहरा सकता हूं?" सामान्य तौर पर, लिनक्स के तहत काम करने वाला कोई भी व्यक्ति निम्नलिखित दो वर्गों को तिरछे तरीके से चला सकता है। यह संभावना नहीं है कि आपको वहां कुछ नया मिलेगा (आप आगे पाएंगे)। और बाकी के लिए, मैं दो विकास विधियों की पेशकश करता हूं जो कि Redd के तहत काम करने के घोषित सिद्धांतों के अनुरूप हैं: विकास और दूरस्थ डिबगिंग के लिए कम श्रम लागत।



चक्र के सभी लेख:

1. Redd में स्थापित FPGAs के लिए सबसे सरल "फर्मवेयर" का विकास, और एक उदाहरण के रूप में मेमोरी टेस्ट का उपयोग करके डिबगिंग
2. Redd में स्थापित FPGAs के लिए सबसे सरल "फर्मवेयर" का विकास। भाग 2. कार्यक्रम कोड
3. FPGA पर आधारित प्रोसेसर सिस्टम में एम्बेड करने के लिए अपने स्वयं के कोर का विकास

विजुअल स्टूडियो टूल्स के साथ काम करें

यह पता चला है कि आप दूरस्थ लिनक्स के लिए विकास का संचालन कर सकते हैं, बिना अपने स्थानीय मशीन पर और बिना किसी गैर-Microsoft सॉफ़्टवेयर टूल को इंस्टॉल किए बिना। यहां यह दिखाया गया है कि इसे विजुअल स्टूडियो में कैसे डाला जाता है (मैंने इसे 2019 के संस्करण में स्थापित किया था, लेकिन ऐसा लगता है कि यह 2015 में दिखाई दिया) docs.microsoft.com/ru-ru/cpp/linux/download-install-and-setup- the-linux-development-workload? view = vs-2019

और यहाँ काम का सिद्धांत है ।

ठीक है, वहां आप टैब, बहुत सारे सिद्धांत और सभी रूसी में घूम सकते हैं।

वाह! आइए FT2232H चिप का उपयोग करने के लिए अधिग्रहीत ज्ञान का उपयोग करने का प्रयास करें, जिसके माध्यम से Redd केंद्रीय प्रोसेसर FPGA से जुड़ा है। यह भविष्य में यह चैनल है जो हमारे स्ट्रीमिंग कार्य का आधार बनेगा। दृश्य स्टूडियो खोलें, "प्रोजेक्ट बनाएं" चुनें। फ़िल्टर में, "भाषा - C ++", "प्लेटफ़ॉर्म - लिनक्स", "प्रोजेक्ट प्रकार - कंसोल" चुनें। मैं दिखाऊंगा कि यह परियोजना के प्रकार के लिए पहले से ही कहां स्थित है। हमें जो फ़िल्टर किया गया है, उससे हम "कंसोल एप्लिकेशन" का चयन करते हैं:



चलो इसे कहते हैं, SimpleConsole कहते हैं। हमने एक ऐसा स्पार्टन सोर्स कोड बनाया है:

#include <cstdio> int main() { printf("hello from SimpleConsole!\n"); return 0; } 

चलो इसे इकट्ठा करने की कोशिश करते हैं। और हमें कनेक्शन स्थापित करने के बारे में एक बहुत ही दिलचस्प सवाल पूछा जाता है। यह विजुअल स्टूडियो में विकास की एक विशेषता है। पर्यावरण में एक क्रॉस-कंपाइलर और कोई लाइब्रेरी नहीं है। यह बस रिमोट मशीन पर एक स्रोत निर्देशिका बनाता है, जिसके बाद प्रत्येक संकलन के लिए यह अद्यतन की गई फ़ाइलों को कॉपी करता है और वहां संकलन शुरू करता है। यही कारण है कि रिमोट मशीन के साथ कनेक्शन शुरू करने के लिए स्थापित नहीं किया जाना चाहिए, लेकिन पहले से ही परियोजना की सामान्य विधानसभा के लिए।

हम Redd उपयोगकर्ता के लिए मापदंडों को भरते हैं, जिनकी ओर से परियोजना पर काम किया जाएगा।



यदि कुछ भी - इस गुप्त स्थान पर पैरामीटर बदले जा सकते हैं (परियोजना के गुणों को बदलने की कोशिश न करें, तो इससे कुछ भी अच्छा नहीं होगा):





दरअसल, आप एक ही लाइन पर एक ब्रेकपॉइंट डाल सकते हैं और सत्यापित कर सकते हैं कि परियोजना शुरू होती है और काम करती है। लेकिन यह तुच्छ है। इसलिए, हम एक और अधिक दिलचस्प कार्य के लिए आगे बढ़ते हैं - FT2232 के साथ काम करना। सवाल उठता है: जहां आवश्यक पुस्तकालय प्राप्त करने के लिए? लिनक्स के लिए, ड्राइवर पैकेज में सब कुछ शामिल है। वहाँ ड्राइवर ही है, और पुस्तकालयों, और उनके साथ काम करने के लिए अनुप्रयोगों के उदाहरण, और यहां तक ​​कि एक संक्षिप्त निर्देश भी। सामान्य तौर पर, हम खोज इंजन में ड्राइव करते हैं:

 FTDI D2XX drivers 

वह दिखाएगा कि उन्हें कहां से डाउनलोड किया जा सकता है। सच, विशेष रूप से, मेरे लिए सब कुछ बुरा था। मेरा प्रदाता RosKomNadzor का जिक्र करते हुए FTDI वेबसाइट (साथ ही रिप्रेज़, 7zip और यहां तक ​​कि ऑस्ट्रोनलाइन) को ब्लॉक करता है। ILV, कथनों के जवाब में, यह कहते हुए अनसब्सक्राइब करता है कि हम कुछ भी ब्लॉक नहीं कर रहे हैं, बल्कि प्रदाता के साथ स्वयं व्यवहार करें। जहां केवल इन अनसब्सक्राइबर्स में उन्होंने मुझे मुड़ने की पेशकश नहीं की, यहां तक ​​कि पुलिस को भी। वे बहुत ही बेबाक हैं। ILV निष्क्रियता के बारे में शिकायत करने का प्रयास ILV को अग्रेषित किया जा रहा है, जहां से अगले सदस्यता रद्द करने का प्रयास किया जाता है। सामान्य तौर पर, यह पता चल सकता है कि आपका प्रदाता एक्सेस को ब्लॉक भी करेगा। सतर्क न रहें, बस डाउनलोड करने के अन्य तरीकों की तलाश करें, इस पर समय व्यतीत करें। और फिर वे आश्चर्यचकित हैं कि मिसाइलों के विकास में दशकों से देरी हो रही है ... मैंने पिछले नवंबर में ILV के साथ पत्राचार शुरू किया था, अब यह जून है, सदस्यता समाप्त करने के अलावा - कोई कार्रवाई नहीं ... लेकिन मैं विचलित हो गया।

ड्राइवरों का उपयोग कैसे किया जा सकता है यह रेडीम फ़ाइल में, पैकेज में ही पाया जा सकता है। आप लिनक्स के लिए दस्तावेज़ AN_220 FTDI ड्राइवर्स इंस्टॉलेशन गाइड भी पा सकते हैं। अंत में, आप YouTube पर FTDI चिप्स द्वारा लिनक्स d2xx ड्राइवर इंस्टॉलेशन गाइड का एक वीडियो पा सकते हैं। इसका एक लिंक ड्राइवर डाउनलोड पेज पर भी है। सामान्य तौर पर, FTDI ने उपयोगकर्ताओं को सूचित करने के लिए विकल्पों पर ध्यान नहीं दिया। दरअसल, यदि आपको रेडी-मेड रेडी पैकेज मिला है, तो ड्राइवर खुद ही पहले से ही इनस्टॉल हो जाते हैं और उस पर कॉन्फ़िगर हो जाते हैं। और हम शीर्ष लेख फ़ाइलों और उदाहरणों में रुचि लेंगे।

आइए एक उदाहरण डालें स्लाइस \ रिलीज़ \ उदाहरण \ EEPROM \ read । मुख्य फ़ंक्शन की बहुत शुरुआत, जहां डिवाइस खुलता है और इसका प्रकार लिया जाता है। यह सुनिश्चित करने के लिए पर्याप्त होगा कि सब कुछ काम करता है। मुझे लेबलों से नफरत है, लेकिन चूंकि हम जल्दी से 10 मिनट तक चलने वाले कोड को खींचते हैं और छोड़ते हैं, इसलिए मैं उस लेबल को खींच दूंगा जो समय बचाने के लिए मूल उदाहरण में था। यह इस तरह से निकला:

 #include <cstdio> #include <stdio.h> #include <stdlib.h> #include <sys/time.h> #include "ftd2xx.h" int main(int argc, char* argv[]) { printf("hello from ConsoleApplication1!\n"); FT_STATUS ftStatus; FT_HANDLE ftHandle0; int iport; static FT_PROGRAM_DATA Data; static FT_DEVICE ftDevice; DWORD libraryVersion = 0; int retCode = 0; ftStatus = FT_GetLibraryVersion(&libraryVersion); if (ftStatus == FT_OK) { printf("Library version = 0x%x\n", (unsigned int)libraryVersion); } else { printf("Error reading library version.\n"); return 1; } if (argc > 1) { sscanf(argv[1], "%d", &iport); } else { iport = 0; } printf("Opening port %d\n", iport); ftStatus = FT_Open(iport, &ftHandle0); if (ftStatus != FT_OK) { /* This can fail if the ftdi_sio driver is loaded use lsmod to check this and rmmod ftdi_sio to remove also rmmod usbserial */ printf("FT_Open(%d) failed\n", iport); return 1; } printf("FT_Open succeeded. Handle is %p\n", ftHandle0); ftStatus = FT_GetDeviceInfo(ftHandle0, &ftDevice, NULL, NULL, NULL, NULL); if (ftStatus != FT_OK) { printf("FT_GetDeviceType FAILED!\n"); retCode = 1; goto exit; } printf("FT_GetDeviceInfo succeeded. Device is type %d.\n", (int)ftDevice); exit: return 0; } 

इकट्ठा करने की कोशिश कर रहा है - नहीं जा रहा है। पर्याप्त हेडर फाइलें नहीं।

 1>main.cpp 1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(5,20): error : ftd2xx.h:      1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(5,20): error : #include "ftd2xx.h" 1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(5,20): error : ^ 1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(5,20): error : compilation terminated. 

लेकिन मैंने उन्हें आगे रखा! सब कुछ सरल है। स्थानीय रूप से, वे पास हैं, लेकिन विधानसभा दूर से की जा रही है। स्टूडियो के लिए उन्हें दूरस्थ मशीन में स्थानांतरित करने के लिए, आपको उन्हें परियोजना में जोड़ना होगा। इसके अलावा, main.cpp फ़ाइल से मैं केवल ftd2xx.h जोड़ता हूं , लेकिन यह अभी भी WinTypes.h को पारगमन में खींचता है । आपको दोनों को जोड़ना होगा।





अब लिंक करने वाला शपथ लेता है।

 1>  1>D:\Work\SimpleConsole\SimpleConsole\obj\x64\Debug\main.o : error : In function `main': 1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(18): error : undefined reference to `FT_GetLibraryVersion' 1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(37): error : undefined reference to `FT_Open' 1>D:\Work\SimpleConsole\SimpleConsole\main.cpp(55): error : undefined reference to `FT_GetDeviceInfo' 1>collect2 : error : ld returned 1 exit status 

यह स्पष्ट है कि पर्याप्त पुस्तकालय नहीं है। उदाहरण के मेकफाइल्स का निरीक्षण करते हुए, मैंने महसूस किया कि मुझे लिंकर सेटिंग्स में कुछ मापदंडों को जोड़ने की जरूरत है:





अब यह परियोजना सफलतापूर्वक चल रही है। हमने आखिरी लाइन पर एक ब्रेकपॉइंट लगाया, चलाने की कोशिश की। हम निम्नलिखित पाठ देखते हैं:

 hello from ConsoleApplication1! Library version = 0x10408 Opening port 0 FT_Open succeeded. Handle is 0x555555768540 FT_GetDeviceInfo succeeded. Device is type 10. 

कुल मिलाकर - बुरा नहीं है। कुछ खोला, तो कुछ उपकरण भी मिले। टाइप 10 क्या है? FTDI से शीर्षक फ़ाइल में हम पाते हैं:

 enum { FT_DEVICE_BM, FT_DEVICE_AM, FT_DEVICE_100AX, FT_DEVICE_UNKNOWN, FT_DEVICE_2232C, FT_DEVICE_232R, FT_DEVICE_2232H, FT_DEVICE_4232H, FT_DEVICE_232H, FT_DEVICE_X_SERIES, FT_DEVICE_4222H_0, FT_DEVICE_4222H_1_2, FT_DEVICE_4222H_3, FT_DEVICE_4222_PROG, }; 

हम उंगली को ऊपर से नीचे तक गिनते हैं - हमारे सामने FT4222H है। हां, Redd में बहुत सारे FTDI डिवाइस हैं। अब मैं बस संक्षेप में कहूंगा कि हमें FT_Open () फ़ंक्शन को दिए गए डिवाइस की संख्या के माध्यम से क्रमबद्ध करना होगा, यह संख्या एक तर्क के रूप में मुख्य () फ़ंक्शन को पास की जाती है। इसे प्रोजेक्ट के डीबगिंग गुणों में सेट किया जा सकता है।

विशिष्ट समस्याओं के साथ एक प्लेट रखना उपयोगी है। आम तौर पर, यह बिना विवरण के "रेडड कॉन्फ़िगर करें" हर जगह कहता है। तथ्य यह है कि परिसरों को अनुकूलित रूप से वितरित किया जाएगा, इसलिए सभी पाठकों को कॉन्फ़िगरेशन नियमों की आवश्यकता नहीं है। समस्याओं के मामले में, व्यवस्थापक आमतौर पर कॉन्फ़िगरेशन से निपटेंगे। तो यह पता चला है कि आप निश्चित रूप से, कॉन्फ़िगरेशन नियमों का वर्णन कर सकते हैं, लेकिन इसमें बहुत अधिक स्थान होगा। इस पर ऊर्जा खर्च करना समझ में आता है अगर किसी को वास्तव में इसकी आवश्यकता है। इसलिए यहां मैं केवल समस्याओं को इंगित करने के लिए खुद को सीमित करूंगा, और उन्हें ठीक करने के लिए कैसे वर्णन करूंगा अगर प्रतिक्रिया में आवेदन हैं।


ठीक। हम विशेष रूप से Microsoft उपकरणों का उपयोग करके उपलब्धियों के लिए तैयार हैं। सामान्य तौर पर, यह पर्याप्त हो सकता है, लेकिन सिर्फ मामले में, मैं आपको एक विकल्प के बारे में बताता हूं जो मेरे बॉस ने मुझे सिखाया था।

वर्चुअल मशीन में चल रहे लिनक्स के साथ काम करना

पिछली विधि का मुख्य नुकसान दूरस्थ विधानसभा है। आप एक हजार और एक कारण के बारे में सोच सकते हैं कि विधानसभा को स्थानीय रूप से क्यों किया जाना चाहिए, और केवल समाप्त बाइनरी फ़ाइल को दूरस्थ मशीन में स्थानांतरित किया जाएगा। ये सभी प्रकार के पैरानॉयड प्रतिबंध हैं (हालाँकि फाइलें एक सुरक्षित प्रोटोकॉल का उपयोग करके प्रेषित की जाती हैं, और आप उनके भंडारण को अन्य उपयोगकर्ताओं से सुरक्षा नीतियों के साथ अलग कर सकते हैं), यह सिर्फ एक चिंता का विषय है कि Redd ड्राइव सभी प्रकार के पुस्तकालयों से नहीं बहती है, यह भी प्रत्येक हेडर फ़ाइल को पंजीकृत करने की अनिच्छा है। अगर उनमें से हजारों हैं ... ठीक है, और बहुत कुछ, बहुत अधिक। सामान्य तौर पर, स्थानीय असेंबली तकनीक उपयोगी हो सकती है, इसलिए इस पर विचार करें।

सबसे पहले, हमने लोकल मशीन पर Oracle से VirtualBox प्रोग्राम रखा। यदि कोई लाइसेंसिंग समस्याएं हैं (मैं इसे एक व्यक्ति के रूप में मुफ्त में उपयोग करता हूं, लेकिन मुझे नहीं पता कि कानूनी संस्थाओं के साथ क्या हो रहा है), एक अलग भौतिक मशीन का चयन करें और वहां लिनक्स डालें। कौन सा? मेरे लिए यह आसान है, मैं उन सभी को उसी के बारे में समझता हूं। मेरा मतलब है, मैं लगभग एक नहीं समझता। इसलिए, बॉस ने मुझसे कहा कि आपको डेबियन का उपयोग करने की आवश्यकता है, मैंने डेबियन को स्थापित किया। आप उसी तरह से जा सकते हैं (सिद्धांत का उपयोग करें "क्यों नहीं?")। कम से कम भविष्य में मैं उसके साथ काम करने पर भरोसा करूंगा।

लिनक्स के साथ काम करते समय, आपको दो नियमों का पालन करना चाहिए जो जीवन को बहुत सुविधाजनक बनाते हैं:

1. यदि, एक आदेश के जवाब में, वे हमें बताते हैं कि पर्याप्त अधिकार नहीं हैं, तो इसे दोहराने के लायक है, शुरुआत में सूडो जादू का जादू जोड़ना।
2. अगर किसी आदेश के जवाब में हमें बताया जाता है कि ऐसा कोई नहीं है, तो यह जादू की वर्तनी के माध्यम से इसे स्थापित करने के लायक है apt-get install <लापता चीज> ।

So. हमने सिर्फ OS स्थापित किया है। तुरंत G ++ कंपाइलर, साथ ही gdb डीबगर स्थापित करके C ++ समर्थन को वहां जोड़ें। कैसे? इसलिए नियम 2 का उपयोग करना:

apt-get install जी ++
apt-get install gdb

क्या नहीं दिया? वाह! नियम 1 का उपयोग करके दोहराएं:

sudo apt-get install जी ++
sudo apt-get install जीडीबी

अब हम इंटरनेट पर जाते हैं, खोज इंजन में हम टाइप करते हैं:

ग्रहण आईडीई

हमें eclipse.org का लिंक मिलता है, जहां जावा के लिए पहला विकल्प है, हम C / C ++ के लिए एक विकल्प ढूंढते हैं और डाउनलोड करते हैं:



डाउनलोड करें और अनपैक करें, कहें, घर में।

वास्तव में, कोई स्थापना की आवश्यकता नहीं है। बस उस निर्देशिका में जाएं जहां सब कुछ बस अनपैक किया गया है और ग्रहण फ़ाइल चलाएं:



हम एक विकास के माहौल में हैं। ठीक है, अगर आपने पहले से ही FPGAs के लिए माइक्रोकंट्रोलर और यहां तक ​​कि प्रोसेसर कोर के साथ काम किया है, तो आप शायद पहले से ही जानते हैं कि ग्रहण क्या है। इसलिए अपरिचित चीजें लगभग पूरी हो चुकी हैं। हम अधिक या कम परिचित चीजों में चारों ओर देखना शुरू करते हैं। हम C ++ प्रोजेक्ट बनाते हैं। मुझे तुरंत कहना होगा कि दो तरीके हैं। एक सफलता की ओर ले जाएगा, दूसरा एक मृत अंत तक। इसलिए, मेरे द्वारा चलने वाले पथ का सावधानीपूर्वक पालन करें:







हमने एक प्रोजेक्ट बनाया है जो अच्छा चल रहा है। इसके डीबगिंग को कॉन्फ़िगर करने के लिए, GDB गुणों पर जाएं:



कनेक्शन समूह में टाइप C / C ++ दूरस्थ अनुप्रयोग का कॉन्फ़िगरेशन बनाएँ, नया क्लिक करें:



SSH जैसा कनेक्शन चुनें:



हम प्राधिकरण के रेडियो बटन को पासवर्ड प्राधिकरण में बदलकर कनेक्शन गुण भरते हैं:



दरअसल, सिस्टम डिबगिंग के लिए तैयार है। यह सुनिश्चित करने के बाद कि स्वागत पाठ वास्तव में प्रदर्शित है, हम कोड को पिछले उदाहरण (जो विज़ुअल स्टूडियो में था) से यहाँ स्थानांतरित करने का प्रयास करते हैं। अतिरिक्त पुस्तकालयों को पंजीकृत करने के लिए, परियोजना के गुणों का चयन करें:



इसके अलावा, चूंकि विधानसभा स्थानीय स्तर पर चल रही है, इसलिए पुस्तकालयों को स्थानीय usr / स्थानीय / कामगार निर्देशिका में भी होना चाहिए। मैं आपको याद दिलाता हूं कि पुस्तकालयों को ड्राइवर के साथ डाउनलोड किया जाता है, और उन्हें कैसे स्थापित किया जाए यह रीडमी है, साथ ही विवरण के लिए AN220 और YouTube वीडियो, विज़ुअल स्टूडियो पर अनुभाग देखें।

इस सब तैयारी के बाद, हम परिचित पंक्तियों को प्राप्त करते हैं। यही है, पिछले अनुभाग में माना जाने वाला कोड पूरी तरह से समान है जिसे कोई कम पहचान नहीं है।

वह सब है। अब, स्थिति के आधार पर, हम विज़ुअल स्टूडियो और वर्चुअल मशीन के माध्यम से कोड चला सकते हैं। जैसा कि आप देख सकते हैं, विशुद्ध रूप से सेटिंग्स के संदर्भ में, विजुअल स्टूडियो सरल है, इसलिए, क्रेटरिस परिबस, मैं इसे चुनूंगा। लेकिन दोनों प्रौद्योगिकियों का मालिक होना बेहतर है, क्योंकि स्टूडियो के माध्यम से काम करने से इसकी कमियां इस तथ्य से संबंधित हैं कि न केवल डिबगिंग, बल्कि असेंबली भी वहां दूरस्थ है।

एफपीजीए एफटी 2232 एच के माध्यम से गति माप लिखता है

खैर क्या। चलो अधिक या कम वास्तविक परियोजना पर अधिग्रहित कौशल को ठीक करें। बेशक, बहुत गंभीर कुछ शुरू करना अब संभव नहीं है, हर कोई पहले से ही थका हुआ है। लेकिन हमें कुछ अधिक या कम व्यावहारिक परिणाम मिलते हैं। उदाहरण के लिए, हम एफटीपीए को एफटीएनएए को एफटी 2232 एच चिप के माध्यम से डेटा को किस अधिकतम गति से स्थानांतरित कर सकते हैं। वहां प्रोटोकॉल सबसे आसान नहीं है, इसलिए हमने इसे दोनों तरफ से प्रसारित नहीं किया, लेकिन खुद को हमें चैनल से प्रसारित करने के लिए प्रतिबंधित कर दिया, जिसके दूसरे छोर पर FPGA स्थापित है। दस्तावेज़ AN_130 FT2232H एक FT245 शैली तुल्यकालिक फीफो मोड में इस्तेमाल किया जाता है , इससे हमें मदद मिलेगी, क्योंकि कॉम्प्लेक्स में नियंत्रक इस मोड (सिंक्रोनस फीफो) में ठीक चालू होता है। इस दस्तावेज़ में निष्कर्ष का विवरण भी शामिल है, जिस रूप में वे इस मोड में उपयोग किए जाते हैं, और समय आरेख, और यहां तक ​​कि कोड उदाहरण भी हैं, जिनसे हम प्रेरणा लेंगे।

So. हम नियंत्रक का उपयोग करके फीफो में रिकॉर्ड करना चाहते हैं। हमारे पास क्या आएगा? मैंने कोशिश की, मुझे पता है। इसमें 1 किलोबाइट डेटा लगेगा, जिसके बाद कंट्रोलर हैंग हो जाएगा। वह अतिरिक्त डेटा को स्वीकार करने से इनकार कर देगा। बात यह है कि एक किलोबाइट इसके आंतरिक बफर का आकार है। जबकि यह संभव है, डेटा USB से लिया जाएगा और इस स्थान पर संग्रहीत किया जाएगा। लेकिन उन्हें सिंक्रोनस चैनल पर जाने के लिए, उन्हें प्राप्त करने के लिए तत्परता के बारे में सूचित करना चाहिए। हम इसी makeshift को देखते हैं।



So. जब FIFO में नियंत्रक के पास कोई डेटा होता है, तो वह RXF सिग्नल को छोड़ देता है। इसके जवाब में, हमें पहले OE सिग्नल को ड्रॉप करना होगा और इसे कम से कम एक घड़ी चक्र के लिए शून्य पर रखना होगा (यह विवरण से आरेख से अधिक इस प्रकार है कि चित्र से ही)। हमें बस में डेटा दिया जाएगा, हमें कम आरडी सिग्नल स्तर के साथ उनके स्वागत की पुष्टि करनी चाहिए। और इसलिए - पूरे फ्रेम के लिए। जब नियंत्रक RXF लाइन को उठाता है, तो हमें OE और RD को हटाना होगा। हम आज डेटा का उपयोग नहीं करेंगे। गति मापने के लिए, FPGA पर FT2232H से डेटा प्राप्त करने का अनुकरण करें। तो ठीक है। इस तरह के एक सरल ऑपरेशन के लिए, किसी प्रोसेसर सिस्टम की आवश्यकता नहीं है। यह एक पतित ऑटोमेटन बनाने के लिए पर्याप्त है, जिसके विकास में प्रोसेसर की तैयारी और इसके लिए कार्यक्रम के साथ उपद्रव करने की तुलना में बहुत कम समय लगेगा। इसलिए, हम निम्नलिखित सामग्री के साथ केवल एक SystemVerilog फ़ाइल युक्त एक प्रोजेक्ट बनाते हैं:

 module JustRead( input logic clk, input logic rxf_n, output logic oe_n, output logic rd_n ); enum {IDLE,TRANSFER} state = IDLE; always @ (posedge clk) begin oe_n <= 1; rd_n <= 1; case (state) IDLE: begin if (rxf_n == 0) begin oe_n <= 0; state <= TRANSFER; end end TRANSFER: begin if (rxf_n == 0) begin oe_n <= 0; rd_n <= 0; end else begin state <= IDLE; end end endcase end endmodule 

मशीन में दो राज्य हैं। इस मामले में, ओई सिग्नल की अवधि इस तथ्य से निर्धारित होती है कि यह घड़ी की नब्ज के तुरंत बाद लता है और अगले तक आयोजित किया जाता है। यह निम्नलिखित मॉडल का उपयोग करके सत्यापित किया जा सकता है:

 module JustReadTB( output logic clk, output logic rxf_n, input logic oe_n, input logic rd_n ); JustRead dut ( .clk, .rxf_n, .oe_n, .rd_n ); always begin clk = 1; #16; clk = 0; #16; end initial begin rxf_n = 1; #120; rxf_n = 0; #120; rxf_n = 1; end endmodule 

मैंने जो समय लिया वह पहले उपलब्ध है, यह स्विच का अनुक्रम है जो घड़ी सिग्नल से जुड़ा हुआ है जो महत्वपूर्ण है। हम निम्नलिखित समय आरेख प्राप्त करते हैं:



पहले सन्निकटन में, यह दस्तावेज की आवश्यकता के अनुरूप है। लेकिन हम वास्तविक डेटा को वैसे भी प्रोसेस नहीं करेंगे।

इस परियोजना में FPGA पैरों का असाइनमेंट भी तालिका के माध्यम से संपादन के लिए कठिनाइयों का कारण नहीं बनता है (* .QSF फ़ाइल से असाइनमेंट ट्रांसफर करने में अधिक समय लगेगा, और मैं लगातार इस बात पर जोर देता हूं कि रेड के लिए एक दिवसीय सिस्टम विकसित करते समय, समय की बचत एक प्राथमिकता है)।



हम इकट्ठा करते हैं, इसे भरते हैं, कॉम्प्लेक्स की शक्ति को बंद करने से पहले, आप कार्यक्रम के साथ काम कर सकते हैं, यह अब बफर ओवरफ्लो होने के बाद लटकाएगा नहीं।

कार्यक्रम में, मैंने दो कार्य किए। पहले डिवाइस को खोजता है और खोलता है। मैंने पिछले परीक्षण से कुछ लिया, मैंने AN130 से कुछ उधार लिया:

 FT_HANDLE OpenFT2232H() { FT_HANDLE ftHandle0; static FT_DEVICE ftDevice; //      int nDevice = 0; while (true) { //     if (FT_Open(nDevice, &ftHandle0) != FT_OK) { //  ,      return 0; } //     ? if (FT_GetDeviceInfo(ftHandle0, &ftDevice, NULL, NULL, NULL, NULL) == FT_OK) { // ,    if (ftDevice == FT_DEVICE_2232H) { // ,     AN130 FT_SetBitMode(ftHandle0, 0xff, 0x00); usleep(1000000); //Sync FIFO mode FT_SetBitMode(ftHandle0, 0xff, 0x40); FT_SetLatencyTimer(ftHandle0, 2); FT_SetUSBParameters(ftHandle0, maxBlockSize, maxBlockSize); return ftHandle0; } } //    FT_Close(ftHandle0); //    nDevice += 1; } } 

विंडोज के एक प्रशंसक के रूप में, मुझे गति माप फ़ंक्शन लिखना पड़ा, लगातार इंटरनेट की जांच करना, क्योंकि मैं आमतौर पर Win32 एपीआई से क्लासिक उच्च-रिज़ॉल्यूशन टाइमर का उपयोग करता हूं। शायद आप अधिक कुशलता से लिख सकते हैं, लेकिन यह एक दिन का कार्यक्रम है।

 const int maxBlockSize = 0x100000; uint8_t buf[maxBlockSize]; … //   BlockSize ,  1 double TestSpeed(FT_HANDLE ftHandle0,int totalSize, int blockSize) { if (blockSize > maxBlockSize) { return -1; } DWORD dwWrittenTotal = 0; timespec before; clock_gettime(CLOCK_REALTIME, &before); for (int i = 0; i < totalSize; i += blockSize) { DWORD dwWritten; FT_Write(ftHandle0, buf, blockSize, &dwWritten); //     dwWrittenTotal += dwWritten; } timespec after; clock_gettime(CLOCK_REALTIME, &after); if (dwWrittenTotal < (DWORD)totalSize) { return -2; } //     uint64_t nsBefore = before.tv_nsec; uint64_t nsAfter = after.tv_nsec; //      nsAfter += (after.tv_sec - before.tv_sec) * 1000000000; //   nsAfter -= nsBefore; //      double res = ((double)nsAfter)/((double)1000000000); //   -    return ((double)dwWrittenTotal) / res; } 

खैर, बुनियादी कार्यक्षमता करने वाला कोड इस तरह निकला:

 int main(int argc, char* argv[]) { FT_HANDLE ftHandle0 = OpenFT2232H(); if (ftHandle0 == 0) { printf("Cannot open device\n"); return -1; } const int totalSize = 0x100000; static const int blockSizes[] = { 0x10,0x20,0x40,0x80,0x100,0x200,0x400,0x800,0x1000,0x2000, 0x4000,0x8000,0x10000,0x20000,0x40000,0x80000,0 }; for (int i = 0; blockSizes[i] != 0; i++) { double speed = TestSpeed(ftHandle0, totalSize, blockSizes[i]); printf("%d,%d\n", blockSizes[i], (int)(speed/1000.)); int stop = 0; } // ,    FT_Close(ftHandle0); return 0; } 

मुझे पता है कि यूएसबी में, गति दृढ़ता से भेजे जाने वाले ब्लॉक के आकार पर निर्भर करती है, इसलिए मैं विभिन्न विकल्पों के लिए गति की जांच करता हूं। रैखिक संसेचन की शायद ही जरूरत होती है। मैंने केवल विशिष्ट आकारों की एक सूची तैयार की है। मैं प्रति सेकंड किलोबाइट में डेटा आउटपुट करता हूं। बाइट्स आंखों के लिए असुविधाजनक होते हैं, मेगाबाइट में छोटे ब्लॉक आकार के साथ कम रिज़ॉल्यूशन होता है। प्रति सेकंड किलोबाइट एक उचित समझौता है। हमें निम्न परिणाम मिलते हैं:

 16,59 32,110 64,237 128,490 256,932 512,1974 1024,3760 2048,5594 4096,10729 8192,16109 16384,20170 32768,24248 65536,26664 131072,28583 262144,29370 524288,29832 

हम उन्हें एक .csv फ़ाइल में सहेजते हैं, उन्हें एक्सेल में लोड करते हैं, गति बनाम ब्लॉक आकार के ग्राफ का निर्माण करते हैं।



सीमा 30 मेगाबाइट प्रति सेकंड है। सैद्धांतिक रूप से अधिकतम 52 एमबी / एस तक। शायद आप किसी तरह से तेजी ला सकते हैं, लेकिन इसे व्यावहारिक कार्य के रूप में पाठकों पर छोड़ दें। मुख्य बात यह है कि हमने चैनल के साथ काम करने के सभी चरणों में महारत हासिल कर ली है और FPGA को केंद्रीय प्रोसेसर के साथ एकल प्रणाली में जोड़ने के लिए तैयार हैं।

जब लेख संकलित किया जा रहा था, तो दस्तावेज़ AN_165 पाया गया था, जिसमें कहा गया था कि तुल्यकालिक फीफो मोड में अधिकतम गति 35 एमबी / एस थी। यही है, वृद्धि के लिए जगह - एक दिए गए आकार तक। लेकिन यह अभी भी वहाँ है।

निष्कर्ष

हम रेड कॉम्प्लेक्स के केंद्रीय प्रोसेसर (माइक्रोसॉफ्ट विज़ुअल स्टूडियो टूल्स का उपयोग करके और लिनक्स ओएस के साथ एक वर्चुअल मशीन पर) निष्पादित प्रोग्राम कोड के विकास और डिबगिंग के लिए दो रणनीतियों से परिचित हुए। हमने चैनल के साथ काम करने में व्यावहारिक कौशल भी प्राप्त किया जिसके माध्यम से कॉम्प्लेक्स का केंद्रीय प्रोसेसर एफपीजीए के साथ संचार करता है।

जाहिर है, अब कुछ भी हमें सीपीयू से FPGA और इसके विपरीत (हालांकि पिछले लेख में मैंने इन शब्दों को लिखा था) में सार्थक डेटा संचारित करने से रोकता है।

FPGAs के लिए सबसे सरल "फर्मवेयर" और एक प्रोग्राम जिसमें यूएसबी पर लिखने की गति को मापने वाले एक उदाहरण को डाउनलोड किया जा सकता है ।