STM32 और ब्लूटूथ या डू-इट-खुद पीसी रिमोट कंट्रोल

शुरू करने के बजाय

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

मैं उन लोगों के लिए तुरंत नोट करूंगा जो बाइक कहते हैं। हाँ यह एक साइकिल है। और मुझे इसे बनाने में दिलचस्पी थी। कई कारणों से। जिनमें से एक यह है कि आप इसे स्वयं करें और न खरीदें।

प्रागितिहास

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

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

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

सामान्य योजना

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

कार्यान्वयन

अब देखते हैं कि ऊपर वर्णित योजना के अनुसार क्या हुआ:

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

दानव

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

प्रोटोटाइप में सेट अप काफी सरल है:

#!/usr/bin/python2 # -*- coding: utf-8 -*- import serial import dbus import subprocess import time import os #        BT ,             ,       .        ,            . #      ser = serial.Serial('/dev/rfcomm0', 115200, timeout=1) #     DBUS,       Amarok. bus = dbus.SessionBus() am = bus.get_object('org.kde.amarok', '/Player') #           ,        . commands = { 'p': [am.PlayPause, []], '>': [am.Next, []], '<': [am.Prev, []], 'm': [am.Mute, []], '+': [am.VolumeUp, [1,]], '-': [am.VolumeDown, [1,]] } print 'Connected' #        . try: while 1: try: #     ,       ,             . line = ser.read(1) #                 except serial.serialutil.SerialException: #      ,     ,        . ser.close() time.sleep(0.5) while 1: try: #      ser = serial.Serial('/dev/rfcomm0', 115200, timeout=1) break #     , ..         ,    2      . except serial.serialutil.SerialException: time.sleep(2) #      (      , ,        ) , if len(line) == 1: #     ,      if line[0] == 'C': print 'Command' #   2   -     line += ser.read(2) #        2  - ..      3 . if len(line) == 3: print "0x%02x 0x%02x 0x%02x" % (ord(line[0]), ord(line[1]), ord(line[2])) #     ping,          , ..     ""    . if ord(line[1]) == 0x00 and ord(line[2]) == 0x00: print 'Device ping' ser.write('A') ser.write(chr(0x00)) ser.write(chr(0x02)) ser.write(chr(ord('O'))) ser.write(chr(ord('K'))) print 'Ansver to device' #      ,     . if ord(line[1]) == 0x02: #     . mlen = ord(line[2]) message = ser.read(mlen) #              if message in commands: current = commands[message] current[0](*current[1]) #    -    . except KeyboardInterrupt: ser.close() del am print 'Exiting' #      BT . # cleaning cmd = "sudo rfcomm unbind all" runner(cmd) 

प्रोटोकॉल

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

युक्ति

यहां वास्तविक प्रकार का उपकरण है जो मुझे मिला, साथ ही साथ पीसी पर मॉड्यूल, इस डिवाइस को एक प्रोटोटाइप के रूप में बनाया गया था, जिसे सिस्टम के पहले संस्करण के निर्माण में विफलताओं का कड़वा अनुभव दिया गया था:

डिवाइस को सी में लिखे फर्मवेयर द्वारा नियंत्रित किया जाता है, अपनी स्वयं की परियोजना संरचना का उपयोग करने के लिए, जिसे आप नीचे दिए गए लिंक पर क्लिक करके देख सकते हैं।

 /* main work function */ void work(void) { unsigned short i, j; unsigned char mailbox_num = 0; volatile ProtoIOMBox * mbox; /*       ,       - . */ //     . /* check status */ check_status(); //    ""     ,      .                  . /* send ping */ mbox->outbox->header = 'C'; /* Command */ mbox->outbox->size = 0x00; /* 0 for ping request */ mbox->outbox_s = PROTO_IO_MBOX_READY; /* Box ready */ mbox->inbox->size = 64; /* buffer len for control */ mbox->inbox_s = PROTO_IO_MBOX_READY; /* Box ready */ /* wait connection estabilished */ while (status == 0); /* send ping message */ proto_send_msg(mailbox_num); /* wait to send message */ while (mbox->outbox_s <= PROTO_IO_MBOX_SEND); if (mbox->outbox_s == PROTO_IO_MBOX_COMPLETE) LCD_String("Con", 36, 6, 1, WHITE, GLASSY); else LCD_String("Un", 36, 6, 1, RED, GLASSY); /* get ping message */ /* FIXME wtf? this not work or work parity */ //proto_get_msg(mailbox_num); /* wait to get message */ while (mbox->inbox_s <= PROTO_IO_MBOX_SEND); if (mbox->inbox_s == PROTO_IO_MBOX_COMPLETE) { LCD_String("OK", 36 + 3 * 7, 6, 1, GREEN, GLASSY); for (i = 0; i < mbox->inbox->size; i++) LCD_Char(mbox->inbox->message[i], 70 + i * 6, 6, 1, WHITE, GLASSY); } else LCD_String("ERR", 36 + 3 * 7, 6, 1, RED, GLASSY); //               .    ,            . /* infinity loop */ while (1) { if (button_state.state[B_LGHT] == B_CLICK) { sender('+'); button_state.state[B_LGHT] = B_RELEASE; } /*       */ } } 

मैं संदेश भेजने और प्राप्त करने के लिए अलग से मॉड्यूल का भी उल्लेख करना चाहता हूं - इस परियोजना में यह proto.o मॉड्यूल है - proto.c स्रोत कोड और proto.h हेडर फ़ाइल। मैं कोड नहीं दूंगा क्योंकि यह बड़ा है। लेकिन सामान्य तौर पर मैं आपको बताता हूं कि यह कैसे काम करता है।
मॉड्यूल को पूरी तरह से रुकावटों से काम करने के लिए डिज़ाइन किया गया है, हालांकि, डेटा ट्रांसफर को अब सही ढंग से लागू नहीं किया गया है, इसलिए, इसे प्रारंभिक प्रारंभिक कॉल की आवश्यकता है। संदेश प्राप्त करना और भेजना 2 राज्य मशीनों का उपयोग करके किया जाता है, जो कि बाइट्स भेजे जाते हैं, उनके राज्य को बदलते हैं। वैधता और त्रुटि से निपटने के लिए संदेश की जाँच की।

मैं पूरी तरह से सिस्टम का एक वीडियो भी संलग्न करता हूं:

अंतभाषण

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