नियंत्रण कक्ष पर GAZ-66 खिलौना। भाग २

इस भाग में हम सॉफ्टवेयर घटक के बारे में बात करेंगे, मशीन कैसे जीवन में आई। किस ओएस का इस्तेमाल किया गया, किस भाषा को चुना गया, किन समस्याओं का सामना करना पड़ा।

1. यह 2 शब्दों में कैसे काम करता है

सिस्टम में एक सर्वर होता है जो एक टाइपराइटर पर स्थापित होता है, और एक क्लाइंट कंसोल पर स्थापित होता है। सर्वर वाईफाई एक्सेस प्वाइंट को बढ़ाता है और क्लाइंट के कनेक्ट होने तक इंतजार करता है। सर्वर क्लाइंट कमांड को निष्पादित करता है, और कैमरे से वीडियो को भी प्रसारित करता है।

2. ओएस

अब बात करते हैं ऑपरेटिंग सिस्टम के इस्तेमाल की।

चूंकि पूरी प्रणाली रास्पबेरी पाई 3 पर आधारित है, इसलिए इसके लिए आधिकारिक ओएस का उपयोग किया गया था। निर्माण के समय, नवीनतम संस्करण स्ट्रेच था, यह एक टाइपराइटर और रिमोट कंट्रोल पर उपयोग के लिए चुना गया था। लेकिन यह पता चला कि इसमें एक बग (एक सप्ताह के लिए तड़पा हुआ) है, जिसके कारण वाईफाई एक्सेस प्वाइंट को उठाना असंभव है। इसलिए, एक्सेस पॉइंट को बढ़ाने के लिए, जेसी का एक पिछला संस्करण लिया गया था जिसमें ऐसी समस्याएं नहीं थीं।

लेख एक पहुंच बिंदु कैसे बढ़ाएं। बहुत विस्तृत, उस पर सब कुछ किया।

रिमोट कंट्रोल स्वचालित रूप से मशीन से जुड़ता है जब वह एक्सेस प्वाइंट बढ़ाता है।
फ़ाइल / etc / नेटवर्क / इंटरफेस जोड़ने में हमारी बात के लिए स्वचालित कनेक्शन:

auto wlan0 iface wlan0 inet dhcp wpa-ssid {ssid} wpa-psk {password} 

2. भाषा

मैंने अजगर को चुना क्योंकि यह आसान और सरल है।

3. सर्वर

इस खंड में सर्वर द्वारा मेरा मतलब होगा कि मशीन द्वारा नियंत्रित करने और वीडियो के साथ काम करने के लिए मेरे द्वारा लिखे गए सॉफ़्टवेयर।

सर्वर में 2 भाग होते हैं। वीडियो सर्वर और प्रबंधन सर्वर।

3.1 वीडियो सर्वर

वीडियो कैमरा के साथ काम करने के 2 विकल्प थे। पहला उपयोग पिकामेरा मॉड्यूल और दूसरा उपयोग mjpg-streamer सॉफ्टवेयर । दो बार सोचने के बिना, मैंने उन दोनों का उपयोग करने का फैसला किया, और जो कि कॉन्फ़िगर सेटिंग्स में उपयोग करना है।

 if conf.conf.VideoServerType == 'm' : cmd = "cd /home/pi/projects/mjpg-streamer-experimental && " cmd += './mjpg_streamer -o "./output_http.so -p {0} -w ./www" -i "./input_raspicam.so -x {1} -y {2} -fps 25 -ex auto -awb auto -vs -ISO 10"'.format(conf.conf.videoServerPort, conf.conf.VideoWidth, conf.conf.VideoHeight) print(cmd) os.system(cmd) else : with picamera.PiCamera(resolution = str(conf.conf.VideoWidth) + 'x' + str(conf.conf.VideoHeight) , framerate = conf.conf.VideoRate) as Camera: output = camera.StreamingOutput() camera.output = output Camera.start_recording(output, format = 'mjpeg') try: address = (conf.conf.ServerIP, conf.conf.videoServerPort) server = camera.StreamingServer(address, camera.StreamingHandler) server.serve_forever() finally: Camera.stop_recording() 

चूंकि वे समान सेटिंग्स लेते हैं, इसलिए वे एक ही पते पर काम करते हैं। एक से दूसरे पर स्विच करने पर रिमोट कंट्रोल के साथ संचार करने में कोई समस्या नहीं है। मुझे लगता है कि mjpg-streamer तेजी से काम करता है।

3.2 प्रबंधन सर्वर

3.2.1 क्लाइंट और सर्वर के बीच सहभागिता

सर्वर और क्लाइंट एक्सचेंज स्ट्रिंग्स के रूप में कमांड करता है:

 {'type': 'remote', 'cmd': 'Start', 'status': True, 'val': 0.0} {'type': 'remote', 'cmd': 'Y', 'status': True, 'val': 0.5} {'type': 'remote', 'cmd': 'turn', 'x': 55, 'y': 32} 

• कमांड भेजने वाले (क्लाइंट या सर्वर) के आधार पर टाइप करें - 'रिमोट' या 'कार'
• cmd - गेम HAT पर बटन के नाम के अनुरूप बटन के साथ एक स्ट्रिंग, उदाहरण के लिए:
  
  • स्टार्ट - स्टार्ट बटन
  • Select - सेलेक्ट बटन
  • वाई - वाई बटन
  • आदि
  • टर्न - जॉयस्टिक की स्थिति को बदलने के लिए कमांड, पहियों को चालू करने के लिए जिम्मेदार है
• स्थिति - सही या गलत, यह इस बात पर निर्भर करता है कि बटन दबाया गया है या नहीं। एक बटन स्थिति घटना हर बार अपने राज्य में परिवर्तन भेजा जाता है।
• वैल - -1 ... 1 से मोटर की गति की दिशा और दिशा, प्रकार फ्लोट का मूल्य। केवल गति बटन के लिए महत्वपूर्ण पैरामीटर।
• x -100 से x अक्ष के साथ जॉयस्टिक का विचलन ... 100, प्रकार int का मान
• y -100 से y अक्ष के साथ जॉयस्टिक का विचलन ... 100, प्रकार int का मूल्य

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

 def run(self): TCP_IP = conf.conf.ServerIP TCP_PORT = conf.conf.controlServerPort BUFFER_SIZE = conf.conf.ServerBufferSize self.tcpServer = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcpServer.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.tcpServer.bind((TCP_IP, TCP_PORT)) threads = [] #     . self.tcpServer.listen(1) while True: print("Car server up : Waiting for connections from TCP clients...") (conn, (ip, port)) = self.tcpServer.accept() newthread = ClientThread(conn, ip, port) newthread.start() self.threads.append(newthread) 

3.2.2 लौह प्रबंधन

रास्पबेरी के साथ काम करते समय, GPIO.BCM पिन नंबरिंग प्रणाली का उपयोग किया गया था।

प्रकाश को gpio 17 के माध्यम से नियंत्रित किया जाता है, यह L293 पर 2 पिन से जुड़ा होता है। अगला, हर बार कमांड शामिल करने के लिए आता है:

 GPIO.output(self.gpioLight, GPIO.HIGH) 

 GPIO.output(self.gpioLight, GPIO.LOW) 

संगत आदेश कहलाते हैं।

सर्वो ड्राइव को I2C बस के माध्यम से PCA9685 बोर्ड के माध्यम से नियंत्रित किया जाता है, इसलिए हमें इसके लिए उपयुक्त पुस्तकालय की आवश्यकता है Adafruit_PCA9685 । PCA9685 7 पिन के माध्यम से सर्वो से जुड़ा हुआ है। सर्वो के साथ काम करने के लिए आवश्यक PWM आवृत्ति 50 हर्ट्ज या 20 एमएस की अवधि है।

सर्वो के संचालन का सिद्धांत:

जब 1.5 एमएस सिग्नल लगाया जाता है, तो पहियों को केंद्रित किया जाएगा। 1 बजे। सर्वो जहां तक ​​संभव हो दाईं ओर मुड़ जाएगा, 2 एमएस। जितना संभव हो उतना बाईं ओर। ऐसे घुमावों के लिए पुलों में स्टीयरिंग पोर डिजाइन नहीं किए गए हैं, इसलिए रोटेशन के कोण को प्रयोगात्मक रूप से चुना जाना था।

मान जो कि Adafruit_PCA9685 API श्रेणी में 0..4095, 0 कोई सिग्नल, 4095 से भरे जा सकते हैं। तदनुसार, इस सीमा से मेरे पहियों के लिए उपयुक्त मूल्यों को चुनना आवश्यक था। बिल्कुल निर्धारित पहियों के लिए मूल्यों को निर्धारित करने का सबसे आसान तरीका ~ 307 की सीमा से 1.5 एमएस को एक मूल्य पर स्थानांतरित करना है।

दाईं ओर का अधिकतम मूल्य 245 है, बाईं ओर 369 है।

जॉयस्टिक से आने वाले मान -100 से मान लेते हैं ... 100, इसलिए उन्हें 245 से 369 तक की सीमा में अनुवादित किया जाना था। फिर, केंद्र सबसे आसान है, अगर 0 यह 307 है। सूत्र के अनुसार बाएं और दाएं:

 val = int(HardwareSetting._turnCenter + (-1 * turn * HardwareSetting._turnDelta / HardwareSetting.yZero)) 

• HardwareSetting._turnCenter - 307
• मोड़ -100 से जॉयस्टिक से मूल्य ... 100
• HardwareSetting._turnDelta - 62, केंद्र और पक्ष के अधिकतम विचलन के बीच का अंतर (307 - 245 = 62)
• HardwareSetting.yZero - 100, जॉयस्टिक से प्राप्त अधिकतम मूल्य

पहिए सीधे:

 def turnCenter(self): val = int(HardwareSetting._turnCenter) self.pwm_servo.set(val) CarStatus.statusCar['car']['turn'] = val 

बाएं मुड़ें:

 def turnLeft(self, turn): val = int(HardwareSetting._turnCenter + (-1 * turn * HardwareSetting._turnDelta / HardwareSetting.yZero)) self.pwm_servo.set(val) CarStatus.statusCar['car']['turn'] = val 

दाएँ मुड़ें:

 def turnRight(self, turn): val = int(HardwareSetting._turnCenter + (-1 * turn * HardwareSetting._turnDelta / HardwareSetting.yZero)) self.pwm_servo.set(val) CarStatus.statusCar['car']['turn'] = val 

इंजन नियंत्रण भी I2C बस के माध्यम से PCA9685 बोर्ड के माध्यम से होता है, इसलिए हम Adafruit_PCA9685 का उपयोग करते हैं। PCA9685 पर पिन 10 से 15 L298N से जुड़े हैं (मैं इसे शक्ति को अवशोषित करने के लिए 2 चैनलों का उपयोग करता हूं)। ENA और ENB को 10 और 11 (मैं गति को नियंत्रित करने के लिए PWM के साथ उन्हें भरता हूं)। 12, 13, 14, 15 से IN1, IN2, IN3, IN4 - मोटर के रोटेशन की दिशा के लिए जिम्मेदार हैं। पीडब्लूएम आवृत्ति यहाँ बहुत महत्वपूर्ण नहीं है, लेकिन मैं 50 हर्ट्ज (मेरा डिफ़ॉल्ट मूल्य) का भी उपयोग करता हूं।

मशीन अभी भी खड़ा है:

 def stop(self): """  . """ self.pwm.set_pwm(self.ena, 0, self.LOW) self.pwm.set_pwm(self.enb, 0, self.LOW) self.pwm.set_pwm(self.in1, 0, self.LOW) self.pwm.set_pwm(self.in4, 0, self.LOW) self.pwm.set_pwm(self.in2, 0, self.LOW) self.pwm.set_pwm(self.in3, 0, self.LOW) 

आगे बढ़ना:

 def back(self, speed): """  . Args: speed:     0  1. """ self.pwm.set_pwm(self.ena, 0, int(speed * self.HIGH)) self.pwm.set_pwm(self.enb, 0, int(speed * self.HIGH)) self.pwm.set_pwm(self.in1, 0, self.LOW) self.pwm.set_pwm(self.in4, 0, self.LOW) self.pwm.set_pwm(self.in2, 0, self.HIGH) self.pwm.set_pwm(self.in3, 0, self.HIGH) 

पिछड़ा आंदोलन:

 def forward(self, speed): """  . Args: speed:     0  1. """ self.pwm.set_pwm(self.ena, 0, int(speed * self.HIGH)) self.pwm.set_pwm(self.enb, 0, int(speed * self.HIGH)) self.pwm.set_pwm(self.in1, 0, self.HIGH) self.pwm.set_pwm(self.in4, 0, self.HIGH) self.pwm.set_pwm(self.in2, 0, self.LOW) self.pwm.set_pwm(self.in3, 0, self.LOW) 

4. ग्राहक

4.1 कीबोर्ड

उसके साथ कुछ समस्याएं थीं, सबसे पहले मैं उसे घटनापूर्ण बनाना चाहता था (यह ~ 2 सप्ताह की पीड़ा थी)। लेकिन मैकेनिकल बटन ने योगदान दिया, संपर्कों की तेजस्वी निरंतर और अप्रत्याशित विफलताओं का कारण बनी (नियंत्रण एल्गोरिदम जो मैंने आविष्कार किया, जो अपूर्ण रूप से काम करता था)। तब मेरे सहयोगी ने मुझे बताया कि कीबोर्ड कैसे बनाए जाते हैं। और मैंने ऐसा करने का फैसला किया, अब मैं राज्य को हर 0.005 सेकंड (ऐसा क्यों, और कौन जानता है) का सर्वेक्षण करता हूं। और अगर यह बदल गया है, तो सर्वर पर मूल्य भेजें।

 def run(self): try: while True: time.sleep(0.005) for pin in self.pins : p = self.pins[pin] status = p['status'] if GPIO.input(pin) == GPIO.HIGH : p['status'] = False else : p['status'] = True if p['status'] != status : p['callback'](pin) except KeyboardInterrupt: GPIO.cleanup() 

4.2 जॉयस्टिक

रीडिंग का पठन ADS1115 बोर्ड द्वारा I2C बस के माध्यम से होता है, इसलिए, इसके लिए उपयुक्त पुस्तकालय Adafruit_PCA9685 है । जॉयस्टिक भी बकवादी संपर्कों के लिए प्रवण है, इसलिए मैं कीबोर्ड के साथ सादृश्य द्वारा इसे रीडिंग लेता हूं।

 def run(self): while True: X = self.adc.read_adc(0, gain=self.GAIN) / HardwareSetting.valueStep Y = self.adc.read_adc(1, gain=self.GAIN) / HardwareSetting.valueStep if X > HardwareSetting.xZero : X = X - HardwareSetting.xZero else : X = -1 * (HardwareSetting.xZero - X) if Y > HardwareSetting.yZero : Y = Y - HardwareSetting.yZero else : Y = -1 * (HardwareSetting.yZero - Y) if (abs(X) < 5) : X = 0 if (abs(Y) < 5) : Y = 0 if (abs(self.x - X) >= 1.0 or abs(self.y - Y) >= 1.0) : self.sendCmd(round(X), round(Y)) self.x = X self.y = Y time.sleep(0.005) 

3.3 वोल्ट से संचालित होने पर, ADS1115 मानों की सीमा 0 से एक जॉयस्टिक के साथ देता है ... 26500। मैं इसे -100 ... 100 से सीमा तक लाता हूं। मेरी सीमा में 0 के आसपास यह हमेशा उतार-चढ़ाव करता है, इसलिए यदि मान 5 से अधिक नहीं होते हैं, तो मेरा मानना ​​है कि यह 0 है (अन्यथा यह बाढ़ होगा)। जैसे ही मान बदलते हैं, उन्हें टाइपराइटर पर भेजें।

4.3 प्रबंधन सर्वर से जुड़ना

सर्वर से जुड़ना एक साधारण बात है:

 try : tcpClient = socket.socket(socket.AF_INET, socket.SOCK_STREAM) tcpClient.settimeout(2.0) tcpClient.connect((conf.conf.ServerIP, conf.conf.controlServerPort)) self.signalDisplayPrint.emit("+") carStatus.statusRemote['network']['control'] = True self.tcpClient = tcpClient except socket.error as e: self.signalDisplayPrint.emit("-") carStatus.statusRemote['network']['control'] = False time.sleep(conf.conf.timeRecconect) self.tcpClient = None continue if self.tcpClient : self.tcpClient.settimeout(None) 

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

मैं कनेक्शन की स्थिति भी संग्रहीत करता हूं, ताकि मुझे पता चल जाए कि क्या नियंत्रण खो गया है और इसे स्क्रीन पर प्रदर्शित करें।

4.4 वाईफाई कनेक्शन की जाँच करना

मैं सर्वर से कनेक्शन के लिए वाईफाई की स्थिति की जांच करता हूं। और अगर, कि मैं खुद को समस्याओं के बारे में बताऊं।

 def run(self): while True: time.sleep(1.0) self.ps = subprocess.Popen(['iwgetid'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) try: output = subprocess.check_output(('grep', 'ESSID'), stdin=self.ps.stdout) if re.search(r'djvu-car-pi3', str(output)) : self.sendStatus('wifi+') continue except subprocess.CalledProcessError: pass self.sendStatus('wifi-') self.ps.kill() 

4.5 वीडियो सर्वर से कनेक्ट करना

इसके लिए, Qt5 की सभी शक्ति की आवश्यकता थी , जिस तरह से स्ट्रेच वितरण पर यह नया है और मेरी राय में बेहतर है। जेसी पर मैंने भी कोशिश की।

प्रदर्शन के लिए मैंने इस्तेमाल किया:

 self.videoWidget = QVideoWidget() 

और वह घटाया:

 self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.LowLatency) self.mediaPlayer.setVideoOutput(self.videoWidget) 

स्ट्रीमिंग वीडियो के लिए कनेक्शन:

 self.mediaPlayer.setMedia(QMediaContent(QUrl("http://{}:{}/?action=stream".format(conf.conf.ServerIP, conf.conf.videoServerPort)))) self.mediaPlayer.play() 

एक बार फिर, मैं टॉटोलॉजी के लिए माफी मांगता हूं)। मैं वीडियो सर्वर से कनेक्शन के लिए वीडियो कनेक्शन की स्थिति की निगरानी करता हूं। और अगर, कि मैं खुद को समस्याओं के बारे में बताऊं।

जब यह सब कुछ काम नहीं करता है तो ऐसा दिखता है:

• डब्ल्यू - का मतलब है कि वाईफाई के साथ कोई संबंध नहीं है
• बी - का मतलब कोई वीडियो नहीं है
• Y - का मतलब है कि कोई नियंत्रण नहीं है

अन्यथा लाल अक्षर नहीं हैं, कैमरे से एक वीडियो है। मैं भविष्य में काम के साथ एक फोटो और वीडियो पोस्ट करूंगा) मुझे उम्मीद है कि कैमरे के लिए माउंट निकट भविष्य में आएगा और मैं इसे सामान्य रूप से संलग्न करूंगा।

5 रास्पबेरी ओएस को कॉन्फ़िगर करना

वैसे, कैमरा और अन्य आवश्यक चीजों के साथ काम करना सक्षम होना चाहिए (क्लाइंट और सर्वर पर दोनों)। OS लोड करने के बाद:

और लगभग सब कुछ चालू करें: कैमरा, ssh, i2c, gpio

प्रदर्शन

केवल एक वीडियो चैनल है (कैमरा काम पर रहता है)। मैं उनकी अनुपस्थिति के लिए माफी चाहता हूं, मैं इसे सोमवार को संलग्न करूंगा।

वीडियो काम:

स्रोत कोड

सर्वर और क्लाइंट स्रोत कोड
डेमॉन सर्वर स्टार्टअप पैकेज

संदर्भ

भाग 1
भाग 3