FPGA का उपयोग कर वास्तविक समय बढ़त का पता लगाने

परिचय

हमारी परियोजना एक OV7670 कैमरे से छवि फ्रेम को कैप्चर करने और एक ग्रेस्केल फिल्टर और सोबेल ऑपरेटर को लागू करने के बाद वीजीए मॉनिटर पर स्ट्रीमिंग करने के आधार पर एक वास्तविक समय के किनारे का पता लगाने वाली प्रणाली को लागू करती है। हमारा डिज़ाइन एक चक्रवात IV FPGA बोर्ड पर बनाया गया है जो हमें निम्न-स्तरीय हार्डवेयर और समानांतर गणनाओं की शक्तिशाली विशेषताओं का उपयोग करके प्रदर्शन को अनुकूलित करने में सक्षम बनाता है जो वास्तविक समय प्रणाली की आवश्यकताओं को पूरा करने के लिए महत्वपूर्ण है।

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

आर्किटेक्चर

हमारे डिजाइन को 3 मुख्य भागों में विभाजित किया गया है:

1. कैमरे से डेटा पिक्सल पढ़ना।
2. हमारे एज डिटेक्शन एल्गोरिदम (ग्रेस्केल कनवर्टर और सोबेल ऑपरेटर) को लागू करना।
3. एक वीजीए मॉनिटर के साथ इंटरफेस करके अंतिम छवि प्रदर्शित करना।

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

ध्यान दें कि हमने कैमरे से पिक्सेल लेने के बाद, हमने इसे सीधे इंटरमीडिएट मेमोरी बफर में स्टोर नहीं किया। इसके बजाय, हमने इसे ग्रेस्केल में बदल दिया, फिर हमने इसे बफर में संग्रहीत किया। ऐसा इसलिए है क्योंकि 8-बिट ग्रेस्केल पिक्सल को स्टोर करने से रंगीन पिक्सल को स्टोर करने की तुलना में कम मेमोरी लगती है जो कि 16-बिट्स हैं। इसके अलावा, हमारे पास एक और बफर है जो डेटा को स्टोर करता है सोबल ऑपरेटर को मॉनिटर पर प्रदर्शित करने के लिए तैयार करने के लिए आवेदन करने के बाद।

यहाँ हमारी वास्तुकला के कार्यान्वयन के बारे में विवरण हैं:

कैमरा

हमने OV7670 कैमरा का उपयोग किया जो कि सबसे सस्ते कैमरा मॉड्यूल में से एक है जो हमें मिला। साथ ही, यह कैमरा 3.3V पर काम कर सकता है और छवि के डेटा को निकालने के लिए I2c या SPI जैसे मुश्किल संचार प्रोटोकॉल की आवश्यकता नहीं है। इसके लिए केवल SCCB इंटरफ़ेस की आवश्यकता होती है जो रंग प्रारूप (RGB565, RGB555, YUV, YCbCr 4: 2: 2), रिज़ॉल्यूशन (VGA, QVGA, QQVGA, CIF, QCIF) के रूप में कैमरे के कॉन्फ़िगरेशन को सेट करने के लिए I2c इंटरफ़ेस के समान है। और कई अन्य सेटिंग्स।

वीडियो में फ़्रेम होते हैं जो एक विशिष्ट दर पर बदले जा रहे हैं। एक फ्रेम एक छवि है जिसमें पिक्सेल की पंक्तियाँ और स्तंभ होते हैं जहाँ प्रत्येक पिक्सेल को रंग मानों द्वारा दर्शाया जाता है। इस परियोजना में, हमने कैमरे के डिफ़ॉल्ट कॉन्फ़िगरेशन का उपयोग किया जहां फ्रेम का आकार वीजीए रिज़ॉल्यूशन 640 x 480 (0.3 मेगापिक्सेल) है, और पिक्सेल का रंग प्रारूप RGB565 (लाल रंग के लिए 5 बिट्स, नीले रंग के लिए 6 बिट्स, ग्रीन के लिए 5 बिट्स) ) और फ्रेम बदलने की दर 30 एफपीएस है।

नीचे, GPIO का उपयोग कर FPGA के लिए कैमरे के कनेक्शन जो विकास बोर्ड में मौजूद हैं:

ध्यान दें कि हमने कॉन्फ़िगरेशन के लिए SCCB इंटरफ़ेस का उपयोग नहीं किया है। इसलिए, हम किसी भी फ्लोटिंग सिग्नल को रोकने के लिए अपने संबंधित तारों को जमीन पर रख देते हैं जो डेटा को प्रभावित कर सकते हैं।

कैमरे के लिए 25 मेगाहर्ट्ज घड़ी प्रदान करने के लिए हमने फेज-लॉक्ड लूप (पीएलएल) का उपयोग किया, जो बोर्ड से प्रदान की गई 50 मेगाहर्ट्ज से आवश्यक घड़ी प्रदान करने के लिए एक बंद लूप आवृत्ति-नियंत्रण प्रणाली है। पीएलएल को लागू करने के लिए, हमने क्वार्टस सॉफ्टवेयर के अंदर आंतरिक आईपी कैटलॉग टूल का उपयोग किया।

यह कैमरा फ्रेम की भेजने की प्रक्रिया को नियंत्रित करने के लिए ऊर्ध्वाधर सिंक्रनाइज़ेशन (VSYNC) सिग्नल का उपयोग करता है और फ्रेम की प्रत्येक पंक्ति को भेजने के लिए क्षैतिज सिंक्रनाइज़ेशन (HREF) सिग्नल को नियंत्रित करता है। यह कैमरा बिट्स को स्थानांतरित करने के लिए केवल 8 लाइनों के डेटा (D0-D7) का उपयोग करता है जो पिक्सेल के रंग मूल्यों का प्रतिनिधित्व करते हैं क्योंकि कैमरा 16-बिट RGB पिक्सेल मान को 2 (8-बिट) भागों में विभाजित करता है और प्रत्येक को अलग-अलग भेजता है।

OV7670 कैमरा मॉड्यूल के डेटा पत्रक से नीचे के आंकड़े ऊर्ध्वाधर और क्षैतिज तुल्यकालन के संकेतों को दर्शाते हैं।

ग्रेस्केल कनवर्टर

अपनी मूल रंगीन छवि से एक ग्रेस्केल छवि बनाने के लिए, कई कारकों को ध्यान में रखा जाना चाहिए, क्योंकि छवि विपरीत, तीक्ष्णता, छाया और संरचना खो सकती है। इसके अलावा, छवि को रंग स्थान के सापेक्ष चमक को संरक्षित करना चाहिए। रंगीन छवि को ग्रेस्केल में बदलने के लिए कई रैखिक और गैर-रैखिक तकनीकों का उपयोग किया जाता है। तदनुसार, अपने उद्देश्य को प्राप्त करने के लिए हमने वर्णक्रमीय (अवधारणात्मक ल्यूमिनेंस-संरक्षण) रूपांतरण को निम्नलिखित समीकरण में दर्शाए गए ग्रेस्केल में उपयोग किया:

अभिकलन के संदर्भ में प्रदर्शन को बढ़ाने के लिए, शिफ्ट ऑपरेटर का उपयोग करना तेज़ है। इसलिए, उपरोक्त समीकरण को निम्न तक घटाया जा सकता है:

परिणामस्वरूप, कैमरे से (565 RGB) पिक्सेल मान कैप्चर करने के बाद, इसे तुरंत रूपांतरण के सूत्र को लागू करने वाले 8-बिट ग्रेस्केल पिक्सेल मूल्य में परिवर्तित किया जा सकता है। Grayscaled छवि मेमोरी में संग्रहीत करने के लिए आसान है और हमारे वास्तविक समय प्रणाली की कार्यक्षमता की सेवा करने के लिए पर्याप्त रूप से तेज़ है क्योंकि इसकी जटिलता लगभग लघुगणकीय है और FPGA समानांतर में मेमोरी तक पहुंचकर इसे और भी तेज़ बना सकती है। उसके बाद, किनारे की पहचान एल्गोरिथ्म को लागू करने के लिए संग्रहीत छवि तैयार है।

इंटरमीडिएट मेमोरी (बफर)

हमारे पास 2 बफ़र हैं, पहले एक का उपयोग पिक्सल्स को ग्रेस्केल और उसके आकार में परिवर्तित करने के बाद स्टोर करने के लिए किया जाता है (8-बिट x 150 x 150) और दूसरे का उपयोग सोबेल ऑपरेटर और थ्रेशोल्ड के लिए पिक्सल को स्टोर करने के लिए किया जाता है। आउटपुट मान और इसका आकार (1-बिट x 150 x 150)। दुर्भाग्य से, 150 x 150 बफ़र्स कैमरे से पूरी छवि को संग्रहीत नहीं करते हैं, लेकिन इसका केवल एक हिस्सा संग्रहीत करते हैं।

हमने चक्रवात IV मेमोरी की सीमा के कारण अपने बफ़र्स का आकार 150 x 150 के रूप में चुना है क्योंकि इसमें केवल 276.480 Kbit है जबकि हमारे दो बफ़र 202.500 Kbit (150 x 150 x 9) लेते हैं जो मूल मेमोरी से 73.2% के बराबर है चक्रवात IV और शेष मेमोरी का उपयोग एल्गोरिथ्म और वास्तुकला के भंडारण के लिए किया जाता है। इसके अलावा, हमने अपने बफ़र्स के लिए एक आकार के रूप में (170 x 170) की कोशिश की, जो मेमोरी से 94.07% लेता है जो एल्गोरिथ्म को लागू करने के लिए पर्याप्त स्थान नहीं छोड़ता है।

हमारे बफ़र ट्रू ड्यूल-पोर्ट रैम हैं जो एक साथ विभिन्न घड़ी चक्रों में पढ़ और लिख सकते हैं। यहाँ, हमने कार्यान्वयन में अधिक लचीलापन होने के लिए क्वार्टस सॉफ़्टवेयर के अंदर आईपी कैटलॉग टूल का उपयोग करने के बजाय अपना कार्यान्वयन बनाया। इसके अलावा, हमने अलग-अलग मॉड्यूल रखने के बजाय दोनों बफ़र्स को केवल एक ही मॉड्यूल में एकीकृत किया।

सोबेल ऑपरेटर

हमने पहले व्युत्पन्न बढ़त का पता लगाने वाले ऑपरेटर का इस्तेमाल किया, जो एक मैट्रिक्स एरिया ग्रेडिएंट ऑपरेटर है जो विभिन्न पिक्सल के बीच ल्यूमिनेन्स के परिवर्तन को निर्धारित करता है। अधिक सटीक होने के लिए, क्योंकि यह मेमोरी उपयोग और समय जटिलता के संदर्भ में एक सीधा और कुशल तरीका है, हमने सोबेल ग्रेडिएंट ऑपरेटर का इस्तेमाल किया जो किनारे की ताकत का प्रतिनिधित्व करने के लिए चुने गए पिक्सेल पर केंद्रित 3x3 कर्नेल का उपयोग करता है। सोबेल ऑपरेटर द्वारा गणना की गई ढाल का परिमाण है:

जहां Gx और Gy को कनवल्शन मास्क का उपयोग करके दिखाया जा सकता है:

ध्यान दें कि मास्क के केंद्र के करीब पिक्सल को अधिक वजन दिया जाता है। इसके अलावा, जी _एक्स और जी _{वाई की} गणना निम्नानुसार की जा सकती है:

जहाँ p _i निम्न सरणी में संबंधित पिक्सेल है, और p _i का मान 8-बिट ग्रेस्केल मान है:

पूर्ण मूल्यों द्वारा सोबेल ऑपरेटर के ढाल परिमाण को अनुमानित करना एक आम बात है:

इस अनुमान को लागू करना आसान है और यह गणना करने के लिए तेज़ है कि समय और स्मृति के मामले में फिर से हमारी कार्यक्षमता क्या है।

यहाँ Sobel ऑपरेटर का ब्लॉक आरेख है जो इनपुट के रूप में 9 (8-बिट) पिक्सेल लेता है और पिक्सेल मूल्य (8 बिट) का उत्पादन करता है:

और यहाँ Sobel ऑपरेटर कार्यान्वयन का विस्तृत ब्लॉक आरेख है।

Vga मॉनिटर

हमारे विकास बोर्ड में एक अंतर्निहित वीजीए इंटरफ़ेस है जो वीजीए मॉनिटर पर केवल 8 रंगों को प्रदर्शित करने की क्षमता रखता है क्योंकि इसमें लाल रंग के लिए एक बिट के माध्यम से, हरे रंग के लिए एक और नीले रंग के लिए केवल 3-बिट्स हैं। इसने हमारे डिबगिंग को कठिन बना दिया है क्योंकि यह हमें कैमरे से छवि को सीधे मॉनिटर में प्रदर्शित करने से रोकता है। इसलिए, हमने पिक्सेल को 1-बिट मान में बदलने के लिए एक सीमा का उपयोग किया है ताकि छवि प्रदर्शित करना संभव हो।

वीजीए इंटरफेस कैमरे की तरह काम करता है क्योंकि यह ऊपरी-बाएँ कोने से निचले-दाएं कोने तक पिक्सेल द्वारा पिक्सेल संचालित करता है। ऊर्ध्वाधर और क्षैतिज तुल्यकालन का उपयोग करते हुए, हम उन संकेतों को सिंक्रनाइज़ कर सकते हैं जो पिक्सेल के प्रवाह को नियंत्रित करते हैं।

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

हमने मानक वीजीए सिग्नल इंटरफ़ेस (640 x 480 @ 60 मेगाहर्ट्ज) का उपयोग किया। सिग्नल के सभी मानक विनिर्देश यहां वर्णित हैं ।

परीक्षण

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

अजगर कोड जिसका हमने उपयोग किया:

# This code is made to test the accuracy of our algorithm on FPGA import cv2 #import opencv library f = open("sample.txt",'w') # Open file to write on it the static image initialization lines img = cv2.imread('us.jpg') # Read the image which has our faces and its size 150x150 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #convert to grayscale sobelx = cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=3) #x-axis sobel operator sobely = cv2.Sobel(gray,cv2.CV_64F,0,1,ksize=3) #y-axis sobel operator abs_grad_x = cv2.convertScaleAbs(sobelx) abs_grad_y = cv2.convertScaleAbs(sobely) grad = abs_grad_x + abs_grad_y for i in range(0,150): for x in range(0,150): #read the pixels of the grayscaled image and Store them into file with specific format to initialize the buffer in FPGA code f.write("data_a[{:d}]<=8'd{:d};\n".format(i*150+x,gray[i][x])) #apply threshold to be exactly like the code on FPGA if(grad[i][x] < 100): grad[i][x] = 255 else: grad[i][x] = 0 cv2.imshow("rgb", img) #Show the real img cv2.imshow("gray",gray) #Show the grayscale img cv2.imshow("sobel",grad)#Show the result img cv2.waitKey(0) #Stop the img to see it 

परिणाम

हमारे कार्यान्वयन के परिणामस्वरूप, हमें एक वास्तविक समय का पता लगाने वाला सिस्टम मिला जो ग्रेस्केल फिल्टर और सोबेल ऑपरेटर को लागू करने के बाद 150x150 की छवि का उत्पादन करता है। कार्यान्वित प्रणाली 30 एफपीएस प्रदान करती है। कैमरा 25MHz की घड़ी पर चलता है और सिस्टम सामान्य रूप से ध्यान देने योग्य अंतराल के बिना वास्तविक समय सीमा को पूरा करता है। इसके अलावा, सीमा मूल्य विवरण की मात्रा और अंतिम छवि में शोर को प्रभावित कर सकता है।

यहाँ FPGA पर Sobel ऑपरेटर और OpenCV sobel ऑपरेटर के बीच तुलना है:

नीचे परिणामों का एक आकर्षक वीडियो है:

यहाँ Github पर भंडार का लिंक दिया गया है जिसमें सभी स्रोत कोड हैं।

भविष्य में सुधार

जैसा कि हम FPGA चक्रवात IV का उपयोग कर रहे हैं, हम इसकी मेमोरी क्षमता और लॉजिक गेट्स की संख्या तक सीमित हैं। इसलिए, भविष्य में सुधार के रूप में, हम एक बाहरी मेमोरी स्रोत का उपयोग कर सकते हैं या हम अपने काम को दूसरे बोर्ड पर लागू कर सकते हैं ताकि हम कैमरे से प्राप्त छवि से सभी पिक्सेल प्रदर्शित कर सकें।

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

तदनुसार, हमने FPGA के अंतर्निहित VGA इंटरफ़ेस का उपयोग किया जो केवल 3-बिट्स छवि का उत्पादन कर सकता है। इस प्रकार, हम grayscaled छवि को प्रदर्शित नहीं कर सकते क्योंकि इसे प्रदर्शित करने के लिए 8 बिट की आवश्यकता होती है। नतीजतन, एक और इंटरफ़ेस लागू करना या अधिक शक्तिशाली बोर्ड का उपयोग करना छवि को प्रदर्शित करने के लचीलेपन को बढ़ाएगा।

निष्कर्ष

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

रसीद

यह परियोजना दो छात्रों से युक्त एक टीम द्वारा बनाई गई है: रूस में इनोपोलिस यूनिवर्सिटी में कंप्यूटर साइंस के पहले वर्ष में हुसैन यूनुस और हनी हैमेड ।

यह प्रोजेक्ट इनोपोलिस यूनिवर्सिटी में कंप्यूटर आर्किटेक्चर कोर्स फॉल 2018 का हिस्सा है ।