रास्पबेरी पाई और ओपनसीवी का उपयोग कर ऑटोनोमस लेन-कीपिंग कार: 7 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:20

इस निर्देश में, एक स्वायत्त लेन रखने वाला रोबोट लागू किया जाएगा और निम्नलिखित चरणों से गुजरेगा:

• भागों को इकट्ठा करना
• सॉफ़्टवेयर पूर्वापेक्षाएँ स्थापित करना
• हार्डवेयर असेंबली
• पहला टेस्ट
• ओपनसीवी का उपयोग करके लेन लाइनों का पता लगाना और मार्गदर्शक रेखा प्रदर्शित करना
• पीडी नियंत्रक को लागू करना
• परिणाम

चरण 1: घटकों को इकट्ठा करना

ऊपर दी गई छवियां इस परियोजना में उपयोग किए गए सभी घटकों को दिखाती हैं:

• आरसी कार: मुझे मेरे देश में एक स्थानीय दुकान से खदान मिली। यह 3 मोटर्स (थ्रॉटलिंग के लिए 2 और स्टीयरिंग के लिए 1) से लैस है। इस कार का मुख्य नुकसान यह है कि स्टीयरिंग "नो स्टीयरिंग" और "फुल स्टीयरिंग" के बीच सीमित है। दूसरे शब्दों में, यह सर्वो-स्टीयरिंग आरसी कारों के विपरीत, एक विशिष्ट कोण पर नहीं चल सकता है। आप यहां से विशेष रूप से रास्पबेरी पाई के लिए डिज़ाइन की गई समान कार किट पा सकते हैं।
• रास्पबेरी पाई 3 मॉडल बी+: यह कार का दिमाग है जो बहुत सारे प्रसंस्करण चरणों को संभालेगा। यह क्वाड कोर 64-बिट प्रोसेसर पर आधारित है जिसकी क्लॉक स्पीड 1.4 गीगाहर्ट्ज़ है। मुझे यहाँ से मेरा मिल गया।
• रास्पबेरी पाई 5 एमपी कैमरा मॉड्यूल: यह 1080p @ 30 एफपीएस, 720p @ 60 एफपीएस, और 640x480p 60/90 रिकॉर्डिंग का समर्थन करता है। यह सीरियल इंटरफ़ेस को भी सपोर्ट करता है जिसे सीधे रास्पबेरी पाई में प्लग किया जा सकता है। इमेज प्रोसेसिंग अनुप्रयोगों के लिए यह सबसे अच्छा विकल्प नहीं है लेकिन यह इस परियोजना के लिए पर्याप्त है और साथ ही यह बहुत सस्ता है। मुझे यहाँ से मेरा मिल गया।
• मोटर चालक: डीसी मोटर्स की दिशा और गति को नियंत्रित करने के लिए प्रयोग किया जाता है। यह 1 बोर्ड में 2 डीसी मोटर्स के नियंत्रण का समर्थन करता है और 1.5 ए का सामना कर सकता है।
• पावर बैंक (वैकल्पिक): मैंने रास्पबेरी पाई को अलग से पावर देने के लिए एक पावर बैंक (5V, 3A पर रेटेड) का उपयोग किया। 1 स्रोत से रास्पबेरी पाई को पावर देने के लिए एक स्टेप डाउन कन्वर्टर (हिरन कनवर्टर: 3A आउटपुट करंट) का उपयोग किया जाना चाहिए।
• 3s(12 V) LiPo बैटरी: लिथियम पॉलिमर बैटरी रोबोटिक्स क्षेत्र में अपने उत्कृष्ट प्रदर्शन के लिए जानी जाती है। इसका उपयोग मोटर चालक को शक्ति प्रदान करने के लिए किया जाता है। मैंने यहां से अपना खरीदा।
• नर से नर और मादा से मादा जम्पर तार।
• दो तरफा टेप: आरसी कार पर घटकों को माउंट करने के लिए उपयोग किया जाता है।
• नीला टेप: यह इस परियोजना का एक बहुत ही महत्वपूर्ण घटक है, इसका उपयोग दो लेन की लाइनें बनाने के लिए किया जाता है जिसके बीच में कार चलेगी। आप अपनी पसंद का कोई भी रंग चुन सकते हैं लेकिन मेरा सुझाव है कि आसपास के वातावरण से अलग रंग चुनें।
• ज़िप टाई और लकड़ी की सलाखों।
• पेंचकस।

चरण 2: रास्पबेरी पाई पर ओपनसीवी स्थापित करना और रिमोट डिस्प्ले सेट करना

यह कदम थोड़ा कष्टप्रद है और इसमें कुछ समय लगेगा।

OpenCV (ओपन सोर्स कंप्यूटर विजन) एक ओपन सोर्स कंप्यूटर विज़न और मशीन लर्निंग सॉफ्टवेयर लाइब्रेरी है। पुस्तकालय में 2500 से अधिक अनुकूलित एल्गोरिदम हैं। अपने रास्पबेरी पाई पर ओपनसीवी स्थापित करने के साथ-साथ रास्पबेरी पाई ओएस (यदि आपने अभी भी नहीं किया) को स्थापित करने के लिए इस बहुत ही सरल मार्गदर्शिका का पालन करें। कृपया ध्यान दें कि ओपनसीवी के निर्माण की प्रक्रिया में एक अच्छी तरह से ठंडे कमरे में लगभग 1.5 घंटे लग सकते हैं (क्योंकि प्रोसेसर का तापमान बहुत अधिक हो जाएगा!) इसलिए कुछ चाय लें और धैर्यपूर्वक प्रतीक्षा करें: डी।

रिमोट डिस्प्ले के लिए, अपने विंडोज/मैक डिवाइस से अपने रास्पबेरी पाई तक रिमोट एक्सेस सेट करने के लिए इस गाइड का भी पालन करें।

चरण 3: भागों को एक साथ जोड़ना

ऊपर दिए गए चित्र रास्पबेरी पाई, कैमरा मॉड्यूल और मोटर चालक के बीच संबंध दिखाते हैं। कृपया ध्यान दें कि जिन मोटरों का मैंने उपयोग किया है, उनमें से प्रत्येक 9 V पर 0.35 A अवशोषित करती है जो मोटर चालक के लिए एक ही समय में 3 मोटर चलाने के लिए सुरक्षित बनाती है। और चूंकि मैं 2 थ्रॉटलिंग मोटर्स की गति (1 रियर और 1 फ्रंट) को ठीक उसी तरह नियंत्रित करना चाहता हूं, इसलिए मैंने उन्हें उसी पोर्ट से जोड़ा। मैंने डबल टेप का उपयोग करके मोटर चालक को कार के दाहिनी ओर घुमाया। कैमरा मॉड्यूल के लिए, मैंने स्क्रू होल के बीच एक ज़िप टाई डाली, जैसा कि ऊपर की छवि में दिखाया गया है। फिर, मैं कैमरे को लकड़ी की पट्टी में फिट करता हूं ताकि मैं कैमरे की स्थिति को अपनी इच्छानुसार समायोजित कर सकूं। जितना हो सके कार के बीच में कैमरा लगाने की कोशिश करें। मैं कैमरे को जमीन से कम से कम 20 सेमी ऊपर रखने की सलाह देता हूं ताकि कार के सामने देखने का क्षेत्र बेहतर हो जाए। फ्रिट्ज़िंग योजनाबद्ध नीचे संलग्न है।

चरण 4: पहला टेस्ट

कैमरा परीक्षण:

एक बार कैमरा स्थापित हो जाने और ओपनसीवी लाइब्रेरी बनने के बाद, यह हमारी पहली छवि का परीक्षण करने का समय है! हम पीआई कैम से एक फोटो लेंगे और इसे "ओरिजिनल.जेपीजी" के रूप में सेव करेंगे। इसे 2 तरीकों से किया जा सकता है:

1. टर्मिनल कमांड का उपयोग करना:

एक नई टर्मिनल विंडो खोलें और निम्न कमांड टाइप करें:

रास्पिस्टिल -ओ ओरिजिनल.jpg

यह एक स्थिर छवि लेगा और इसे "/pi/original.jpg" निर्देशिका में सहेज लेगा।

2. किसी भी पायथन आईडीई का उपयोग करना (मैं आईडीएलई का उपयोग करता हूं):

एक नया स्केच खोलें और निम्नलिखित कोड लिखें:

आयात cv2

video = cv2. VideoCapture(0) जबकि ट्रू: ret, फ्रेम = video.read () फ्रेम = cv2.flip (फ्रेम, -1) # इमेज को लंबवत रूप से फ्लिप करने के लिए उपयोग किया जाता है cv2.imshow ('ओरिजिनल', फ्रेम) cv2. imwrite('origin.jpg', फ्रेम) key = cv2.waitKey(1) if key == 27: ब्रेक video.release() cv2.destroyAllWindows()

आइए देखें कि इस कोड में क्या हुआ। पहली पंक्ति हमारे सभी कार्यों का उपयोग करने के लिए हमारे ओपनसीवी पुस्तकालय को आयात कर रही है। वीडियो कैप्चर (0) फ़ंक्शन इस फ़ंक्शन द्वारा निर्धारित स्रोत से एक लाइव वीडियो स्ट्रीमिंग शुरू करता है, इस मामले में यह 0 है जिसका अर्थ है रास्पि कैमरा। यदि आपके पास कई कैमरे हैं, तो अलग-अलग नंबर लगाए जाने चाहिए। video.read() कैमरे से आने वाले प्रत्येक फ्रेम को पढ़ेगा और इसे "फ्रेम" नामक एक चर में सहेजेगा। फ्लिप() फ़ंक्शन छवि को वाई-अक्ष (लंबवत) के संबंध में फ़्लिप करेगा क्योंकि मैं अपने कैमरे को उलटा कर रहा हूं। imshow() हमारे फ्रेम को "ऑरिजिनल" शब्द के साथ प्रदर्शित करेगा और imwrite() हमारी फोटो को ओरिजिनल-j.webp

मैं ओपनसीवी कार्यों से परिचित होने के लिए दूसरी विधि के साथ आपकी तस्वीर का परीक्षण करने की सलाह देता हूं। छवि "/pi/original.jpg" निर्देशिका में सहेजी गई है। मेरे कैमरे द्वारा ली गई मूल तस्वीर ऊपर दिखाई गई है।

परीक्षण मोटर्स:

प्रत्येक मोटर के घूर्णन की दिशा निर्धारित करने के लिए यह कदम आवश्यक है। सबसे पहले, आइए मोटर चालक के कार्य सिद्धांत पर एक संक्षिप्त परिचय दें। ऊपर की छवि मोटर चालक को पिन-आउट दिखाती है। सक्षम ए, इनपुट 1 और इनपुट 2 मोटर ए नियंत्रण से जुड़े हैं। सक्षम बी, इनपुट 3 और इनपुट 4 मोटर बी नियंत्रण से जुड़े हैं। दिशा नियंत्रण "इनपुट" भाग द्वारा स्थापित किया जाता है और गति नियंत्रण "सक्षम" भाग द्वारा स्थापित किया जाता है। उदाहरण के लिए मोटर ए की दिशा को नियंत्रित करने के लिए, इनपुट 1 को उच्च पर सेट करें (इस मामले में 3.3 वी क्योंकि हम रास्पबेरी पाई का उपयोग कर रहे हैं) और इनपुट 2 को कम पर सेट करें, मोटर एक विशिष्ट दिशा में घूमेगा और विपरीत मान सेट करके इनपुट 1 और इनपुट 2 के लिए, मोटर विपरीत दिशा में घूमेगी। यदि इनपुट 1 = इनपुट 2 = (उच्च या निम्न), मोटर चालू नहीं होगा। पिन सक्षम करें रास्पबेरी (0 से 3.3 वी) से पल्स चौड़ाई मॉड्यूलेशन (पीडब्लूएम) इनपुट सिग्नल लें और तदनुसार मोटर चलाएं। उदाहरण के लिए, 100% PWM सिग्नल का मतलब है कि हम अधिकतम गति पर काम कर रहे हैं और 0% PWM सिग्नल का मतलब है कि मोटर घूम नहीं रही है। निम्नलिखित कोड का उपयोग मोटर्स की दिशा निर्धारित करने और उनकी गति का परीक्षण करने के लिए किया जाता है।

आयात समय

RPIO. GPIO को GPIO के रूप में आयात करें। 23 # फिजिकल पिन 16 इन4 = 24 # फिजिकल पिन 18 GPIO.setmode(GPIO. BCM) # फिजिकल नंबरिंग के बजाय GPIO नंबरिंग का उपयोग करें GPIO.setup(in1, GPIO.out) GPIO.setup(in2, GPIO.out) GPIO। सेटअप(in3, GPIO.out) GPIO.setup(in4, GPIO.out) GPIO.setup(throttle_enable, GPIO.out) GPIO.setup(steering_enable, GPIO.out) # स्टीयरिंग मोटर कंट्रोल GPIO.output(in1, GPIO. हाई) GPIO.output(in2, GPIO. LOW) स्टीयरिंग = GPIO. PWM (स्टीयरिंग_इनेबल, 1000) # स्विचिंग फ्रीक्वेंसी को 1000 हर्ट्ज पर सेट करें।.output(in4, GPIO. LOW) थ्रॉटल = GPIO. PWM(throttle_enable, 1000) # स्विचिंग फ्रीक्वेंसी को 1000 Hz थ्रॉटल पर सेट करें। % PWM सिग्नल-> (0.25 * बैटरी वोल्टेज) - ड्राइवर का लॉस स्टीयरिंग।स्टार्ट (100) # 100% पीडब्लूएम सिग्नल पर मोटर शुरू करता है-> (1 * बैटरी वोल्टेज) - चालक के नुकसान का समय। नींद (3) थ्रॉटल। स्टॉप () स्टीयरिंग। स्टॉप ()

यह कोड थ्रॉटलिंग मोटर्स और स्टीयरिंग मोटर को 3 सेकंड तक चलाएगा और फिर उन्हें रोक देगा। (चालक का नुकसान) एक वाल्टमीटर का उपयोग करके निर्धारित किया जा सकता है। उदाहरण के लिए, हम जानते हैं कि 100% PWM सिग्नल को मोटर के टर्मिनल पर पूरी बैटरी का वोल्टेज देना चाहिए। लेकिन, पीडब्लूएम को १००% पर सेट करके, मैंने पाया कि ड्राइवर ३ वी ड्रॉप कर रहा है और मोटर को १२ वी के बजाय ९ वी मिल रहा है (ठीक वही जो मुझे चाहिए!)। हानि रैखिक नहीं है अर्थात 100% पर हानि 25% पर हानि से बहुत अलग है। उपरोक्त कोड चलाने के बाद, मेरे परिणाम इस प्रकार थे:

थ्रॉटलिंग परिणाम: यदि in3 = HIGH और in4 = LOW, तो थ्रॉटलिंग मोटर्स में क्लॉक-वाइज (CW) रोटेशन होगा यानी कार आगे बढ़ेगी। नहीं तो गाड़ी पीछे की ओर जाएगी।

स्टीयरिंग परिणाम: यदि in1 = HIGH और in2 = LOW, तो स्टीयरिंग मोटर अपने अधिकतम बायीं ओर मुड़ जाएगी यानी कार बाईं ओर चलेगी। नहीं तो गाड़ी सही चलेगी। कुछ प्रयोगों के बाद, मैंने पाया कि अगर पीडब्लूएम सिग्नल 100% नहीं था (यानी मोटर पूरी तरह से दाईं ओर या पूरी तरह से बाईं ओर चला जाएगा) तो स्टीयरिंग मोटर चालू नहीं होगी।

चरण 5: लेन लाइनों का पता लगाना और शीर्षक रेखा की गणना करना

इस चरण में, कार की गति को नियंत्रित करने वाले एल्गोरिथम के बारे में बताया जाएगा। पहली छवि पूरी प्रक्रिया दिखाती है। सिस्टम का इनपुट इमेज है, आउटपुट थीटा (डिग्री में स्टीयरिंग एंगल) है। ध्यान दें, प्रसंस्करण 1 छवि पर किया जाता है और सभी फ़्रेमों पर दोहराया जाएगा।

कैमरा:

कैमरा (320 x 240) रिज़ॉल्यूशन के साथ वीडियो रिकॉर्ड करना शुरू कर देगा। मैं संकल्प को कम करने की सलाह देता हूं ताकि आप बेहतर फ्रेम दर (एफपीएस) प्राप्त कर सकें क्योंकि एफपीएस ड्रॉप प्रत्येक फ्रेम में प्रसंस्करण तकनीकों को लागू करने के बाद होगा। नीचे दिया गया कोड प्रोग्राम का मुख्य लूप होगा और इस कोड पर प्रत्येक चरण को जोड़ देगा।

आयात cv2

np वीडियो के रूप में numpy आयात करें = cv2. VideoCapture(0) video.set(cv2. CAP_PROP_FRAME_WIDTH, 320) # चौड़ाई को 320 p video.set (cv2. CAP_PROP_FRAME_HEIGHT, 240) पर सेट करें # ऊंचाई को 240 p पर सेट करें # लूप जबकि सच: रिट, फ्रेम = वीडियो.रीड () फ्रेम = cv2.flip (फ्रेम, -1) cv2.imshow ("मूल", फ्रेम) कुंजी = cv2.waitKey (1) यदि कुंजी == 27: ब्रेक वीडियो। रिलीज () cv2.destroyAllWindows ()

यहां कोड चरण 4 में प्राप्त मूल छवि दिखाएगा और ऊपर की छवियों में दिखाया गया है।

HSV कलर स्पेस में कनवर्ट करें:

अब कैमरे से वीडियो रिकॉर्डिंग को फ्रेम के रूप में लेने के बाद, अगला कदम प्रत्येक फ्रेम को ह्यू, सैचुरेशन और वैल्यू (एचएसवी) कलर स्पेस में बदलना है। ऐसा करने का मुख्य लाभ उनके चमक के स्तर से रंगों के बीच अंतर करने में सक्षम होना है। और यहाँ HSV रंग स्थान की एक अच्छी व्याख्या है। HSV में कनवर्ट करना निम्नलिखित फ़ंक्शन के माध्यम से किया जाता है:

def Convert_to_HSV (फ्रेम):

hsv = cv2.cvtColor (फ़्रेम, cv2. COLOR_BGR2HSV) cv2.imshow ("HSV", hsv) रिटर्न hsv

यह फ़ंक्शन मुख्य लूप से कॉल किया जाएगा और फ़्रेम को HSV कलर स्पेस में वापस कर देगा। मेरे द्वारा HSV कलर स्पेस में प्राप्त फ्रेम ऊपर दिखाया गया है।

नीले रंग और किनारों का पता लगाएं:

छवि को HSV रंग स्थान में परिवर्तित करने के बाद, यह केवल उस रंग का पता लगाने का समय है जिसमें हम रुचि रखते हैं (अर्थात नीला रंग क्योंकि यह लेन लाइनों का रंग है)। HSV फ़्रेम से नीला रंग निकालने के लिए, रंग, संतृप्ति और मान की एक श्रेणी निर्दिष्ट की जानी चाहिए। एचएसवी मूल्यों पर एक बेहतर विचार रखने के लिए यहां देखें। कुछ प्रयोगों के बाद, नीले रंग की ऊपरी और निचली सीमाएं नीचे दिए गए कोड में दिखाई गई हैं। और प्रत्येक फ्रेम में समग्र विकृति को कम करने के लिए, किनारों का पता केवल कैनी एज डिटेक्टर का उपयोग करके लगाया जाता है। कैनी एज के बारे में अधिक यहाँ पाया जाता है। सामान्य नियम 1:2 या 1:3 के अनुपात के साथ कैनी () फ़ंक्शन के मापदंडों का चयन करना है।

def डिटेक्ट_एजेस (फ्रेम):

Low_blue = np.array([90, 120, 0], dtype = "uint8") # नीले रंग की निचली सीमा अपर_ब्लू = np.array([150, 255, 255], dtype="uint8") # की ऊपरी सीमा नीला रंग का मुखौटा = cv2.inRange (hsv, निचला_नीला, ऊपरी_नीला) # यह मुखौटा नीले रंग के अलावा सब कुछ फ़िल्टर करेगा

इस फ़ंक्शन को मुख्य लूप से भी बुलाया जाएगा जो HSV कलर स्पेस फ्रेम को एक पैरामीटर के रूप में लेता है और एज्ड फ्रेम को लौटाता है। मैंने जो किनारा फ्रेम प्राप्त किया वह ऊपर पाया गया है।

रुचि के क्षेत्र का चयन करें (आरओआई):

फ़्रेम के केवल 1 क्षेत्र पर ध्यान केंद्रित करने के लिए रुचि के क्षेत्र का चयन करना महत्वपूर्ण है। इस मामले में, मैं नहीं चाहता कि कार पर्यावरण में बहुत सी वस्तुओं को देखे। मैं बस चाहता हूं कि कार लेन लाइनों पर ध्यान केंद्रित करे और किसी और चीज को अनदेखा करे। पीएस: समन्वय प्रणाली (एक्स और वाई अक्ष) ऊपरी बाएं कोने से शुरू होती है। दूसरे शब्दों में, बिंदु (0, 0) ऊपरी बाएँ कोने से शुरू होता है। y-अक्ष ऊंचाई है और x-अक्ष चौड़ाई है। नीचे दिया गया कोड केवल फ्रेम के निचले आधे हिस्से पर ध्यान केंद्रित करने के लिए रुचि के क्षेत्र का चयन करता है।

def क्षेत्र_ऑफ_रुचि (किनारों):

ऊंचाई, चौड़ाई = किनारों। आकार # किनारों की ऊंचाई और चौड़ाई निकालें फ्रेम मुखौटा = np.zeros_like (किनारों) # किनारों के फ्रेम के समान आयामों के साथ एक खाली मैट्रिक्स बनाएं # केवल स्क्रीन के निचले आधे हिस्से पर ध्यान केंद्रित करें # के निर्देशांक निर्दिष्ट करें 4 अंक (निचले बाएं, ऊपरी बाएं, ऊपरी दाएं, निचले दाएं) बहुभुज = np.array(

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

रेखा खंडों का पता लगाएं:

एक किनारे वाले फ्रेम से लाइन सेगमेंट का पता लगाने के लिए हफ़ ट्रांसफॉर्म का उपयोग किया जाता है। हफ़ ट्रांसफॉर्म गणितीय रूप में किसी भी आकृति का पता लगाने की एक तकनीक है। यह लगभग किसी भी वस्तु का पता लगा सकता है, भले ही वह कुछ मतों के अनुसार विकृत हो। हफ़ ट्रांसफ़ॉर्म के लिए एक बढ़िया संदर्भ यहाँ दिखाया गया है। इस एप्लिकेशन के लिए, प्रत्येक फ्रेम में लाइनों का पता लगाने के लिए cv2. HoughLinesP () फ़ंक्शन का उपयोग किया जाता है। इस फ़ंक्शन द्वारा लिए जाने वाले महत्वपूर्ण पैरामीटर हैं:

cv2. HoughLinesP (फ्रेम, rho, थीटा, min_threshold, minLineLength, maxLineGap)

• फ़्रेम: वह फ़्रेम है जिसमें हम लाइनों का पता लगाना चाहते हैं।
• rho: यह पिक्सेल में दूरी की सटीकता है (आमतौर पर यह = 1 है)
• थीटा: रेडियन में कोणीय परिशुद्धता (हमेशा = np.pi/180 ~ 1 डिग्री)
• min_threshold: न्यूनतम वोट इसे एक लाइन के रूप में माना जाना चाहिए
• minLineLength: पिक्सेल में लाइन की न्यूनतम लंबाई। इस संख्या से छोटी कोई भी रेखा रेखा नहीं मानी जाती है।
• maxLineGap: 2 लाइनों के बीच पिक्सल में अधिकतम गैप को 1 लाइन माना जाएगा। (मेरे मामले में इसका उपयोग नहीं किया जाता है क्योंकि मैं जिस लेन लाइनों का उपयोग कर रहा हूं उनमें कोई अंतर नहीं है)।

यह फ़ंक्शन एक पंक्ति के अंतिम बिंदु देता है। निम्न फ़ंक्शन को मेरे मुख्य लूप से हफ़ ट्रांसफ़ॉर्म का उपयोग करके लाइनों का पता लगाने के लिए कहा जाता है:

डीईएफ़ डिटेक्ट_लाइन_सेगमेंट्स (क्रॉप्ड_एजेस):

rho = 1 थीटा = np.pi / 180 min_threshold = 10 line_segments = cv2. HoughLinesP(cropped_edges, rho, theta, min_threshold, np.array(), minLineLength=5, maxLineGap=0) रिटर्न लाइन_सेगमेंट

औसत ढलान और अवरोधन (एम, बी):

याद कीजिए कि रेखा का समीकरण y = mx + b द्वारा दिया गया है। जहाँ m रेखा का ढाल है और b y-अवरोधन है। इस भाग में, हफ़ ट्रांसफ़ॉर्म का उपयोग करके पता लगाए गए लाइन सेगमेंट के ढलानों और इंटरसेप्ट्स के औसत की गणना की जाएगी। ऐसा करने से पहले, आइए ऊपर दिखाए गए मूल फ्रेम फोटो पर एक नजर डालते हैं। बाईं लेन ऊपर की ओर जाती हुई प्रतीत होती है, इसलिए इसमें एक नकारात्मक ढलान है (समन्वय प्रणाली प्रारंभ बिंदु याद रखें?) दूसरे शब्दों में, बाईं लेन की रेखा में x1 <x2 और y2 x1 और y2> y1 है जो एक सकारात्मक ढलान देगा। तो, सकारात्मक ढलान वाली सभी रेखाओं को समकोण बिंदु माना जाता है। ऊर्ध्वाधर रेखाओं (x1 = x2) के मामले में, ढलान अनंत होगा। इस मामले में, हम त्रुटि प्राप्त करने से बचने के लिए सभी लंबवत रेखाओं को छोड़ देंगे। इस पहचान में अधिक सटीकता जोड़ने के लिए, प्रत्येक फ़्रेम को 2 सीमा रेखाओं के माध्यम से दो क्षेत्रों (दाएं और बाएं) में विभाजित किया गया है। सभी चौड़ाई बिंदु (x-अक्ष बिंदु) दाएँ सीमा रेखा से अधिक, दाएँ लेन गणना के साथ जुड़े हुए हैं। और यदि सभी चौड़ाई बिंदु बाईं सीमा रेखा से कम हैं, तो वे बाएं लेन गणना से जुड़े हैं। निम्न फ़ंक्शन प्रसंस्करण के तहत फ़्रेम लेता है और हफ़ ट्रांसफ़ॉर्म का उपयोग करके पता लगाया गया लेन खंड और औसत ढलान और दो लेन लाइनों का अवरोधन देता है।

def औसत_स्लोप_इंटरसेप्ट (फ्रेम, लाइन_सेगमेंट):

लेन_लाइन्स = अगर लाइन_सेगमेंट कोई नहीं है: प्रिंट ("कोई लाइन सेगमेंट नहीं मिला") रिटर्न लेन_लाइन की ऊंचाई, चौड़ाई, _ = फ्रेम। चौड़ाई * लाइन_सेगमेंट में लाइन_सेगमेंट के लिए सीमा: लाइन_सेगमेंट में x1, y1, x2, y2 के लिए: यदि x1 == x2: प्रिंट ("ऊर्ध्वाधर रेखाएं छोड़ना (ढलान = अनंत)") फ़िट जारी रखें = np.polyfit ((x1, x2), (y1, y2), 1) ढलान = (y2 - y1) / (x2 - x1) अवरोधन = y1 - (ढलान * x1) यदि ढलान <0: यदि x1 <बाएं_क्षेत्र_सीमा और x2 दाएं_क्षेत्र_सीमा और x2> दाएं_क्षेत्र_सीमा: दाएं_फिट। एपेंड ((ढलान, अवरोधन)) लेफ्ट_फिट_एवरेज = एनपी। औसत (बाएं_फिट, अक्ष = 0) अगर लेन (बाएं_फिट)> 0: लेन_लाइन्स। संलग्न करें (मेक_पॉइंट्स (फ्रेम, बाएं_फिट_एवरेज)) दाएं_फिट_एवरेज = एनपी। औसत (दाएं_फिट, अक्ष = 0) अगर len(right_fit) > 0: lane_lines.append(make_points(frame, right_fit_average)) # lane_lines एक 2-डी सरणी है जिसमें दाएं और बाएं लेन लाइनों के निर्देशांक शामिल हैं # उदाहरण के लिए: लैन e_lines =

make_points () औसत_स्लोप_इंटरसेप्ट () फ़ंक्शन के लिए एक सहायक फ़ंक्शन है जो लेन लाइनों के बंधे हुए निर्देशांक (नीचे से फ्रेम के मध्य तक) लौटाएगा।

def make_points (फ्रेम, लाइन):

ऊंचाई, चौड़ाई, _ = फ्रेम। आकार ढलान, अवरोधन = रेखा y1 = ऊंचाई # फ्रेम के नीचे y2 = int(y1 / 2) # फ्रेम के बीच से अंक बनाएं यदि ढलान == 0: ढलान = 0.1 x1 = int((y1 - अवरोधन) / ढलान) x2 = int((y2 - अवरोधन) / ढलान) वापसी

0 से विभाजित होने से रोकने के लिए एक शर्त प्रस्तुत की जाती है। यदि ढलान = 0 जिसका अर्थ है y1 = y2 (क्षैतिज रेखा), ढलान को 0 के पास मान दें। यह एल्गोरिथ्म के प्रदर्शन को प्रभावित नहीं करेगा और साथ ही यह असंभव मामले (0 से विभाजित) को रोकेगा।

फ़्रेम पर लेन लाइनों को प्रदर्शित करने के लिए, निम्नलिखित फ़ंक्शन का उपयोग किया जाता है:

def डिस्प्ले_लाइन्स (फ्रेम, लाइन्स, लाइन_कलर = (0, 255, 0)), लाइन_विड्थ = 6: # लाइन कलर (बी, जी, आर)

line_image = np.zeros_like(frame) यदि रेखाएँ कोई नहीं है: पंक्ति में पंक्ति के लिए: x1, y1, x2, y2 पंक्ति में: cv2.line(line_image, (x1, y1), (x2, y2), line_color, लाइन_विड्थ) लाइन_इमेज = cv2.addWeighted (फ्रेम, ०.८, लाइन_इमेज, १, १) रिटर्न लाइन_इमेज

cv2.addWeighted () फ़ंक्शन निम्नलिखित पैरामीटर लेता है और इसका उपयोग दो छवियों को संयोजित करने के लिए किया जाता है, लेकिन प्रत्येक को एक वजन देने के साथ।

cv2.addWeighted (छवि 1, अल्फा, छवि 2, बीटा, गामा)

और निम्न समीकरण का उपयोग करके आउटपुट छवि की गणना करता है:

आउटपुट = अल्फा * इमेज 1 + बीटा * इमेज 2 + गामा

cv2.addWeighted () फ़ंक्शन के बारे में अधिक जानकारी यहाँ प्राप्त की गई है।

हेडिंग लाइन की गणना और प्रदर्शन करें:

हमारे मोटरों पर गति लागू करने से पहले यह अंतिम चरण है। हेडिंग लाइन स्टीयरिंग मोटर को वह दिशा देने के लिए जिम्मेदार है जिसमें उसे घूमना चाहिए और थ्रॉटलिंग मोटर्स को वह गति देनी चाहिए जिस पर वे काम करेंगे। हेडिंग लाइन की गणना शुद्ध त्रिकोणमिति है, टैन और एटान (tan^-1) त्रिकोणमितीय कार्यों का उपयोग किया जाता है। कुछ चरम मामले तब होते हैं जब कैमरा केवल एक लेन की रेखा का पता लगाता है या जब यह किसी भी रेखा का पता नहीं लगाता है। इन सभी मामलों को निम्नलिखित फ़ंक्शन में दिखाया गया है:

def get_steering_angle (फ्रेम, lane_lines):

ऊंचाई, चौड़ाई, _ = फ्रेम। आकार अगर लेन (लेन_लाइन) == 2: # यदि दो लेन लाइनों का पता लगाया जाता है _, _, बाएं_x2, _ = लेन_लाइन [0] [0] # लेन_लाइन सरणी से बाएं x2 निकालें _, _, right_x2, _ = lane_lines[1][0] # lane_lines array से दायां x2 निकालें मध्य = int(चौड़ाई / 2) x_offset = (left_x2 + right_x2) / 2 - मध्य y_offset = int(ऊंचाई / 2) elif len(lane_lines) == 1: # यदि केवल एक पंक्ति का पता लगाया जाता है x1, _, x2, _ = lane_lines[0][0] x_offset = x2 - X1 y_offset = int(height/2) elif len(lane_lines) == 0: # यदि कोई रेखा नहीं पाई जाती है x_offset = 0 y_offset = int(height/2) angle_to_mid_radian = math.atan(x_offset / y_offset) angle_to_mid_deg = int(angle_to_mid_radian * 180.0 / math.pi) स्टीयरिंग_angle = angle_to_mid_deg + 90 रिटर्न स्टीयरिंग_एंगल

पहले मामले में x_offset औसत ((दाएं x2 + बायां x2)/2) स्क्रीन के मध्य से कितना भिन्न है। y_offset को हमेशा ऊंचाई / 2 माना जाता है। ऊपर दी गई अंतिम छवि शीर्षक रेखा का एक उदाहरण दिखाती है। angle_to_mid_radians वही "थीटा" है जो ऊपर की अंतिम छवि में दिखाया गया है। अगर स्टीयरिंग_एंगल = 90 है, तो इसका मतलब है कि कार की हेडिंग लाइन "ऊंचाई / 2" लाइन के लंबवत है और कार बिना स्टीयरिंग के आगे बढ़ेगी। यदि स्टीयरिंग_एंगल> 90 है, तो कार को दाईं ओर चलना चाहिए अन्यथा उसे बाईं ओर चलना चाहिए। हेडिंग लाइन को प्रदर्शित करने के लिए, निम्नलिखित फ़ंक्शन का उपयोग किया जाता है:

डीईएफ़ डिस्प्ले_हेडिंग_लाइन (फ्रेम, स्टीयरिंग_एंगल, लाइन_कलर = (0, 0, 255), लाइन_विड्थ = 5)

हेडिंग_इमेज = np.zeros_like(फ्रेम) ऊंचाई, चौड़ाई, _ = फ्रेम। शेप स्टीयरिंग_एंगल_रेडियन = स्टीयरिंग_एंगल / 180.0 * गणित.पीआई x1 = इंट (चौड़ाई / 2) y1 = ऊंचाई x2 = इंट (x1 - ऊंचाई / 2 / गणित। टैन (स्टीयरिंग_एंगल_रेडियन)) y2 = int(ऊंचाई / 2) cv2.line(heading_image, (x1, y1), (x2, y2), line_color, line_width) हेडिंग_इमेज = cv2.addWeighted(फ्रेम, 0.8, हेडिंग_इमेज, 1, 1) वापसी शीर्षक_छवि

ऊपर दिया गया फंक्शन उस फ्रेम को लेता है जिसमें हेडिंग लाइन को इनपुट के रूप में और स्टीयरिंग एंगल पर खींचा जाएगा। यह हेडिंग लाइन की इमेज लौटाता है। मेरे मामले में लिया गया शीर्षक रेखा फ्रेम ऊपर की छवि में दिखाया गया है।

सभी कोड को एक साथ जोड़ना:

कोड अब इकट्ठा होने के लिए तैयार है। निम्न कोड प्रत्येक फ़ंक्शन को कॉल करने वाले प्रोग्राम का मुख्य लूप दिखाता है:

आयात cv2

np वीडियो = cv2. VideoCapture(0) video.set(cv2. CAP_PROP_FRAME_WIDTH, 320) video.set(cv2. CAP_PROP_FRAME_HEIGHT, 240) के रूप में numpy आयात करें जबकि सही: ret, फ्रेम = वीडियो। पढ़ें () फ्रेम = cv2.flip (फ्रेम, -1) # फ़ंक्शन को कॉल करना एचएसवी = कन्वर्ट_टू_एचएसवी (फ्रेम) किनारों = डिटेक्ट_एजेस (एचएसवी) रोई = क्षेत्र_ऑफ_इंटरेस्ट (किनारों) लाइन_सेगमेंट = डिटेक्ट_लाइन_सेगमेंट (आरओआई) लेन_लाइन्स = एवरेज_स्लोप_इंटरसेप्ट (फ्रेम, लाइन_सेगमेंट) लेन_लाइन_इमेज = डिस्प्ले_लाइन्स (फ्रेम, लाइन_सेगमेंट) = get_steering_angle (फ्रेम, लेन_लाइन्स) हेडिंग_इमेज = डिस्प्ले_हेडिंग_लाइन (लेन_लाइन्स_इमेज, स्टीयरिंग_एंगल) कुंजी = cv2.waitKey(1) यदि कुंजी == 27: ब्रेक वीडियो.रिलीज () cv2.destroyAllWindows ()

चरण 6: पीडी नियंत्रण लागू करना

अब हमारे पास हमारा स्टीयरिंग एंगल मोटर्स को फीड करने के लिए तैयार है। जैसा कि पहले उल्लेख किया गया है, यदि स्टीयरिंग कोण 90 से अधिक है, तो कार को दाएं मुड़ना चाहिए अन्यथा इसे बाएं मुड़ना चाहिए। मैंने एक साधारण कोड लागू किया है जो स्टीयरिंग मोटर को दाएं घुमाता है यदि कोण 90 से ऊपर है और यदि स्टीयरिंग कोण 90 से कम है, तो निरंतर थ्रॉटलिंग गति (10% पीडब्लूएम) पर बाएं मुड़ता है, लेकिन मुझे बहुत सारी त्रुटियां मिलीं। मुझे मिली मुख्य त्रुटि यह है कि जब कार किसी भी मोड़ पर पहुंचती है, तो स्टीयरिंग मोटर सीधे काम करती है लेकिन थ्रॉटलिंग मोटर्स जाम हो जाती है। मैंने बारी-बारी से थ्रॉटलिंग की गति (20% PWM) बढ़ाने की कोशिश की, लेकिन रोबोट के गलियों से बाहर निकलने के साथ समाप्त हो गया। मुझे कुछ ऐसा चाहिए था जो थ्रॉटलिंग की गति को बहुत बढ़ा दे यदि स्टीयरिंग कोण बहुत बड़ा है और गति को थोड़ा बढ़ा देता है यदि स्टीयरिंग कोण इतना बड़ा नहीं है तो गति को प्रारंभिक मूल्य तक कम कर देता है क्योंकि कार 90 डिग्री (सीधी चलती) तक पहुंचती है। समाधान पीडी नियंत्रक का उपयोग करना था।

PID कंट्रोलर का मतलब आनुपातिक, इंटीग्रल और डेरिवेटिव कंट्रोलर है। रोबोटिक्स अनुप्रयोगों में इस प्रकार के रैखिक नियंत्रकों का व्यापक रूप से उपयोग किया जाता है। ऊपर दी गई छवि विशिष्ट पीआईडी फीडबैक कंट्रोल लूप दिखाती है। इस नियंत्रक का लक्ष्य "ऑन-ऑफ" नियंत्रकों के विपरीत सबसे कुशल तरीके से "सेटपॉइंट" तक पहुंचना है जो कुछ शर्तों के अनुसार संयंत्र को चालू या बंद करते हैं। कुछ कीवर्ड ज्ञात होने चाहिए:

• सेटपॉइंट: वह वांछित मूल्य है जिसे आप अपने सिस्टम तक पहुंचाना चाहते हैं।
• वास्तविक मूल्य: सेंसर द्वारा महसूस किया गया वास्तविक मूल्य है।
• त्रुटि: सेटपॉइंट और वास्तविक मान (त्रुटि = सेटपॉइंट - वास्तविक मान) के बीच का अंतर है।
• नियंत्रित चर: इसके नाम से, वह चर जिसे आप नियंत्रित करना चाहते हैं।
• केपी: आनुपातिक स्थिरांक।
• Ki: अभिन्न स्थिरांक।
• केडी: व्युत्पन्न स्थिरांक।

संक्षेप में, PID नियंत्रण प्रणाली लूप निम्नानुसार कार्य करता है:

• उपयोगकर्ता सिस्टम तक पहुंचने के लिए आवश्यक सेटपॉइंट को परिभाषित करता है।
• त्रुटि की गणना की जाती है (त्रुटि = सेटपॉइंट - वास्तविक)।
• P नियंत्रक त्रुटि के मान के समानुपाती क्रिया उत्पन्न करता है। (त्रुटि बढ़ती है, P क्रिया भी बढ़ती है)
• I नियंत्रक समय के साथ त्रुटि को एकीकृत करेगा जो सिस्टम की स्थिर स्थिति त्रुटि को समाप्त करता है लेकिन इसके ओवरशूट को बढ़ाता है।
• डी नियंत्रक त्रुटि के लिए बस समय व्युत्पन्न है। दूसरे शब्दों में, यह त्रुटि का ढलान है। यह त्रुटि के व्युत्पन्न के समानुपाती क्रिया करता है। यह नियंत्रक सिस्टम की स्थिरता को बढ़ाता है।
• नियंत्रक का आउटपुट तीन नियंत्रकों का योग होगा। यदि त्रुटि 0 हो जाती है तो नियंत्रक का आउटपुट 0 हो जाएगा।

पीआईडी नियंत्रक का एक अच्छा विवरण यहां पाया जा सकता है।

लेन कीपिंग कार में वापस जाने पर, मेरा नियंत्रित चर गति थ्रॉटलिंग था (चूंकि स्टीयरिंग में केवल दो राज्य या तो दाएं या बाएं हैं)। इस उद्देश्य के लिए एक पीडी नियंत्रक का उपयोग किया जाता है क्योंकि डी क्रिया थ्रॉटलिंग गति को बहुत बढ़ा देती है यदि त्रुटि परिवर्तन बहुत बड़ा है (यानी बड़ा विचलन) और यदि यह त्रुटि परिवर्तन 0 के करीब आता है तो कार को धीमा कर देता है। मैंने पीडी को लागू करने के लिए निम्नलिखित कदम उठाए नियंत्रक:

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

थ्रॉटलिंग मोटर्स की गति को नियंत्रित करने के लिए मुख्य लूप में निम्नलिखित कोड का उपयोग किया जाता है:

गति = 10 # ऑपरेटिंग गति% PWM. में

# प्रत्येक लूप को अद्यतन करने के लिए चर अंतिम समय = 0 अंतिम त्रुटि = 0 # पीडी स्थिरांक केपी = 0.4 केडी = केपी * 0.65 जबकि सत्य: अब = समय। समय () # वर्तमान समय चर डीटी = अब - अंतिम समय विचलन = स्टीयरिंग_एंगल - 90 # समकक्ष to angle_to_mid_deg चर त्रुटि = एब्स (विचलन) यदि विचलन -5: # 10-डिग्री त्रुटि श्रेणी विचलन = 0 त्रुटि = 0 GPIO.output (in1, GPIO. LOW) GPIO.output (in2, GPIO) होने पर न चलें. LOW) स्टीयरिंग.स्टॉप () एलिफ विचलन > 5: # यदि विचलन सकारात्मक है तो स्टीयर राइट -5: # यदि विचलन ऋणात्मक है तो बाएं स्टीयर करें। * त्रुटि पीडी = इंट (गति + व्युत्पन्न + आनुपातिक) एसपीडी = एबीएस (पीडी) अगर एसपीडी> 25: एसपीडी = 25 थ्रॉटल। स्टार्ट (एसपीडी) अंतिम त्रुटि = त्रुटि अंतिम समय = समय। समय ()

यदि त्रुटि बहुत बड़ी है (मध्य से विचलन अधिक है), आनुपातिक और व्युत्पन्न क्रियाएं उच्च होती हैं जिसके परिणामस्वरूप उच्च थ्रॉटलिंग गति होती है। जब त्रुटि 0 के करीब पहुंचती है (बीच से विचलन कम होता है), व्युत्पन्न क्रिया विपरीत रूप से कार्य करती है (ढलान नकारात्मक है) और सिस्टम की स्थिरता बनाए रखने के लिए थ्रॉटलिंग गति कम हो जाती है। पूरा कोड नीचे संलग्न है।

चरण 7: परिणाम

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

मैं इस परियोजना को बेहतर बनाने के लिए आपकी सिफारिशों को सुनने की प्रतीक्षा कर रहा हूं! जैसा कि मुझे आशा है कि यह निर्देश आपको कुछ नई जानकारी देने के लिए पर्याप्त थे।