प्रेरणा का स्रोत

गेमिंग प्रदर्शनियों में, स्पेस डेवलपर्स में ऑब्जेक्ट्स ने एक विशाल स्पेसशिप के कॉकपिट पर एक नियंत्रक के साथ अपने गेम का डेमो दिखाया। यह रोशन बटन, एनालॉग डिवाइस, स्टेटस लाइट इंडिकेटर, स्विच इत्यादि द्वारा पूरक था ... यह खेल में विसर्जन को बहुत प्रभावित करता है:


इस तरह के नियंत्रकों के लिए संचार प्रोटोकॉल के विवरण के साथ खेल की वेबसाइट पर एक Arduino ट्यूटोरियल पोस्ट किया गया है ।

मैं अपने खेल के लिए वही बनाना चाहता हूं

इस उदाहरण में, मैं एक रेसिंग सिम्युलेटर के कॉकपिट में सुंदर, बड़े और भारी स्विच को जोड़ने के लिए लगभग $ 40 खर्च करूंगा। मुख्य लागत इन स्विचों के साथ जुड़ी हुई है - अगर मैंने सरल स्विच / बटन का उपयोग किया है, तो कीमत आधी हो जाएगी! यह वास्तविक उपकरण है जो 240 वाट की शक्ति का सामना कर सकता है, और मैं केवल इसके बारे में 0.03 वाट को बाहर कर दूंगा।

चेतावनी: मैंने पैसे बचाने का फैसला किया है, इसलिए मैं एक सस्ती चीनी वेबसाइट का लिंक छोड़ता हूं जहां मैं विभिन्न घटकों / उपकरणों का एक गुच्छा खरीदता हूं। सस्ते घटकों को खरीदने की एक खामी यह है कि उनके पास अक्सर कोई दस्तावेज नहीं होता है, इसलिए इस लेख में मैं इस समस्या को हल करूंगा।

मुख्य घटक

• Arduino Mega2560 - $ 9
  
• इग्निशन स्विच रेसिंग पैनल - $ 26
  
• कनेक्टिंग तारों का एक गुच्छा ( "पुरुष से पुरुष" , "पुरुष से महिला" , आदि ...) - $ 2

चुनिंदा उपकरण

• टांका लगाने वाला लोहा ( यह एक अच्छा चुनने के लायक है, लेकिन यह काम का सामना करने के लिए सस्ता है )
• मिलाप ( रोजिन 60/40 के साथ - इसके साथ काम करना आसान है, हालांकि यह पर्यावरण के लिए हानिकारक है ।)
  
• हीट हटना टयूबिंग ( और औद्योगिक हेयर ड्रायर, हेयर ड्रायर, या लाइटर ) या बिजली के टेप
  
• गोंद बंदूक ( और इसे छड़ें ), या किसी प्रकार की एपॉक्सी
  
• मल्टीमीटर
  
• यदि आप को पैसे बचाने की आवश्यकता है, तो स्ट्रिपिंग तारों , या सिर्फ कैंची के लिए निप्पर्स / सरौता ।

सॉफ्टवेयर

• Arduino प्रोसेसर की प्रोग्रामिंग के लिए Arduino IDE
• एक नियंत्रक बनाने के लिए जो वास्तविक हार्डवेयर USB नियंत्रक / जॉयस्टिक के रूप में दिखाई देता है:
  
  • Arduino USB नियंत्रक में नए फर्मवेयर को चमकाने के लिए FLIP
  • जीथुब पर अरुडिनो -यूएसबी लाइब्रेरी
• एक नियंत्रक बनाने के लिए जिसके साथ खेल सीधे संवाद करता है ( या जो एक आभासी यूएसबी नियंत्रक / जॉयस्टिक के रूप में प्रकट होता है )
  • मेरी ois_protocol लाइब्रेरी जीथब पर
    
  • VJoy ड्राइवर यदि आप नियंत्रक को वर्चुअल USB नियंत्रक / जॉयस्टिक के रूप में उपयोग करना चाहते हैं।

चेतावनी

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

मेरे लिए यह एक प्रशिक्षण परियोजना थी, इसलिए इसमें गलत सलाह या गलतियाँ हो सकती हैं!

भाग 1. नियंत्रक को एक साथ रखना!

हम दस्तावेजों के बिना स्विच के साथ काम करते हैं ...

जैसा कि ऊपर कहा गया है, मैं कम मार्जिन वाले रिटेलर से सस्ते हिस्से खरीदता हूं, इसलिए सबसे पहले यह पता लगाना है कि ये स्विच / बटन कैसे काम करते हैं।

सरल पुश-बटन / स्विच

बटन के साथ, सब कुछ सरल है - इसमें कोई एल ई डी नहीं हैं और केवल दो संपर्क हैं। मल्टीमीटर को निरंतरता / डायलिंग मोड पर स्विच करें ( ) और विभिन्न संपर्कों की जांच को स्पर्श करें - ओएल (ओपन लूप, ओपन सर्किट) स्क्रीन पर प्रदर्शित किया जाएगा: इसका मतलब है कि दो जांचों के बीच कोई संबंध नहीं है। फिर हम बटन दबाते हैं, फिर भी संपर्क जांच को छूते हैं - 0.1 now की तरह कुछ अब स्क्रीन पर दिखाई देना चाहिए और मल्टीमीटर बीप करना शुरू कर देगा ( यह दर्शाता है कि जांच के बीच बहुत कम प्रतिरोध है - एक बंद सर्किट )।

अब हम जानते हैं कि जब बटन दबाया जाता है, तो सर्किट बंद हो जाता है, और जब दबाया जाता है, तो यह खुलता है। आरेख में, इसे एक सरल स्विच के रूप में वर्णित किया जा सकता है:

हम Arduino पर स्विच कनेक्ट करते हैं

Arduino बोर्ड पर दो पिन ढूंढें: GND को लेबल किया गया और "2" (या किसी अन्य मनमाने ढंग से नंबर) को लेबल किया गया - ये सामान्य उद्देश्य I / O पिन हैं जिन्हें हम सॉफ्टवेयर के माध्यम से नियंत्रित कर सकते हैं)।

यदि हम स्विच को इस तरह से कनेक्ट करते हैं, और फिर हम Arduino को पिन 2 को INPUT पिन के रूप में कॉन्फ़िगर करने का आदेश देते हैं, तो हमें बाईं ओर (नीचे दिए गए चित्र में) सर्किट दिखाया गया है। जब बटन दबाया जाता है, तो पिन 2 सीधे जमीन / 0 वी से जुड़ा होगा, और जब दबाया जाता है, तो पिन 2 किसी भी चीज से जुड़ा नहीं होगा। इस स्थिति ( किसी भी चीज़ से जुड़ी नहीं ) को "फ्लोटिंग" (उच्च प्रतिबाधा अवस्था) कहा जाता है और दुर्भाग्य से, यह हमारे उद्देश्यों के लिए बहुत अच्छी स्थिति नहीं है। जब हम सॉफ़्टवेयर में एक संपर्क से डेटा पढ़ते हैं ( digitalRead (2) का उपयोग करके ), तो हम कम हो जाते हैं यदि संपर्क जमीन पर है, और एक अप्रत्याशित परिणाम (LOW या उच्च) यदि संपर्क चल रहा है!

इसे ठीक करने के लिए, हम INPUT_PULLUP मोड में संपर्क को कॉन्फ़िगर कर सकते हैं, जो प्रोसेसर के अंदर रोकनेवाला से कनेक्ट होता है और दाईं ओर दिखाए गए सर्किट को बनाता है। इस सर्किट में, स्विच ओपन के साथ, पिन 2 में + 5V का एक पथ है, इसलिए जब इसे पढ़ा जाता है, तो परिणाम हमेशा उच्च होगा। जब स्विच बंद हो जाता है, तो संपर्क में अभी भी + 5V के लिए उच्च प्रतिरोध के साथ एक पथ होगा, साथ ही साथ ग्राउंड / 0V के प्रतिरोध के बिना एक पथ, जो "जीतता है", इसलिए जब हम संपर्क पढ़ते हैं, तो हमें एक LOW मिलता है।


सॉफ़्टवेयर डेवलपर्स के लिए, ऑर्डर उलटा लग सकता है - जब हम बटन पर क्लिक करते हैं, तो हम गलत / कम पढ़ते हैं, और जब उदास होते हैं, तो हम सच / उच्च पढ़ते हैं।

आप विपरीत कर सकते हैं, लेकिन प्रोसेसर में केवल अंतर्निर्मित पुल-अप प्रतिरोध हैं और पुल-डाउन प्रतिरोधक नहीं हैं, इसलिए हम इस मॉडल से चिपके रहेंगे।

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

void setup() { Serial.begin(9600); pinMode(2, INPUT_PULLUP); } void loop() { int state = digitalRead(pin); Serial.println( state == HIGH ? "Released" : "Pressed" ); delay(100);//artifically reduce the loop rate so the output is at a human readable rate... } 

लगभग कोई दस्तावेज के साथ अन्य स्विच ...

तीन-पिन एलईडी स्विच

सौभाग्य से, मेरे पैनल के मुख्य स्विच पर तीन संपर्कों के निशान हैं:


मुझे पूरी तरह से यकीन नहीं है कि यह कैसे काम करता है, इसलिए हम मल्टीमीटर को निरंतर मोड पर स्विच करेंगे और स्विच चालू और बंद होने पर सभी जोड़े संपर्कों को स्पर्श करेंगे ... हालांकि, जब हम [GND] और [+] जांच को छूते हैं तो इस बार मल्टीमीटर बिल्कुल भी बीप नहीं करता है। चालू करो! एकमात्र कॉन्फ़िगरेशन जिसमें मल्टीमीटर बीप करता है ( एक कनेक्शन का पता लगाता है ) जब स्विच "चालू" होता है और जांच [+] और [दीपक] पर होती है।

स्विच के अंदर की एलईडी निरंतरता माप को अवरुद्ध करती है, इसलिए उपरोक्त परीक्षणों से हम यह मान सकते हैं कि एलईडी सीधे [GND] पिन से जुड़ा है, और [+] और [दीपक] संपर्कों से नहीं। अगला, हम मल्टीमीटर को डायोड टेस्ट मोड (प्रतीक) में बदल देंगे ) और संपर्कों की जोड़ी को फिर से जांचें, लेकिन इस बार ध्रुवता महत्वपूर्ण है ( लाल और काली जांच )। अब अगर हम लाल जांच को [दीपक], और काले [GND] से जोड़ते हैं, तो एलईडी प्रकाश करेगा और मल्टीमीटर पर 2.25V प्रदर्शित होगा। यह डायोड का प्रत्यक्ष वोल्टेज है, या इसे चालू करने के लिए आवश्यक न्यूनतम वोल्टेज है। स्विच की स्थिति के बावजूद, [दीपक] से [GND] तक 2.25V एलईडी का कारण बनता है। यदि हम लाल जांच को [+], और काले को [GND] से जोड़ते हैं, तो एलईडी तभी चालू होगी जब स्विच चालू होगा।

इन रीडिंग से, हम मान सकते हैं कि इस स्विच के इनसाइड नीचे दिए गए आरेख की तरह दिखते हैं:

1. [+] और [दीपक] स्विच-ऑन / बंद होने पर कम-प्रसारित होते हैं।
   
2. एक सकारात्मक वोल्टेज [दीपक] से [जीएनडी] हमेशा एलईडी को रोशनी देता है।
   
3. एक सकारात्मक वोल्टेज [+] से [GND] एलईडी को तभी रोशनी देता है जब स्विच चालू / बंद हो।

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

हम Arduino पर स्विच कनेक्ट करते हैं

सबसे आसान तरीका है Arduino के साथ स्विच का उपयोग करना, [लैंप] पिन को अनदेखा करना: Arduino में GND को [GND] कनेक्ट करें और गिने-चुने Arduino संपर्कों में से एक से [+] कनेक्ट करें, उदाहरण के लिए 3।

यदि हम पिन 3 को INPUT_PULLUP ( पिछले बटन के समान) के रूप में कॉन्फ़िगर करते हैं , तो हमें नीचे दिखाया गया परिणाम मिलेगा। ऊपरी बाएँ Arduino कोड में "digitalRead (3)" निष्पादित करके हमें प्राप्त होने वाले मान को दिखाता है।

जब स्विच चालू / बंद होता है, तो हम LOW और LED लाइट को पढ़ते हैं! इस कॉन्फ़िगरेशन में ऐसे स्विच का उपयोग करने के लिए, हम बटन उदाहरण में उसी Arduino कोड का उपयोग कर सकते हैं।

इस समाधान की समस्याएं

Arduino से कनेक्ट होने के बाद, पूरा सर्किट इस तरह दिखता है:


हालांकि, यहां हम देख सकते हैं कि जब स्विच बंद हो जाता है, तो एलईडी के सामने छोटे वर्तमान-सीमित अवरोधक के अलावा (मेरा मानना ​​है कि इसका प्रतिरोध 100 ओम है), 20 कोहम द्वारा पुल-अप रोकनेवाला भी है, जो एलईडी के माध्यम से वर्तमान प्रवाह की मात्रा को कम करता है। इसका मतलब है कि हालांकि सर्किट काम करता है, एलईडी बहुत उज्ज्वल नहीं होगा।

इस योजना का एक और दोष यह है कि हमारे पास एलईडी पर सॉफ्टवेयर नियंत्रण नहीं है - यह चालू है जब स्विच चालू है, और विपरीत स्थिति में अक्षम है।

आप देख सकते हैं कि क्या होता है अगर हम [लैंप] पिन को 0V या + 5V से जोड़ते हैं।

यदि [दीपक] 0 वी से जुड़ा है, तो एलईडी लगातार बंद है ( स्विच स्थिति की परवाह किए बिना ), और अरुडिनो स्थिति मान्यता अभी भी निष्पादित की जाती है। यह हमें प्रोग्राम को एलईडी अक्षम करने की अनुमति देता है!


यदि [दीपक] + 5 वी से जुड़ा है, तो एलईडी लगातार चालू है ( स्विच की स्थिति की परवाह किए बिना ), हालांकि, Arduino स्थिति की मान्यता टूट गई है - उच्च हमेशा संपर्क से पढ़ा जाएगा।

हम इस स्विच को Arduino से सही तरीके से कनेक्ट करते हैं

हम अधिक कोड लिखकर ऊपर वर्णित सीमाओं ( एलईडी की कम वर्तमान / चमक और एलईडी पर कार्यक्रम नियंत्रण की कमी ) को दूर कर सकते हैं! एलईडी को नियंत्रित करने की क्षमता और इसके कारण टूट गई स्थिति की पहचान के बीच संघर्ष को हल करने के लिए, हम समय में दो कार्यों को अलग कर सकते हैं, अर्थात् सेंसर संपर्क (3) को पढ़ते समय अस्थायी रूप से एलईडी को बंद कर सकते हैं।

सबसे पहले, [दीपक] पिन को दूसरे सामान्य-उद्देश्य वाले अरुडिनो पिन से कनेक्ट करें, उदाहरण के लिए, 4 से ताकि आप दीपक को नियंत्रित कर सकें।

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

 int pinSwitch = 3; int pinLed = 4; void setup() { //connect to the PC Serial.begin(9600); //connect our switch's [+] connector to a digital sensor, and to +5V through a large resistor pinMode(pinSwitch, INPUT_PULLUP); //connect our switch's [lamp] connector to 0V or +5V directly pinMode(pinLed, OUTPUT); } void loop() { int lampOn = (millis()>>8)&1;//make a variable that alternates between 0 and 1 over time digitalWrite(pinLed, LOW);//connect our [lamp] to +0V so the read is clean int state = digitalRead(pinSwitch); if( lampOn ) digitalWrite(pinLed, HIGH);//connect our [lamp] to +5V Serial.println(state);//report the switch state to the PC } 

Arduino मेगा में, पिन 2-13 और 44-46 एनालॉगवर्ट फ़ंक्शन का उपयोग कर सकते हैं, जो वास्तव में 0V से + 5V तक वोल्टेज उत्पन्न नहीं करता है, लेकिन इसे एक वर्ग तरंग का उपयोग करके अनुमानित करता है। यदि वांछित है, तो आप इसे एलईडी की चमक को नियंत्रित करने के लिए उपयोग कर सकते हैं! यह कोड प्रकाश स्पंदित करेगा, न कि केवल झिलमिलाहट:

 void loop() { int lampState = (millis()>>1)&0xFF;//make a variable that alternates between 0 and 255 over time digitalWrite(pinLed, LOW);//connect our [lamp] to +0V so the read is clean int state = digitalRead(pinSwitch); if( lampState > 0 ) analogWrite(pinLed, lampState); } 

असेंबली टिप्स

पोस्ट पहले से ही काफी बड़ी है, इसलिए मैंने सोल्डरिंग ट्यूटोरियल नहीं जोड़ा, आप इसे गूगल कर सकते हैं!

हालाँकि, मैं सबसे बुनियादी सुझाव दूंगा:

• बड़े धातु संपर्कों के साथ तारों को जोड़ने पर, पहले सुनिश्चित करें कि टांका लगाने वाला लोहा गर्म है और थोड़ी देर के लिए धातु के संपर्क को गर्म करें। टांका लगाने का अर्थ एक मिश्र धातु का निर्माण करके एक स्थायी कनेक्शन बनाना है, लेकिन यदि कनेक्शन का केवल एक हिस्सा गर्म है, तो आप आसानी से एक "ठंडा कनेक्शन" प्राप्त कर सकते हैं जो कनेक्शन की तरह दिखता है, लेकिन वास्तव में जुड़ा नहीं है।
  
• जब दो तारों को जोड़ते हैं, तो पहले उनमें से एक पर हीट-सिकुड़ ट्यूबिंग का एक टुकड़ा डालें - कनेक्शन के बाद, ट्यूबिंग को नहीं डाला जा सकता है। यह स्पष्ट प्रतीत होता है, लेकिन मैं इसे लगातार भूल जाता हूं और मुझे ट्यूब के बजाय विद्युत टेप का उपयोग करना पड़ता है ... सिकुड़ ट्यूब को कनेक्शन से दूर खींचो ताकि यह समय से पहले गर्म न हो। टांका लगाने वाले कनेक्शन की जांच करने के बाद, ट्यूब को उस पर स्लाइड करें और इसे गर्म करें।
  
• शुरुआत में जिन पतले छोटे कनेक्टिंग तारों का मैंने उल्लेख किया, वे सोल्डरलेस कनेक्शन के लिए अच्छी तरह से अनुकूल हैं (उदाहरण के लिए, जब एक Arduino से जुड़ा होता है!), लेकिन बल्कि नाजुक। टांका लगाने के बाद, उन्हें ठीक करने के लिए एक गोंद बंदूक का उपयोग करें और कनेक्शन से सभी तनावों को हटा दें। उदाहरण के लिए, नीचे की तस्वीर में लाल तारों को गलती से ऑपरेशन के दौरान खींचा जा सकता है, इसलिए टांका लगाने के बाद मैंने उन्हें गर्म पानी की एक बूंद के साथ तय किया:
  
  
  

भाग 2. हम डिवाइस को गेम कंट्रोलर में बदल देते हैं!

USB गेमिंग कंट्रोलर के रूप में डिवाइस को पहचानने के लिए OS के लिए, आपको काफी सरल कोड की आवश्यकता होती है, लेकिन, दुर्भाग्यवश, आपको Arduino USB चिप फर्मवेयर को दूसरे के साथ बदलने की भी आवश्यकता है, जिसे यहां लिया जा सकता है: https://github.com/harlequin-tech-arduino-usb ।

लेकिन इस फर्मवेयर को Arduino पर अपलोड करने के बाद, डिवाइस USB जॉयस्टिक बन जाता है और Arduino होना बंद हो जाता है। इसलिए, इसे पुन: उत्पन्न करने के लिए, आपको मूल Arduino फर्मवेयर को फिर से फ्लैश करने की आवश्यकता है। ये पुनरावृत्तियाँ काफी दर्दनाक हैं - Arduino कोड लोड करें, जॉयस्टिक फर्मवेयर फ़्लैश करें, परीक्षण करें, फ़्लैश arduino फर्मवेयर, दोहराएं ...

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

 // define DEBUG if you want to inspect the output in the Serial Monitor // don't define DEBUG if you're ready to use the custom firmware #define DEBUG //Say we've got three buttons, connected to GND and pins 2/3/4 int pinButton1 = 2; int pinButton2 = 3; int pinButton3 = 4; void setup() { //configure our button's pins properly pinMode(pinButton1, INPUT_PULLUP); pinMode(pinButton2, INPUT_PULLUP); pinMode(pinButton3, INPUT_PULLUP); #if defined DEBUG Serial.begin(9600); #else Serial.begin(115200);//The data rate expected by the custom USB firmware delay(200); #endif } //The structure expected by the custom USB firmware #define NUM_BUTTONS 40 #define NUM_AXES 8 // 8 axes, X, Y, Z, etc typedef struct joyReport_t { int16_t axis[NUM_AXES]; uint8_t button[(NUM_BUTTONS+7)/8]; // 8 buttons per byte } joyReport_t; void sendJoyReport(struct joyReport_t *report) { #ifndef DEBUG Serial.write((uint8_t *)report, sizeof(joyReport_t));//send our data to the custom USB firmware #else // dump human readable output for debugging for (uint8_t ind=0; ind<NUM_AXES; ind++) { Serial.print("axis["); Serial.print(ind); Serial.print("]= "); Serial.print(report->axis[ind]); Serial.print(" "); } Serial.println(); for (uint8_t ind=0; ind<NUM_BUTTONS/8; ind++) { Serial.print("button["); Serial.print(ind); Serial.print("]= "); Serial.print(report->button[ind], HEX); Serial.print(" "); } Serial.println(); #endif } joyReport_t joyReport = {}; void loop() { //check if our buttons are pressed: bool button1 = LOW == digitalRead( pinButton1 ); bool button2 = LOW == digitalRead( pinButton2 ); bool button3 = LOW == digitalRead( pinButton3 ); //write the data into the structure joyReport.button[0] = (button1?0x01:0) | (button2?0x02:0) | (button3?0x03:0); //send it to the firmware sendJoyReport(joyReport) } 

भाग 3. हम डिवाइस को अपने गेम के साथ एकीकृत करते हैं!

यदि आपके पास उस गेम पर नियंत्रण है जिसके साथ डिवाइस को बातचीत करनी चाहिए, तो एक विकल्प के रूप में आप सीधे नियंत्रक के साथ संवाद कर सकते हैं - ओएस को जॉयस्टिक के रूप में इसे दिखाई देने की कोई आवश्यकता नहीं है! पोस्ट की शुरुआत में, मैंने अंतरिक्ष में वस्तुओं का उल्लेख किया; यह वह तरीका है जो इसके डेवलपर्स उपयोग करते हैं। उन्होंने एक सरल ASCII संचार प्रोटोकॉल बनाया जो नियंत्रक और खेल को एक दूसरे के साथ संवाद करने की अनुमति देता है। बस सिस्टम के सीरियल पोर्ट्स को सूचीबद्ध करें ( वे विंडोज पर COM पोर्ट हैं; वैसे, सी में कितना भयानक दिखता है ), उस पोर्ट को ढूंढें जिसमें "Arduino" नामक डिवाइस जुड़ा हुआ है, और इस लिंक से ASCII पढ़ना / लिखना शुरू करें।

Arduino की तरफ, हम सिर्फ Serial.print फ़ंक्शन का उपयोग करते हैं जो ऊपर दिए गए उदाहरणों में उपयोग किए गए थे।

इस पोस्ट की शुरुआत में, मैंने इस समस्या को हल करने के लिए अपनी लाइब्रेरी का भी उल्लेख किया: https://github.com/hodgman/ois_protocol ।

इसमें C ++ कोड होता है जिसे खेल में एकीकृत किया जा सकता है और इसे "सर्वर" के रूप में उपयोग किया जाता है, और Arduino कोड जिसे नियंत्रक में "क्लाइंट" के रूप में उपयोग करने के लिए निष्पादित किया जा सकता है।

Arduino को अनुकूलित करें

Example_hardware.h में, मैंने अलग-अलग बटन / रेडियो बटन के लिए कक्षाएं बनाईं ; उदाहरण के लिए, "स्विच" पहले उदाहरण से एक साधारण बटन है। और "LEDSwitch2Pin" एक स्विच है जिसका दूसरे उदाहरण से नियंत्रित एलईडी है।

मेरे बटन बार का नमूना कोड example.ino में है ।

एक छोटे से उदाहरण के रूप में, मान लें कि हमारे पास एक एकल बटन है जिसे गेम में भेजने की आवश्यकता है, और एक गेम-नियंत्रित एलईडी। आवश्यक Arduino कोड इस तरह दिखता है:

 #include "ois_protocol.h" //instantiate the library OisState ois; //inputs are values that the game will send to the controller struct { OisNumericInput myLedInput{"Lamp", Number}; } inputs; //outputs are values the controller will send to the game struct { OisNumericOutput myButtonOutput{"Button", Boolean}; } outputs; //commands are named events that the controller will send to the game struct { OisCommand quitCommand{"Quit"}; } commands; int pinButton = 2; int pinLed = 3; void setup() { ois_setup_structs(ois, "My Controller", 1337, 42, commands, inputs, outputs); pinMode(pinButton, INPUT_PULLUP); pinMode(pinLed, OUTPUT); } void loop() { //read our button, send it to the game: bool buttonPressed = LOW == digitalRead(pin); ois_set(ois, outputs.myButtonOutput, buttonPressed); //read the LED value from the game, write it to the LED pin: analogWrite(pinLed, inputs.myLedInput.value); //example command / event: if( millis() > 60 * 1000 )//if 60 seconds has passed, tell the game to quit ois_execute(ois, commands.quitCommand); //run the library code (communicates with the game) ois_loop(ois); } 

खेल को अनुकूलित करें

गेम कोड "सिंगल हेडर" की शैली में लिखा गया है। पुस्तकालय को आयात करने के लिए खेल में oisdevice.h को शामिल करें।

एक एकल CPP फ़ाइल में, #include हैडर निष्पादित करने से पहले, #define OIS_DEVICE_IMPL और #define OIS_SERIALPORT_IMPL लिखें - यह CPP फ़ाइल में कक्षाओं का स्रोत कोड जोड़ देगा। यदि आपके पास अपने स्वयं के बयान, लॉगिंग, स्ट्रिंग्स या वैक्टर हैं, तो कई अन्य ओआईएस_ * मैक्रोज़ हैं जिन्हें आप इंजन की क्षमताओं का लाभ उठाने के लिए हेडर आयात करने से पहले परिभाषित कर सकते हैं।

COM पोर्ट को सूचीबद्ध करने और किसी विशिष्ट डिवाइस के साथ कनेक्शन बनाने के लिए, आप निम्न कोड का उपयोग कर सकते हैं:

 OIS_PORT_LIST portList; OIS_STRING_BUILDER sb; SerialPort::EnumerateSerialPorts(portList, sb, -1); for( auto it = portList.begin(); it != portList.end(); ++it ) { std::string label = it->name + '(' + it->path + ')'; if( /*device selection choice*/ ) { int gameVersion = 1; OisDevice* device = new OisDevice(it->id, it->path, it->name, gameVersion, "Game Title"); ... } } 

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

यह सब करने वाला एक उदाहरण एप्लिकेशन यहां पाया जा सकता है: example_ois2vjoy / main.cpp ।

भाग 4. अगर मैं एक ही समय में 2 और 3 भाग चाहता हूं तो क्या होगा?

नियंत्रक के लिए अन्य खेलों (भाग 2) में काम करने के लिए, आपको अपने स्वयं के फर्मवेयर और एक Arduino प्रोग्राम को स्थापित करने की आवश्यकता है, लेकिन नियंत्रक द्वारा खेल को पूरी तरह से प्रोग्राम करने के लिए, हमने मानक Arduino फर्मवेयर और एक अन्य Arduino प्रोग्राम का उपयोग किया। लेकिन क्या होगा अगर हम एक ही समय में दोनों संभावनाएं चाहते हैं?

नमूना आवेदन जिसके ऊपर मैंने लिंक दिया था ( ois2vjoy ) इस समस्या को हल करता है।

यह एप्लिकेशन OIS डिवाइस (पार्ट 3 से प्रोग्राम) के साथ संचार करता है, और फिर पीसी पर इस डेटा को नियमित नियंत्रक / जॉयस्टिक डेटा में परिवर्तित करता है, जो तब वर्चुअल कंट्रोलर / जॉयस्टिक डिवाइस में स्थानांतरित हो जाते हैं। इसका मतलब यह है कि आप अपने नियंत्रक को ओआईएस लाइब्रेरी (किसी अन्य फर्मवेयर की आवश्यकता नहीं है) का लगातार उपयोग करने की अनुमति दे सकते हैं, और अगर हम इसे नियमित नियंत्रक / जॉयस्टिक के रूप में उपयोग करना चाहते हैं, तो बस पीसी पर ओआईएस 2vjoy एप्लिकेशन चलाएं, जो रूपांतरण करता है।

भाग 5. पूर्णता

मुझे आशा है कि किसी को यह लेख उपयोगी या दिलचस्प लगा। अंत तक पढ़ने के लिए धन्यवाद!

यदि आप उत्सुक हैं, तो मैं आपको ois_protocol लाइब्रेरी के विकास में भाग लेने के लिए आमंत्रित करता हूं ! मुझे लगता है कि खेलों में सभी प्रकार के घर-निर्मित नियंत्रकों का समर्थन करने के लिए एक एकल प्रोटोकॉल विकसित करना और खेलों को घर-निर्मित नियंत्रकों को सीधे समर्थन देने के लिए प्रोत्साहित करना बहुत अच्छा होगा!