🚓 🏇🏼 🎚️ एंड्रॉइड डिवाइस के एक्सेलेरोमीटर द्वारा नियंत्रित .NET माइक्रो फ्रेमवर्क के साथ नियंत्रक पर मशीन ☣️ 😭 👡

ब्लूटूथ चैनल के माध्यम से एंड्रॉइड डिवाइस से नियंत्रण के साथ 4WD कारों के निर्माण का वर्णन करने वाला एक सरल प्रोजेक्ट। टैबलेट / स्मार्टफोन को झुकाकर मशीन को एक्सेलेरोमीटर द्वारा नियंत्रित किया जाता है। लेख के अंत में वीडियो देखें। सभी स्रोत कोड संलग्न है।

विकास उपकरण: एंड्रॉइड के लिए जावा / एक्लिप्स और माइक्रोकंट्रोलर के लिए .NET माइक्रो फ्रेमवर्क / विज़ुअल सी # एक्सप्रेस।

प्रविष्टि

मैं विभिन्न परिष्कृत स्मार्टफोन्स, आईपैड, इत्यादि में कूल टेक्नोलॉजी गैजेट्स का समर्थक नहीं हूं। 2001 से, मेरे पास केवल एक दूसरा फोन है: सैमसंग बी 2700 (पहला सीमेंस सी 55 था, अभी भी मेरी दादी के साथ काम कर रहा है)। लेकिन गतिविधि के प्रकार से, मुझे एसएसएच के माध्यम से सर्वर तक पहुंचने के लिए एक उपकरण की आवश्यकता थी, और जब मैं यात्रा कर रहा था तो वेब-इंटरफ़ेस तक। इस संबंध में, सबसे सस्ती चीनी एंड्रॉइड टैबलेट में से एक खरीदा गया था: ऐनोल ऑरोरा। यह काफी सामान्य रूप से काम करता था, और वेब, और ssh, कंसोल और यहां तक कि ftp क्लाइंट, सामान्य रूप से, अपने कार्यों को 100% करते थे। लेकिन मुझे केवल यात्राओं पर ही उसकी जरूरत थी, बाकी समय वह बेवकूफी से घर में बंद रहता था, क्योंकि मैं नहीं खेलता, मैं स्क्रीन से नहीं पढ़ सकता, वेब सर्फिंग के लिए स्थिर पीसी हैं। खैर, मैंने गहराई से खुदाई करने का फैसला किया, इसे कुछ और के लिए अनुकूलित करें। पहला विचार स्मार्ट घर बनाना था, लेकिन सिस्टम का हिस्सा पहले से ही काम कर रहा था, और मरम्मत हाल ही में पूरी हुई, मैं नए उपकरणों, केबलों, बिजली तारों आदि को बाड़ नहीं देना चाहता था। इसलिए, मैंने इस विचार को खारिज कर दिया, लेकिन खेल के हित के लिए मैंने एक Seeeduino ADK मेन बोर्ड शॉल खरीदा और एक USB कनेक्शन (ओपन एक्सेसरी और माइक्रोब्रिज) के माध्यम से सूचना के हस्तांतरण के साथ थोड़ा खेला। इस प्रक्रिया में, मुझे पता चला कि भले ही टैबलेट में एंड्रॉइड 4.0.3 है, लेकिन इसका मतलब यह नहीं है कि यह ओपन एक्सेसरी का समर्थन करता है। इसलिए, यह माइक्रोब्रिज मोड के साथ खेला गया था, डेटा एक्सचेंज सफल रहा था, लेकिन फिर भी मेरे लिए कुछ अतुलनीय क्षण थे ...

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

उस योजना को लागू करने के लिए, जिसकी आपको आवश्यकता होगी:
1. एंड्रॉइड डिवाइस
2. नियंत्रक (PWM, UART)
3. ब्लूटूथ मॉड्यूल
4. इंजन ड्राइवर
5. कारों के लिए प्लेटफार्म

मुझे लगता है कि हैबर के अधिकांश आगंतुक प्रोग्रामर और ऐसे लोग हैं जो किसी न किसी तरह आईटी से संबंधित हैं। इसलिए, वे उन विकल्पों में रुचि नहीं लेंगे जहां PIC, STM32, Arduino, आदि को नियंत्रक के रूप में उपयोग किया जाएगा। यही कारण है कि मैंने .NET माइक्रो फ्रेमवर्क के साथ आसपास पड़े FEZ पांडा II कंट्रोलर का उपयोग करने का निर्णय लिया है। इस नियंत्रक के लिए सॉफ्टवेयर विकास विज़ुअल C # एक्सप्रेस के वातावरण में किया जाता है, अर्थात अधिकांश प्रोग्रामर के लिए, यह एक परिचित टूलकिट होगा, हालाँकि .NET को छोटा किया गया है और कई फ़ंक्शन गायब हैं।

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

नियंत्रक - .NET माइक्रो फ्रेमवर्क के तहत कोई भी। यानी Netduino, GHI Electronics इत्यादि करेंगे। मैंने FEZ पांडा II का उपयोग किया:

चीनी UART मॉड्यूल HC-06 का उपयोग ब्लूटूथ मॉड्यूल के रूप में किया गया था। कोई भी सीरियल ब्लूटूथ करेगा। पिन पिंस के साथ लेना बेहतर है ताकि आपको मिलाप न करना पड़े, क्योंकि टर्मिनलों के बीच की दूरी बहुत छोटी है। AliExpress / eBay पर इस तरह के एक मॉड्यूल की लागत औसत 5-10 डॉलर है।

एक ड्राइवर के रूप में, मैंने एक L298N चिप के साथ एक रूमाल का उपयोग किया, जो एक दोहरी पुल मोटर चालक है और इसे डीसी और स्टेपर मोटर्स को नियंत्रित करने के लिए डिज़ाइन किया गया है। इश्यू प्राइस $ 4-5 है।

मशीन के मंच के लिए, आप 2 या 4 डीसी मोटर्स के साथ कुछ भी उपयोग कर सकते हैं। मैंने eBay पर 4 DC मोटर्स के साथ DIY प्रोजेक्ट्स के लिए तैयार 4WD चेसिस खरीदा।

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

चेसिस विधानसभा

DFRobot का 4WD प्लेटफ़ॉर्म बिना लाइसेंस के आता है:

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

मोटर्स के साथ डिब्बे में, मैंने एल 298 एन बोर्ड रखा, उन्हें इससे जोड़ा, और नियंत्रण, जीएनडी और पावर के लिए 6 तारों: 4 को बाहर लाया।

मैंने 4WD प्लेटफॉर्म की विस्तृत असेंबली का वर्णन नहीं किया है, हर किसी का अपना होगा, और यहां तक कि अगर DFRobot से 4WD चेसिस है, तो यह घर पर उपकरण और सामग्री के आधार पर कुछ सुधारों को पसंद करेगा।

मेरे द्वारा उपयोग किया जाने वाला ब्लूटूथ मॉड्यूल चीनी HC-06 है। मैं इसे पिन पिन के साथ तुरंत लेने की सलाह देता हूं, ताकि टांका लगाने के साथ गड़बड़ न हो।
HC-06 मॉड्यूल के आवश्यक पिन:
UART_TX (पिन 1), UART_RX (पिन 2)
3.3V (पिन 12) - 3.3V बिजली की आपूर्ति।
जीएनडी (पिन 13) - सामान्य।
PIO1 (पिन 24) - ऑपरेटिंग मोड संकेतक। यदि कनेक्शन स्थापित नहीं है, तो एलईडी झपकी देता है; यदि स्थापित है, तो यह लगातार रोशनी करता है।

नियंत्रक से L298N बोर्ड में 5 तारों को लाने के लिए आवश्यक है: GND (जनरल), IN1, IN2, IN3, IN4 - मोटर नियंत्रण इनपुट (PWM और बाएं मोटर के लिए रोटेशन की दिशा और दाएं तरल मोटर के लिए समान)।

डीसी मोटर्स ली-पो बैटरी 3.7V 1100 एमए द्वारा संचालित हैं। नियंत्रक एक अलग 3.7V बैटरी द्वारा संचालित है (हालांकि 5V की आवश्यकता है, लेकिन यह 3.7V से भी ठीक काम करता है)। ब्लूटूथ मॉड्यूल पावर FEZ बोर्ड से लिया गया है।

तारों में एक बड़ी गड़बड़ी है क्योंकि इससे पहले कि परियोजना STM32 पर इकट्ठा हुई थी और विशेष रूप से FEZ पांडा II नियंत्रक के साथ कार्यान्वयन के लिए disassembled थी। भविष्य में, मशीन फिर से कुछ सुधार के साथ STM32 और Arduino पर होगी। लेकिन यह एक अन्य लेख का विषय है, शायद ...

कनेक्शन आरेख इस प्रकार है:

FEZ बोर्ड को 2-पक्षीय टेप का उपयोग करके प्लेटफ़ॉर्म से जोड़ा गया था:

इसके अलावा, सब कुछ इकट्ठा और जुड़ा हुआ था। यह इस तरह निकला:

सॉफ्टवेयर

इसलिए, Android एप्लिकेशन में, मैंने 3 नियंत्रण विधियाँ लागू की हैं:
1. एक्सेलेरोमीटर - डिवाइस को झुकाकर
2. बटन - स्मार्टफोन स्क्रीन पर 4 बटन खींचे जाते हैं: आगे, पीछे, बाईं ओर रोटेशन, दाईं ओर रोटेशन।
3. स्पर्श-नियंत्रण। मैंने इस पद्धति को खेल डेथ रैली में जासूसी की, मैं इसे लागू करने की कोशिश करना चाहता था। ईमानदारी से, यह बहुत सुविधाजनक नहीं था, लेकिन इसे छोड़ दिया जैसा कि यह है।
4. सॉफ्टवेयर में 02.15.2013 को एक नया प्रकार का नियंत्रण जोड़ा गया "वर्चुअल स्टीयरिंग व्हील"

सभी गणना एंड्रॉइड एप्लिकेशन में होती हैं। कंट्रोलर PWM के लिए रेडीमेड डेटा प्राप्त करता है, रोटेशन की दिशा और फ्लैश-मेमोरी के साथ काम करने की आज्ञा देता है। इस प्रकार यह लचीली सेटिंग्स के साथ एक सार्वभौमिक अनुप्रयोग निकला, जो विभिन्न प्रकार के नियंत्रकों के लिए, विभिन्न पीडब्लूएम मूल्यों में, आदि के अनुरूप हो सकता है। वास्तव में, पहले से ही आंशिक रूप से क्या किया गया है: यह परियोजना पहले ही STM32, Arduino और FEZ पांडा II पर लागू हो चुकी है। निकट भविष्य में अन्य प्लेटफार्मों के लिए लागू करने की योजना है: MSP430, PIC, आदि।

ब्लूटूथ के माध्यम से प्रेषित कमांड का उदाहरण:
L-60 \ rR-100 \ r
एल प्रतीक का अर्थ है बाएं इंजन के लिए कमांड, माइनस साइन रिवर्स रोटेशन को इंगित करता है, 60 पीडब्लूएम मूल्य इंगित करता है। आर - सही इंजन के लिए, 100 - पीडब्लूएम मान (FEZ पांडा II के लिए अधिकतम मूल्य)। उदाहरण के लिए, Arduino के लिए, अधिकतम PWM मान 255 है, इसे Android एप्लिकेशन की सेटिंग में सेट किया जा सकता है। इस आदेश से, मशीन वापस आ जाएगी, क्योंकि बाएं पहिए दाईं ओर से थोड़ा धीमा घूमेंगे, लेकिन यह बाईं ओर थोड़ा मुड़ जाएगा। जैसा कि आप देख सकते हैं, यह नियंत्रण विधि एक ट्रैक किए गए प्लेटफ़ॉर्म के लिए अधिक उपयुक्त है।

Fw1035 \ t - microcontroller की फ्लैश मेमोरी को टाइमआउट मान लिखने के लिए कमांड (संचार खो जाने या कमांड प्राप्त नहीं होने पर मशीन किस समय बंद हो जाती है)। पहले अंक 1 का अर्थ है टाइमआउट का समावेश (क्रमशः 0 - ऑफ)। सेकंड में मान प्राप्त करने के लिए, 035 को 10 से विभाजित किया जाना चाहिए, अर्थात्। इस स्थिति में, टाइमआउट 3.5 सेकंड होगा। तदनुसार, मानों की सीमा 0.1 से 99.9 सेकंड तक है।

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

वैसे, एंड्रॉइड एप्लिकेशन की सेटिंग्स में कमांड कैरेक्टर भी सेट किए जा सकते हैं। सेटिंग्स मुख्य गतिविधि से स्वयं सेट की जाती हैं, यहां उनका एक स्क्रीनशॉट है:

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

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

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

.NET माइक्रो फ्रेमवर्क के लिए स्रोत:

using System; using System.IO.Ports; using System.Threading; using System.Text; using Microsoft.SPOT; using Microsoft.SPOT.Hardware; using GHIElectronics.NETMF.Hardware; using GHIElectronics.NETMF.FEZ; namespace CxemCAR { public class Program { public const char cmdL = 'L'; //  UART    public const char cmdR = 'R'; //  UART    public const char cmdH = 'H'; //  UART  .  1 (   Horn) public const char cmdF = 'F'; //  UART    EEPROM      public const char cmdr = 'r'; //  UART    EEPROM      () public const char cmdw = 'w'; //  UART    EEPROM      () //public const int t_TOut = 2500; // - ,        static int sw_autoOFF; static int autoOFF = 2500; static byte[] storage = new byte[InternalFlashStorage.Size]; //     FLASH   static OutputPort MotorL_d = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.Di4, false); //    1 static OutputPort MotorR_d = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.Di7, false); //    2 static OutputPort Channel1 = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.Di8, false); // .  1 static PWM MotorL = new PWM((PWM.Pin)FEZ_Pin.PWM.Di5); //      1 () static PWM MotorR = new PWM((PWM.Pin)FEZ_Pin.PWM.Di6); //      2 () static SerialPort UART1 = new SerialPort("COM1", 9600); //   UART1 ( COM1) static Timer timerTO; //  public static void Main() { byte[] L_Data = new byte[4]; //      L byte L_index = 0; //   byte[] R_Data = new byte[4]; //      R byte R_index = 0; //   byte[] H_Data = new byte[1]; //    .  byte H_index = 0; //   byte[] F_Data = new byte[8]; //       EEPROM byte F_index = 0; char command = ' '; // :   R, L, H, F    int i_tmp_L = 0; int i_tmp_R = 0; int i_tmp_H = 0; byte[] incomingByte = new byte[1]; //   UART UART1.Open(); UART1.Flush(); timerTO = new Timer(new TimerCallback(TimeOut), null, autoOFF, autoOFF); //     timer_init(); //    while (true) { int read_count = UART1.Read(incomingByte, 0, 1); //   if (read_count > 0) //  ? { if (incomingByte[0] == cmdL) //      L { command = cmdL; //   Array.Clear(L_Data, 0, L_Data.Length); //   L_index = 0; //    } else if (incomingByte[0] == cmdR) //      R { command = cmdR; //   Array.Clear(R_Data, 0, R_Data.Length); //   R_index = 0; //    } else if (incomingByte[0] == cmdH) //     .  1 { command = cmdH; //   Array.Clear(H_Data, 0, H_Data.Length); //   H_index = 0; //    } else if (incomingByte[0] == cmdF) //     .  1 { command = cmdF; //   Array.Clear(F_Data, 0, F_Data.Length); //   F_index = 0; //    } else if (incomingByte[0] == '\r') command = 'e'; //   else if (incomingByte[0] == '\t') command = 't'; //        if (command == cmdL && incomingByte[0] != cmdL) { if (ValidData(incomingByte[0])) { L_Data[L_index] = incomingByte[0]; //       if (L_index < (L_Data.Length - 1)) L_index++; //     } } else if (command == cmdR && incomingByte[0] != cmdR) { if (ValidData(incomingByte[0])) { R_Data[R_index] = incomingByte[0]; if (R_index < (R_Data.Length - 1)) R_index++; } } else if (command == cmdH && incomingByte[0] != cmdH) { if (ValidData(incomingByte[0])) { H_Data[H_index] = incomingByte[0]; if (H_index < (H_Data.Length - 1)) H_index++; } } else if (command == cmdF && incomingByte[0] != cmdF) { F_Data[F_index] = incomingByte[0]; if (F_index < (F_Data.Length - 1)) F_index++; } else if (command == 'e') //     { timerTO.Dispose(); //     string tmp_L = new string(System.Text.UTF8Encoding.UTF8.GetChars(L_Data)); //     string tmp_R = new string(System.Text.UTF8Encoding.UTF8.GetChars(R_Data)); string tmp_H = new string(System.Text.UTF8Encoding.UTF8.GetChars(H_Data)); try { if (tmp_L != null) i_tmp_L = int.Parse(tmp_L); //     int if (tmp_R != null) i_tmp_R = int.Parse(tmp_R); if (tmp_H != null) i_tmp_H = int.Parse(tmp_H); } catch { Debug.Print("Error: convert String to Integer"); } if (i_tmp_L > 100) i_tmp_L = 100; else if (i_tmp_L < -100) i_tmp_L = -100; if (i_tmp_R > 100) i_tmp_R = 100; else if (i_tmp_R < -100) i_tmp_R = -100; Control4WD(i_tmp_L, i_tmp_R, i_tmp_H); timerTO.Change(autoOFF, autoOFF); //    } else if (command == 't') //         { Flash_Op(F_Data[0], F_Data[1], F_Data[2], F_Data[3], F_Data[4]); } } } } static void Flash_Op(byte FCMD, byte z1, byte z2, byte z3, byte z4) { if (FCMD == cmdr && sw_autoOFF != 255) //    EEPROM  { byte[] buffer = Encoding.UTF8.GetBytes("FData:"); //       UART UART1.Write(buffer, 0, buffer.Length); //    UART byte[] buffer2 = new byte[4] { storage[0], storage[1], storage[2], storage[3] }; UART1.Write(buffer2, 0, buffer2.Length); byte[] buffer3 = Encoding.UTF8.GetBytes("\r\n"); UART1.Write(buffer3, 0, buffer3.Length); } else if (FCMD == cmdw) //    EEPROM  { byte[] varToSave = new byte[InternalFlashStorage.Size]; varToSave[0] = z1; varToSave[1] = z2; varToSave[2] = z3; varToSave[3] = z4; InternalFlashStorage.Write(varToSave); //    FLASH   timer_init(); //   byte[] buffer2 = Encoding.UTF8.GetBytes("FWOK\r\n"); //       UART UART1.Write(buffer2, 0, buffer2.Length); //  ,     } } static void timer_init() { InternalFlashStorage.Read(storage); //    FLASH  sw_autoOFF = storage[0]; if(sw_autoOFF == '1'){ //     byte[] var_Data= new byte[3]; var_Data[0] = storage[1]; var_Data[1] = storage[2]; var_Data[2] = storage[3]; string tmp_autoOFF = new string(System.Text.UTF8Encoding.UTF8.GetChars(var_Data)); autoOFF = int.Parse(tmp_autoOFF)*100; timerTO.Change(autoOFF, autoOFF); //    } else if(sw_autoOFF == '0'){ timerTO.Dispose(); //   } Debug.Print("Timer Init" + autoOFF.ToString()); } static void TimeOut(object o) { //Debug.Print(DateTime.Now.ToString()); Control4WD(0, 0, 0); //     } public static void Control4WD(int mLeft, int mRight, int Horn) { bool directionL, directionR; //    L298N int valueL, valueR; //   M1, M2 (0-100) if (mLeft > 0) { valueL = mLeft; directionL = false; } else if (mLeft < 0) { valueL = 100 - System.Math.Abs(mLeft); directionL = true; } else { directionL = false; valueL = 0; } if (mRight > 0) { valueR = mRight; directionR = false; } else if (mRight < 0) { valueR = 100 - System.Math.Abs(mRight); directionR = true; } else { directionR = false; valueR = 0; } if (Horn == 1) { Channel1.Write(true); } else Channel1.Write(false); //Debug.Print("L:" + valueL.ToString() + ", R:" + valueR.ToString()); MotorL.Set(30000, (byte)(valueL)); MotorR.Set(30000, (byte)(valueR)); MotorL_d.Write(directionL); MotorR_d.Write(directionR); } public static bool ValidData(byte chIncom) //       "0..9"  "-" { if ((chIncom >= 0x30 && chIncom <= 0x39) || chIncom == 0x2D) return true; else return false; } } }

FEZ के तहत कार्यक्रम ही बहुत जटिल नहीं है - एक चक्र में हम UART से डेटा पढ़ते हैं और संबंधित सरणियों का निर्माण करते हैं। जैसे ही अंतरण समाप्ति वर्ण (\ r या \ t) आता है, डेटा परिवर्तित हो जाता है और संबंधित Control4WD () या Flash_Op () कार्यों में स्थानांतरित हो जाता है। Control4WD () फ़ंक्शन दिशा की गणना करता है, साथ ही साथ छोटी गणना करता है, और फिर डेटा संबंधित कंट्रोलर पिंस के लिए आउटपुट होता है।

वर्तमान सॉफ्टवेयर संस्करण: 1.2 दिनांक 02.15.2013।

काम का वीडियो:

"वर्चुअल स्टीयरिंग व्हील" मोड का वीडियो (02.15.2013 जोड़ा गया):

एंड्रॉयड डिवाइस पर इंस्टॉलेशन के लिए एपीके फाइल डाउनलोड करें
ग्रहण के लिए प्रोजेक्ट डाउनलोड करें
विजुअल C # 2010 एक्सप्रेस के लिए एक प्रोजेक्ट डाउनलोड करें

उपयोगी सामग्री और स्रोत:

एंड्रॉइड डिवाइस के एक्सेलेरोमीटर द्वारा नियंत्रित .NET माइक्रो फ्रेमवर्क के साथ नियंत्रक पर मशीन

प्रविष्टि

चेसिस विधानसभा

सॉफ्टवेयर

More articles: