🏂🏻 🈶 👺 हम रास्पबेरी पाई का उपयोग करके Xbox 360 से PSP गेमपैड से कनेक्ट करते हैं 🔊 👩‍💻 🚣🏽

... या एक कहानी के बारे में कि कैसे एक पेंगुइन ने अमेरिका और जापान के साथ दोस्ती की।

इसलिए, प्राचीन समय में, लोग सोनी प्लेस्टेशन पर खेलते थे और वे हर चीज से खुश थे। लेकिन प्रगति तब भी टिक नहीं पाई। Microcircuits के एकीकरण की डिग्री में वृद्धि हुई। इंजीनियरिंग ने सोचा था कि लगातार नए फॉर्म कारकों की तलाश की जा रही है, और मार्केटिंग ने सोचा कि नए बाजारों की तलाश है। इसलिए 2005 में, सोनी Playstation पोर्टेबल, एक पोर्टेबल गेमिंग सिस्टम, जापान के बाहर बिक्री पर चला गया । उसकी गेम लाइन (किसी अन्य कंसोल के साथ) PSP आयरन गेम्स के लिए विशेष रूप से संकलित थी। लेकिन उसके पास अंतर्निहित इम्यूलेटर के माध्यम से मूल प्लेस्टेशन से गेम चलाने के लिए पर्याप्त कंप्यूटिंग शक्ति भी थी। यद्यपि, शायद, मुख्य भूमिका इस तथ्य से निभाई गई थी कि PlayStation और PSP दोनों में एक ही आर्किटेक्चर का प्रोसेसर था - अर्थात्, MIPS। लेकिन इस प्रणाली के बारे में सबसे उल्लेखनीय बात यह है कि लॉन्च के वर्ष में, तुरंत, PSP एसडीके पुस्तकालय नेटवर्क पर लीक हो गए। नतीजतन, लॉन्च के लगभग 10 साल बाद, हमारे पास खेलों की एक विशाल लाइब्रेरी और अच्छी तरह से काम कर रहे होमब्रेव हैं। इसके अलावा, अब, रूस के सबसे बड़े शहर में नहीं, एक पूरी तरह से काम कर रहे PSP (सबसे कार्यात्मक संशोधन) 3000 रूबल के लिए खरीदा जा सकता है। यह सब इसे वर्तमान में एक बहुत ही आकर्षक बजट गेमिंग सिस्टम बनाता है जिसमें सिर्फ एक विशाल इंस्टॉलेशन बेस है। सबसे कार्यात्मक संशोधन में एक टीवी से कनेक्ट करने के लिए एक घटक आउटपुट है। लेकिन लंबे समय तक PSP को गेमपैड के रूप में उपयोग करने के मामले में टीवी कनेक्टर अच्छी तरह से तैनात नहीं है। इसके अलावा, लंबे समय तक उपयोग के साथ, चार्जर से - एक दूसरे तार को कनेक्ट करना आवश्यक हो जाता है। और इस तरह के चिमेरा की उपयोगिता शून्य हो जाती है। इस समस्या को अपेक्षाकृत सस्ते और एक ही समय में geeky से कैसे हल किया जाए - इस लेख में इस पर चर्चा की जाएगी। इसके अलावा संक्षेप में PSP के लिए USB क्लाइंट ड्राइवर की प्रोग्रामिंग के विषय हैं, PSP में हुक कार्यों को स्थापित करने की विधि, USB उपकरणों के साथ लिनक्स के तहत और एपीआई के माध्यम से जॉयस्टिक के साथ काम करना। हम शुरू कर रहे हैं।

पोर्टेबल कंसोल को टीवी से जोड़ने का विचार नया नहीं है

लेकिन हम शुरू करने से पहले, मैं आपको एक दिलचस्प तथ्य के बारे में बताऊंगा। चूंकि PSP लगभग 10 साल पहले जारी किया गया था, सोनी की पोर्टेबल कंसोल की अगली पीढ़ी, जिसका नाम सोनी प्लेस्टेशन वीटा है, वर्तमान में प्रासंगिक है। और तथ्य यह है कि जापान में एक पोर्टेबल कंसोल का एक स्थिर संस्करण था। सोनी प्लेस्टेशन वीटा टीवी।

पीएस वीटा टी.वी.

गेमपैड के रूप में, यह Playstation 3 से सामान्य ड्यूलशॉक 3 का उपयोग करता है। यह यूएसबी या ब्लूटूथ कनेक्शन का समर्थन करता है। वीटा की तरह वीटा टीवी, मूल प्लेस्टेशन से वीटा, पीएसपी और गेम खेल सकते हैं। इस प्रकार, "स्थिर पोर्टेबल" कंसोल का विचार काफी सुसंगत और दिलचस्प है।

दोस्तों को गेमपैड और पीएसपी बनाने के लिए क्या?

अगला, सवाल उठता है कि एक बाहरी गेमपैड को पीएसपी से कैसे जोड़ा जाए। ऐसा लगता है कि पीएसपी में एक यूएसबी कनेक्टर है, जिसके माध्यम से उत्साही लोगों ने पीएसपी को कनेक्टेड कंप्यूटर के फ़ोल्डर से गेम चलाना सिखाया है या गेम के साथ पूरी तस्वीर को इसी यूएसबी कनेक्टेड कंप्यूटर की विंडो में ट्रांसफर किया है । लेकिन, जैसा कि यह निकला , पीएसपी में यूएसबी केवल एक ग्राहक हो सकता है। और यहां तक कि आधिकारिक सामान (उदाहरण के लिए, कैमरा) होस्ट मोड में काम करता है (वैसे, एंड्रॉइड में बाह्य उपकरणों के साथ काम करने पर Google स्मार्टफोन को क्लाइंट मोड में स्विच करने की सिफारिश करता है)। यानी एक PSP के लिए एक गेमपैड को सीधे कनेक्ट करना बेकार है। इसलिए, आपको किसी प्रकार के मध्यवर्ती उपकरण की आवश्यकता है। एक स्थानीय इलेक्ट्रॉनिक स्टोर में, अलग-अलग डिग्री के डिबग बोर्ड की लागत 1 से 10 हजार रूबल तक होती है। जबकि ये माइक्रोकंट्रोलर हैं, आपको अलग से USB होस्ट के बारे में सोचने की आवश्यकता है। फिर रास्पबेरी पाई ने मेरी आंख को पकड़ लिया।

रास्पबेरी पाई

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

पढ़ाई शुरू

यदि आप बस USB केबल को PSP से जोड़ते हैं, तो यह USB फ्लैश ड्राइव के रूप में दिखाई देगा। हमें बाहरी प्रबंधन के बारे में आज्ञाओं को स्वीकार करने की आवश्यकता है। यानी PSP में किसी प्रकार का कोड घूमना चाहिए जो USB के माध्यम से जानकारी प्राप्त करेगा और PSP पर नियंत्रण के दबाव का अनुकरण करेगा। लाइसेंस प्राप्त खेलों के अलावा कुछ कोड चलाने की बहुत क्षमता केवल पायरेटेड फर्मवेयर पर संभव है। तकनीकी रूप से, पायरेटेड फर्मवेयर एक प्रोग्राम है जो मेमोरी कार्ड पर स्थित एक आधिकारिक कार्यक्रम होने का दिखावा करता है, और जिसे लॉन्च करने पर रैम में काम करने वाले फर्मवेयर कोड को एक संशोधित के साथ बदल देता है जो आपको PSP कंप्यूटर कार्ड से .iso फ़ाइलों से गेम चलाने की अनुमति देता है। इस प्रकार, फर्मवेयर अगले PSP रिबूट तक आसानी से चलता है। लेकिन जो हमारे लिए मायने रखता है वह यह नहीं है, बल्कि यह तथ्य कि यह प्लगइन्स का समर्थन करता है। प्लगइन्स एक विशिष्ट प्रारूप में जुड़ी हुई ऑब्जेक्ट फाइलें हैं, जो मुख्य मेनू, पीएसपी गेम या मूल Playstation के गेम लॉन्च करने के समानांतर अलग-अलग धाराओं में शुरू होती हैं। मूल PSP फर्मवेयर का नवीनतम संस्करण पहले से ही 6.60 है। फर्मवेयर के पुराने संस्करणों के लिए तेज किए गए प्लगइन्स नवीनतम फर्मवेयर के तहत काम नहीं कर सकते हैं। इस मामले में ऐसा ही हुआ। एक प्लगइन जो एक PSP से एक विंडोज-आधारित पीसी वीडियो के लिए एक PSP से USB के माध्यम से स्थानांतरित कर सकता है जो PSP पर होता है और PSP में एक पीसी से जुड़े गेमपैड से डेटा प्राप्त करता है, यूएसबी के माध्यम से केवल आधा फर्मवेयर 6.60 पर काम करता है, अर्थात्। गेमपैड से पीएसपी तक डेटा पहुंच गया, लेकिन पीएसपी नियंत्रण के नियंत्रण के सिमुलेशन ने काम नहीं किया। मैंने ऐसे प्लगइन्स की तलाश शुरू की जो किसी तरह फर्मवेयर 6.60 पर नियंत्रण के साथ काम करें। और मिल गया। PSP एनालॉग स्टिक के साथ काम करने के लिए एक अन्य प्लगइन का उपयोग किया जाता है, और यह नवीनतम फर्मवेयर पर काम करता है। सभी PSP स्रोतों को इस होमब्रे एसडीके के साथ संकलित किया गया है।

PSP प्लगइन्स के लिए स्रोत कोड का संशोधन। Hooky।

प्लग-इन प्रोजेक्ट के आधार पर जिसे मैं संशोधित करूंगा, मैंने वह चुना है जिसमें पहले से ही USB क्लाइंट का कार्य कोड शामिल था। लेकिन सामान्य डिबगिंग और आम तौर पर आरामदायक वातावरण के लिए, मुझे प्रिंटफ () की आवश्यकता थी। पीएसपी पर। यह चयनित प्लगइन में नहीं था। लेकिन प्लगइन में, जिसमें से मैं PSP नियंत्रणों की घटनाओं को रोकने के लिए काम करने वाले कोड को बाहर निकालना चाहता था, यह फ्रेम फ्रेम के लिए अगले फ्रेम को ड्राइंग करने और मुझे डिबग लाइनों को जोड़ने की आवश्यकता थी, जो कि फ्रेम में मुझे जरूरत थी। रेंडरिंग के कैप्चर फंक्शन (हुक) को इस प्रकार लागू किया जाता है:

#define GET_JUMP_TARGET_(x) (0x80000000 | (((x) & 0x03FFFFFF) << 2)) int (*g_setframebuf)(int unk, void* addr, int width, int psm, int sync); int setframebuf_hook_func(int unk, void* addr, int width, int psm, int sync) { if(g_info == 1) { dbgprint( debugmsg, addr, psm ); if (!g_info) DEBUG_RESET() } return g_setframebuf(unk, addr, width, psm, sync); } int hook_function(unsigned int* jump, void* hook, unsigned int* result) { unsigned int target; unsigned int func; int inst; target = GET_JUMP_TARGET_(*jump); while (((inst = _lw(target+4)) & ~0x03FFFFFF) != 0x0C000000) // search next JAL instruction target += 4; if((inst & ~0x03FFFFFF) != 0x0C000000) { printf("invalid!\n"); return 1; } *result = GET_JUMP_TARGET_(inst); func = (unsigned int) hook; func = (func & 0x0FFFFFFF) >> 2; _sw(0x0C000000 | func, target+4); return 0; } int module_start( SceSize args, void *argp ) { //... hook_function( (unsigned int*) sceDisplaySetFrameBuf, setframebuf_hook_func, (unsigned int*)&g_setframebuf ); //... }

अपने आंतरिक कर्नेल फ़ंक्शन को कॉल करने के बाद, PSP ऑपरेटिंग सिस्टम, PSP ऑपरेटिंग सिस्टम को कॉल करने के बाद, sceDisplaySetFrameBuf () वास्तव में setframebuf_hook_func () कॉल करेगा। और मूल sceDisplaySetFrameBuf () को कॉल करने के लिए अब आपको g_setframebuf () को कॉल करने की आवश्यकता है। हुक के विषय में रुचि रखने वाले किसी भी व्यक्ति को यहां अधिक विवरण में पाया जा सकता है ।

PSP प्लगइन्स के लिए स्रोत कोड का संशोधन। प्रबंधन।

इसके बाद, मैंने प्रबंधन कार्य sceCtrlReadBufferPositive (), sceCtrlPeekBufferPositive (), sceCtrlReadBufferNegative () और sceCtrlPeekBufferNegative () से उन्हें लेते हुए प्रोजेक्ट हुक में काम के हुक जोड़े। मैंने अभी यह सुनिश्चित किया है कि पीसी के होस्ट से जुड़े गेमपैड की स्थिति के बारे में PSP के लिए भेजा गया आखिरी डेटा उनके अंदर इनपुट डेटा था। यहां सभी आवश्यक बायनेरिज़ और स्रोत कोड के साथ एक संग्रह है । कार्यक्रम के पीसी भाग को शुरू करने से पहले, आपको यूएसबी चालक को स्थापित करने की आवश्यकता है। सबसे पहले आपको PSP पर प्लगइन चलाने की जरूरत है (आप सीख सकते हैं कि Yandex में googling द्वारा प्लगइन कैसे चलाएं)। फिर PSP को पुनरारंभ करें और इसे पीसी से कनेक्ट करें। एक PSP प्रकार बी डिवाइस का पता लगाया जाना चाहिए। इसके बाद, ड्राइवरों को डाउनलोड करें। विज़ार्ड के माध्यम से ड्राइवर को स्थापित करें (बिन \ inf- विज़ार्ड। Exe), हमारे PSP प्रकार बी डिवाइस की ओर इशारा करते हुए और आपको ड्राइवर को अंत में स्थापित करने के लिए कह रहा है।

न्यूनतम PSP संस्करण तैयार करना

सबकुछ ठीक होगा, लेकिन नेटवर्क में केवल 0.19 रिमोटजॉयलाइट संस्करण के लिए स्रोत कोड हैं। और यह कुछ गेम पर सही तरीके से काम नहीं करता है (उदाहरण के लिए, के-ऑन! बेतहाशा धीमा है, और ग्राफिक आर्टिफ़िक डंगऑन सीज़र में दिखाई देते हैं)। संस्करण ०.२० में कहा गया है कि यह तय हो गया है, लेकिन इस संस्करण के लिए स्रोत कोड सार्वजनिक रूप से उपलब्ध नहीं है। इसलिए, गेमपैड की स्थिति के बारे में केवल न्यूनतम जानकारी प्रसारित करने के लिए, साथ ही पीएसपी भाग के स्रोत के आकार को कम करने के लिए यूएसबी के माध्यम से प्रसारित डेटा के प्रोटोकॉल को संशोधित करने का निर्णय लिया गया था। PSP से PC में स्थानांतरित सभी डेटा को प्रोटोकॉल से हटा दिया गया था, और केवल एक संरचना को PC से PSP में स्थानांतरित कर दिया गया था, जिसके परिणामस्वरूप ब्रेक और कलाकृतियां गुमनामी में गायब हो गईं:

 #define USBDATA_PATTERN 0x1234ABFE struct { unsigned int Pattern; unsigned int ButtonData; unsigned int AnalogX; unsigned int AnalogY; } PSPUsbData;

स्वयं पीएसपी में छड़ी से एनालॉग डेटा को प्रत्येक अक्ष (127 केंद्र) के लिए एकल-बाइट अहस्ताक्षरित पूर्णांक के रूप में प्रस्तुत किया जाता है, और प्रोटोकॉल में 4 बाइट्स आवंटित किए जाते हैं, क्योंकि संरचनाओं की पैकिंग और संरेखण की समस्याओं के बारे में भी नहीं सोचना चाहते हैं, क्योंकि RemoteJoyLite में ही, डेटा निम्नानुसार पैक किया जाता है:

 struct HostFsCmd { uint32_t magic; uint32_t command; uint32_t extralen; } __attribute__((packed));

और इसी समस्याओं के बारे में सोचने के लिए भी नहीं (आखिरकार, रिमोटजॉयलाइट खुद MinGW GCC द्वारा संकलित किया गया है, और अगला कदम Microsoft Visual Studio में एक छोटा प्रोटोकॉल बनाने के लिए एक प्रोजेक्ट बनाना है जो __attribute __ ((पैक)) के बारे में नहीं जानता), मैंने सभी संरेखण और पैकेजिंग संरचना को हटा दिया है) उन्हें 32-बिट प्रतिनिधित्व में लाना। नतीजतन, इस संग्रह में एक छीन-नीचे परियोजना के स्रोत कोड और बायनेरिज़ हैं - दोनों PSP- और विंडोज-पार्ट। Windows अनुप्रयोग को Microsoft Visual Studio 2010 के लिए C ++ में mfc प्रोजेक्ट के रूप में डिज़ाइन किया गया है। Windows प्रोग्रामर के लिए, यह देखना उपयोगी होगा कि कर्सर नियंत्रण कीस्ट्रोक्स कैसे कार्यान्वित किया जाता है (mfc अनुप्रयोगों में, यह केवल तभी काम करता है जब यह संपूर्ण अनुप्रयोग के विंडो संदेश फ़िल्टर में हो, और संवाद कीस्ट्रोक में नहीं), और एक अलग स्ट्रीम से भी प्रिंटफ़ () फॉर्म पर सही ढंग से काम करने के कारण। पीएसपी भाग में, संलग्न हल्के स्रोत का अध्ययन करना दिलचस्प होगा, जिसमें केवल यूएसबी, नियंत्रण और प्रिंटफ () शेष हैं। उदाहरण के लिए, USB डेटा रिसेप्शन अतुल्यकालिक है और निम्नानुसार कार्यान्वित किया जाता है। USB होस्ट से कनेक्ट करते समय, USB बस पर आंतरिक पता प्राप्त करने की सही प्रक्रिया (USB विवरण देखें) के बाद, एक UsbAttach () कॉल किया जाता है, क्योंकि यह कॉल आरंभीकरण के दौरान पंजीकृत ड्राइवर संरचना में वर्णित था:

 #define RJLITE_DRIVERNAME "RJLiteDriver" #define RJLITE_DRIVERPID (0x1C9) struct UsbDriver UsbDriver = { RJLITE_DRIVERNAME, 4, UsbEndpoint, &UsbInterface, &UsbData[0].devdesc[0], &UsbData[0].config, &UsbData[1].devdesc[0], &UsbData[1].config, &StringDescriptor, UsbRequest, UsbUnknown, UsbAttach, UsbDetach, 0, UsbStartFunc, UsbStopFunc, NULL }; int module_start( SceSize args, void *argp ) { //... sceUsbbdRegister(&UsbDriver); if((sceUsbStart(PSP_USBBUS_DRIVERNAME, 0, 0) == 0) && (sceUsbStart(RJLITE_DRIVERNAME, 0, 0) == 0) && //... { //... } //... }

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

 static SceUID UsbMainEventFlag = -1; static int UsbStartFunc( int size, void *p ) { //... UsbMainEventFlag = sceKernelCreateEventFlag( "USBMainEvent", 0x200, 0, NULL ); //... UsbMainThreadID = sceKernelCreateThread( "USBMainThread", UsbMainThread, 10, 0x10000, 0, NULL ); //... sceKernelStartThread( UsbMainThreadID, 0, NULL ); //... }

तो, और UsbAttach कहा जाता है () UsbMainEventFlag ऑब्जेक्ट के ध्वज चर में फ्लैग USB_EVENT_ATTACH सेट करता है:

 static int UsbAttach(int speed, void *arg2, void *arg3) { sceKernelSetEventFlag( UsbMainEventFlag, USB_EVENT_ATTACH); return 0; }

उसी समय, UsbMainThread () थ्रेड में पूर्व में UsbStartFunc () कॉल करते समय बनाया गया, यह कहता है:

 static int UsbMainThread(SceSize size, void *argp) { int ret; u32 result; while(1) { ret = sceKernelWaitEventFlag(UsbMainEventFlag, USB_EVENT_ATTACH | USB_EVENT_ASYNC, PSP_EVENT_WAITOR | PSP_EVENT_WAITCLEAR, &result, NULL); if(ret < 0) { sceKernelExitDeleteThread(0); } if(result&USB_EVENT_ASYNC) { usb_async_events++;//nyashkoshkko: debug SetUsbAyncReq(&PSPUsbData, sizeof(PSPUsbData)); } if(result&USB_EVENT_ATTACH) { usb_attach_events++;//nyashkoshkko: debug SetUsbAyncReq(&PSPUsbData, sizeof(PSPUsbData)); } } return 0; }

इसका अर्थ यह है कि अनंत लूप में थ्रेड USB_EVENT_ATTACH ध्वज या USB_EVENT_ASYNC ध्वज के लिए प्रतीक्षा करता है ताकि UsbMainEventFlag ऑब्जेक्ट के ध्वज चर में सेट किया जा सके। USB होस्ट के साथ सफल कनेक्शन के कारण USB_EVENT_ATTACH ध्वज की स्थापना हुई, जिसके द्वारा यह धागा USB के माध्यम से डेटा पैकेट प्राप्त करने के लिए एक अतुल्यकालिक अनुरोध करता है, जबकि USB_EVENT_ASTNC ध्वज को रीसेट करता है:

 static int SetUsbAyncReq( void *data, int size ) { //... UsbAsyncReq.data = data; UsbAsyncReq.size = size; UsbAsyncReq.func = UsbAsyncReqDone; sceKernelClearEventFlag( UsbMainEventFlag, ~USB_EVENT_ASYNC ); return( sceUsbbdReqRecv( &UsbAsyncReq ) ); }

इस अनुरोध में, कॉलबैक UsbAsyncReqDone () फ़ंक्शन के लिए कॉल सेट करता है:

 static int UsbAsyncReqDone( struct UsbdDeviceReq *req, int arg2, int arg3 ) { sceKernelSetEventFlag( UsbMainEventFlag, USB_EVENT_ASYNC ); return( 0 ); }

यह फ़ंक्शन, जैसा कि हम देखते हैं, USB होस्ट से डेटा पैकेट प्राप्त करने के पूरा होने पर (PSP USB नियंत्रक से पीएसपी ऑपरेटिंग सिस्टम कर्नेल द्वारा संसाधित किया जाता है) UsbbainEventFlag ऑब्जेक्ट के ध्वज चर में ध्वज USB_EVENT_ASYNC सेट करता है। उस पर, हमारा अंतहीन लूप एक नया एसिंक्रोनस डेटा अनुरोध सेट करता है। इस तरह की एक घटना तंत्र आपको डेटा तैयार ध्वज को पूरी तरह से मतदान करने पर सीपीयू समय बर्बाद करने की अनुमति नहीं देता है, क्योंकि जब आप sceKernelWaitEventFlag () को कॉल करते हैं, तो स्ट्रीम को समय स्लाइस आवंटित नहीं किया जाता है जब तक आवश्यक घटना नहीं होती है - यह PSP ऑपरेटिंग सिस्टम के अंदर थ्रेड अनुसूचक द्वारा सुनिश्चित किया जाता है, और वास्तव में यह सुनिश्चित करता है। मूल सिद्धांत किसी भी मल्टीटास्किंग ऑपरेटिंग सिस्टम में काम करता है।

रास्पबेरी पाई के तहत लिनक्स के लिए यूएसबी के साथ काम करने के लिए एक सेवा लिखना

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

 > yum install libusb1-devel

पैकेज प्रबंधक में झगड़ा हुआ और उसने कहा कि यह पुराना है, लिबासबक्स का उपयोग करें। ठीक है टीम

 > yum install libusbx-devel

आवश्यक फ़ाइलों को डाउनलोड किया। लेकिन तथ्य यह है कि एपीआई कॉल पर लिबसबक्स लिबास 1 के साथ असंगत है, जो कि लिबासब के विंडोज़ संस्करण के समान है, जो बदले में मूल रिमोटजॉयलाइट स्रोतों में उपयोग किया गया था, और आमतौर पर विंडोज के तहत काम करता है। लेकिन ठीक है। USB के साथ, अब लिनक्स के नीचे से गेमपैड को एक्सेस करने के लिए आगे बढ़ते हैं। मेरे पास मेरे निपटान में एक वायर्ड Xbox 360 गेमपैड है जो विंडोज पर बहुत अच्छा लगता है और, आश्चर्यजनक रूप से, रास्पबेरी पाई पर फेडोरा रीमिक्स 18 पर बॉक्स से बाहर पैसा बनाया, डिवाइस / देव / इनपुट / js0 का निर्माण किया । यह एक नियमित रूप से xpad ड्राइवर का काम करता है। एक वैकल्पिक Xboxdrv ड्राइवर है - यह कॉन्फ़िगरेशन में अधिक लचीला है। लेकिन हमारे पास पर्याप्त और पूर्णकालिक है।

वैसे, android बिल्कुल वैसा ही है।

Xpad ड्राइवर Android के लिए लिनक्स कर्नेल का हिस्सा है:

 #define DRIVER_DESC "X-Box pad driver"

और डिवाइस / देव / इनपुट / js0 उसी तरह बनाया गया है:

 MODULE_SUPPORTED_DEVICE("input/js");

उदाहरण के लिए, विचार करें कि एंड्रॉइड में इनपुट उपकरणों की सूची कैसे प्राप्त करें। अनुशंसित एपीआई हमें getDeviceIds () कहते हुए ऐसा करने के लिए कहता है, जो कहता है :

  /** * Gets the ids of all input devices in the system. * @return The input device ids. */ public static int[] getDeviceIds() { return InputManager.getInstance().getInputDeviceIds(); }

getInputDeviceIds () :

  private final IInputManager mIm; //... private SparseArray<InputDevice> mInputDevices; //... /** * Gets the ids of all input devices in the system. * @return The input device ids. */ public int[] getInputDeviceIds() { synchronized (mInputDevicesLock) { populateInputDevicesLocked(); final int count = mInputDevices.size(); final int[] ids = new int[count]; for (int i = 0; i < count; i++) { ids[i] = mInputDevices.keyAt(i); } return ids; } } //... private void populateInputDevicesLocked() { if (mInputDevicesChangedListener == null) { final InputDevicesChangedListener listener = new InputDevicesChangedListener(); try { mIm.registerInputDevicesChangedListener(listener); } catch (RemoteException ex) { throw new RuntimeException( "Could not get register input device changed listener", ex); } mInputDevicesChangedListener = listener; } if (mInputDevices == null) { final int[] ids; try { ids = mIm.getInputDeviceIds(); } catch (RemoteException ex) { throw new RuntimeException("Could not get input device ids.", ex); } mInputDevices = new SparseArray<InputDevice>(); for (int i = 0; i < ids.length; i++) { mInputDevices.put(ids[i], null); } } }

mIm.getInputDeviceIds () :

 interface IInputManager { // Gets input device information. InputDevice getInputDevice(int deviceId); int[] getInputDeviceIds(); //...

यह वह जगह है जहाँ InputManager सेवा आती है:

 import android.view.InputDevice; //... /* * Wraps the C++ InputManager and provides its callbacks. */ public class InputManagerService extends IInputManager.Stub implements Watchdog.Monitor, DisplayManagerService.InputManagerFuncs { static final String TAG = "InputManager"; static final boolean DEBUG = false; private static final String EXCLUDED_DEVICES_PATH = "etc/excluded-input-devices.xml"; //... private InputDevice[] mInputDevices = new InputDevice[0]; //... /** * Gets the ids of all input devices in the system. * @return The input device ids. */ @Override // Binder call public int[] getInputDeviceIds() { synchronized (mInputDevicesLock) { final int count = mInputDevices.length; int[] ids = new int[count]; for (int i = 0; i < count; i++) { ids[i] = mInputDevices[i].getId(); } return ids; } }

getId () हमें पहले ही लाता है कि हम कहाँ थे (Android अद्भुत है):

 public final class InputDevice implements Parcelable { private final int mId; //... /** * Gets the input device id. * <p> * Each input device receives a unique id when it is first configured * by the system. The input device id may change when the system is restarted or if the * input device is disconnected, reconnected or reconfigured at any time. * If you require a stable identifier for a device that persists across * boots and reconfigurations, use {@link #getDescriptor()}. * </p> * * @return The input device id. */ public int getId() { return mId; } //... // Called by native code. private InputDevice(int id, int generation, int controllerNumber, String name, int vendorId, int productId, String descriptor, boolean isExternal, int sources, int keyboardType, KeyCharacterMap keyCharacterMap, boolean hasVibrator, boolean hasButtonUnderPad) { mId = id; mGeneration = generation; mControllerNumber = controllerNumber; mName = name; mVendorId = vendorId; mProductId = productId; mDescriptor = descriptor; mIsExternal = isExternal; mSources = sources; mKeyboardType = keyboardType; mKeyCharacterMap = keyCharacterMap; mHasVibrator = hasVibrator; mHasButtonUnderPad = hasButtonUnderPad; } private InputDevice(Parcel in) { mId = in.readInt(); mGeneration = in.readInt(); mControllerNumber = in.readInt(); mName = in.readString(); mVendorId = in.readInt(); mProductId = in.readInt(); mDescriptor = in.readString(); mIsExternal = in.readInt() != 0; mSources = in.readInt(); mKeyboardType = in.readInt(); mKeyCharacterMap = KeyCharacterMap.CREATOR.createFromParcel(in); mHasVibrator = in.readInt() != 0; mHasButtonUnderPad = in.readInt() != 0; for (;;) { int axis = in.readInt(); if (axis < 0) { break; } addMotionRange(axis, in.readInt(), in.readFloat(), in.readFloat(), in.readFloat(), in.readFloat(), in.readFloat()); } }

एंड्रॉइड के मूल भाग में, InputDevice () का एक उदाहरण यहां बनाया गया है ( टोस्टर से शीघ्र प्रतिक्रिया के लिए धन्यवाद):

 jobject android_view_InputDevice_create(JNIEnv* env, const InputDeviceInfo& deviceInfo) { //... ScopedLocalRef<jobject> inputDeviceObj(env, env->NewObject(gInputDeviceClassInfo.clazz, gInputDeviceClassInfo.ctor, deviceInfo.getId(), deviceInfo.getGeneration(), deviceInfo.getControllerNumber(), nameObj.get(), static_cast<int32_t>(ident.vendor), static_cast<int32_t>(ident.product), descriptorObj.get(), deviceInfo.isExternal(), deviceInfo.getSources(), deviceInfo.getKeyboardType(), kcmObj.get(), deviceInfo.hasVibrator(), deviceInfo.hasButtonUnderPad()));

इस समारोह को यहां कहा जाता है :

 void NativeInputManager::notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) { JNIEnv* env = jniEnv(); //... jobject inputDeviceObj = android_view_InputDevice_create(env, inputDevices.itemAt(i));

InformInputDevicesChanged () फ़ंक्शन के लिए कॉल पहले से परिचित InputManager सेवा में फिर से कॉलबैक द्वारा निर्धारित किया जाता है:

  // Native callback. private void notifyInputDevicesChanged(InputDevice[] inputDevices) { synchronized (mInputDevicesLock) { if (!mInputDevicesChangedPending) { mInputDevicesChangedPending = true; mHandler.obtainMessage(MSG_DELIVER_INPUT_DEVICES_CHANGED, mInputDevices).sendToTarget(); } mInputDevices = inputDevices; } }

कॉलबैक के लिए एक कॉल स्वयं इनपुटरीडर में शुरू की जाती है :

 void InputReader::loopOnce() { //... size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE); //... // Send out a message that the describes the changed input devices. if (inputDevicesChanged) { mPolicy->notifyInputDevicesChanged(inputDevices); }

यहां हम यह भी देखते हैं कि इनपुट डिवाइस से ईवेंट्स EventHubInterface वर्ग द्वारा प्राप्त किए जाते हैं:

  sp<EventHubInterface> mEventHub;

और, अंत में, इस क्लास EventHub.cpp के कार्यान्वयन में , हम रास्पबेरी पाई में सामान्य लिनक्स फेडोरा की तरह / देव / इनपुट से डिवाइस खोल रहे हैं और काम कर रहे हैं:

  static const char *DEVICE_PATH = "/dev/input"; //... char devname[PATH_MAX]; char *filename; //... strcpy(devname, DEVICE_PATH); filename = devname + strlen(devname); *filename++ = '/'; //... strcpy(filename, event->name); //... openDeviceLocked(devname); //... status_t EventHub::openDeviceLocked(const char *devicePath) { char buffer[80]; ALOGV("Opening device: %s", devicePath); int fd = open(devicePath, O_RDWR | O_CLOEXEC); if(fd < 0) { ALOGE("could not open %s, %s\n", devicePath, strerror(errno)); return -1; }

सामान्य तौर पर, एंड्रॉइड में इस पूरे इनपुट सिस्टम के बारे में, यह संक्षेप में स्रोत कोड में ही समझाया गया है :

 /* * The input manager is the core of the system event processing. * * The input manager uses two threads. * * 1. The InputReaderThread (called "InputReader") reads and preprocesses raw input events, * applies policy, and posts messages to a queue managed by the DispatcherThread. * 2. The InputDispatcherThread (called "InputDispatcher") thread waits for new events on the * queue and asynchronously dispatches them to applications. * * By design, the InputReaderThread class and InputDispatcherThread class do not share any * internal state. Moreover, all communication is done one way from the InputReaderThread * into the InputDispatcherThread and never the reverse. Both classes may interact with the * InputDispatchPolicy, however. * * The InputManager class never makes any calls into Java itself. Instead, the * InputDispatchPolicy is responsible for performing all external interactions with the * system, including calling DVM services. */ class InputManagerInterface : public virtual RefBase {

तो, सेवा के अंतिम स्रोत कोड के निम्नलिखित रूप हैं:

 #include <stdio.h> #include <stdlib.h> #include <termios.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <libusb-1.0/libusb.h> #define SONY_VENDOR_ID 0x054C #define PSP_B_PRODUCT_ID 0x01C9 #define UP 0x00000010 #define DOWN 0x00000040 #define LEFT 0x00000080 #define RIGHT 0x00000020 #define B_X 0x00004000 #define B_O 0x00002000 #define B_KVADRAT 0x00008000 #define B_TREUGOLNIK 0x00001000 #define B_L 0x00000100 #define B_R 0x00000200 #define B_SELECT 0x00000001 #define B_START 0x00000008 #define B_NOTE 0x00800000 struct { unsigned int Pattern; unsigned int Btn; unsigned int X; unsigned int Y; } PS = {0x1234ABFE, 0, 127, 127}; struct js_event { unsigned int time; short value; unsigned char type; unsigned char number; }; int is_usbdevblock(libusb_device *dev) { struct libusb_device_descriptor desc; int r = libusb_get_device_descriptor(dev, &desc); if((desc.idVendor == SONY_VENDOR_ID) && (desc.idProduct == PSP_B_PRODUCT_ID)) { return 1; } return 0; } int main(int argc, char** argv) { unsigned int real_x = 0, real_y = 0; int x, y; int fd = 0; while(1) { libusb_device **list; libusb_device *found = NULL; libusb_context *ctx = NULL; int attached = 0; libusb_init(&ctx); libusb_set_debug(ctx, 3); ssize_t cnt = libusb_get_device_list(ctx, &list); ssize_t i = 0; int err = 0; if(cnt < 0) { return -1; } for(i = 0; i < cnt; i++) { libusb_device *device = list[i]; if(is_usbdevblock(device)) { found = device; break; } } if(found) { libusb_device_handle *handle; err = libusb_open(found, &handle); if (err) { return -1; } if (libusb_kernel_driver_active(handle, 0)) { libusb_detach_kernel_driver(handle, 0); attached = 1; } err = libusb_claim_interface(handle, 0); if (err) { return -1; } if(fd == 0) { fd = open("/dev/input/js0", O_RDONLY); } if(fd < 0) { goto clean; } int nEndpoint = 0x01; int nTimeout = 500; //in milliseconds int BytesWritten = 0; int ret; struct js_event e; int t; while(1) { read(fd, &e, sizeof(struct js_event)); e.type &= ~0x80; t = 0; //transfer = 0; if(e.type == 1) { if(e.value == 1) { if(e.number == 0) {PS.Btn |= B_X; t = 1;} if(e.number == 1) {PS.Btn |= B_O; t = 1;} if(e.number == 2) {PS.Btn |= B_KVADRAT; t = 1;} if(e.number == 3) {PS.Btn |= B_TREUGOLNIK; t = 1;} if(e.number == 4) {PS.Btn |= B_L; t = 1;} if(e.number == 5) {PS.Btn |= B_R; t = 1;} if(e.number == 6) {PS.Btn |= B_SELECT; t = 1;} if(e.number == 7) {PS.Btn |= B_START; t = 1;} if(e.number == 8) {PS.Btn |= B_NOTE; t = 1;}//XBOX_HOME //if(e.number == 9) PS.Btn |= ;//L_STICK_PRESS //if(e.number == 10)PS.Btn |= ;//R_STICK_PRESS } if(e.value == 0) { if(e.number == 0) {PS.Btn &= ~B_X; t = 1;} if(e.number == 1) {PS.Btn &= ~B_O; t = 1;} if(e.number == 2) {PS.Btn &= ~B_KVADRAT; t = 1;} if(e.number == 3) {PS.Btn &= ~B_TREUGOLNIK; t = 1;} if(e.number == 4) {PS.Btn &= ~B_L; t = 1;} if(e.number == 5) {PS.Btn &= ~B_R; t = 1;} if(e.number == 6) {PS.Btn &= ~B_SELECT; t = 1;} if(e.number == 7) {PS.Btn &= ~B_START; t = 1;} if(e.number == 8) {PS.Btn &= ~B_NOTE; t = 1;} } } if(e.type == 2) { if(e.number == 6) { if(e.value == -32767) {PS.Btn |= LEFT; t = 1;} if(e.value == 32767) {PS.Btn |= RIGHT; t = 1;} if(e.value == 0) {PS.Btn &= ~(LEFT | RIGHT); t = 1;} } if(e.number == 7) { if(e.value == -32767) {PS.Btn |= UP; t = 1;} if(e.value == 32767) {PS.Btn |= DOWN; t = 1;} if(e.value == 0) {PS.Btn &= ~(UP | DOWN); t = 1;} } if(e.number == 0) { if(real_x != ((e.value + 32767) / 256)) {real_x = ((e.value + 32767) / 256); t = 1;} } if(e.number == 1) { if(real_y != ((e.value + 32767) / 256)) {real_y = ((e.value + 32767) / 256); t = 1;} } } if(t == 1) { #define KOEF 1.4 //[-128..0..127] x = real_x - 128; y = real_y - 128; x = x * (1. + ((abs(x) * (KOEF-1.))/(127./KOEF))); if(x > 127) x = 127; if(x < -128) x = -128; y = y * (1. + ((abs(y) * (KOEF-1.))/(127./KOEF))); if(y > 127) y = 127; if(y < -128) y = -128; PS.X = 128 + x; PS.Y = 128 + y; ret = libusb_bulk_transfer(handle, nEndpoint, (unsigned char *)&PS, sizeof(PS), &BytesWritten, nTimeout); if(ret < 0) { break; } } } clean: if(fd) { close(fd); fd = 0; } if(attached == 1) { libusb_attach_kernel_driver(handle, 0); } libusb_close(handle); } libusb_free_device_list(list, 1); libusb_exit(ctx); sleep(1); } return 0; }

यहाँ सेवा बाइनरी के लिए एक लिंक है। और यहाँ भी m.sh संकलन स्क्रिप्ट की सामग्री है:

 gcc xbox2psp.c -o xbox2psp.o -I/usr/local -L/usr/local -lusb-1.0

स्रोत के अनुसार, मैं दो बिंदुओं पर ध्यान देना चाहूंगा। सबसे पहले, Xbox एनालॉग स्टिक्स में 16 बिट्स की सटीकता होती है, जबकि PSP स्टिक में 8 बिट्स की सटीकता होती है। इस संबंध में, मैं पैकेज को 8 बिट्स पर कम किए गए अक्ष मूल्यों को बदलने के लिए भेजता हूं, और Xbox नियंत्रक से स्रोत डेटा को बदलने के लिए नहीं। दूसरे, PSP में विकर्णों का मान पूर्ण पैमाने से मेल खाता है (यानी, पैमाने के संदर्भ में गोल PSP छड़ी एक वर्ग है), और Xbox में, जैसा कि यह होना चाहिए, पैमाने का आधा:

इसलिए, एक रैखिक रूप से बढ़ रही है (Xbox नियंत्रक के केंद्र अक्ष से अधिक विचलन, बड़ा) गुणांक को अधिकतम 1.4 के साथ पेश किया गया था (हालांकि, जैसा कि बाद में पता चला, यह कोण मूल्य निर्धारित करने के लिए सही होगा, और कोण को विकर्ण के करीब, अधिक से अधिक गुणांक)। इन मूल्यों के साथ, Xbox गेमपैड को बिना किसी असुविधा के महसूस किया जाता है, हालांकि विशुद्ध रूप से तकनीकी संवेदनशीलता रूखी निकली। डूम 0.05 में नियंत्रण के लिए यह सुविधाजनक है, डंगऑन घेराबंदी में सभी तीन आंदोलन गति (छड़ी विक्षेपण बल के आधार पर) काम करते हैं और PSP पर ही महसूस करते हैं। जब समस्या के साथ सामना किया जाता है, तो शुरुआत में एक साधारण गुणांक का परीक्षण किया गया था (1.5 और 1.4 दोनों), विचलन के आधार पर रैखिक वृद्धि के बिना, और नामित खेलों में तेज असुविधा थी - यह खेलना असंभव था।

रास्पबेरी पाई के लिए फेडोरा रीमिक्स 18 में स्टार्टअप के लिए अपनी स्वयं की सेवा जोड़ना

लिनक्स पर ऑटोलॉड के लिए एक कार्यक्रम को जोड़ने पर सतही गुगली मुख्य रूप से init आरसी स्क्रिप्ट को संशोधित करने पर सिफारिशें देता है। लेकिन हमारे मामले में, हमें अलग तरीके से करने की जरूरत है।

1. सबसे पहले आपको हमारी सर्विस Xbox2psp.o को / usr / लोकल / बिन में कॉपी करना होगा और इसके लिए लॉन्च राइट्स (तीनों बिट्स) सेट करने होंगे।

2. फिर निम्नलिखित सामग्री के साथ फ़ाइल /lib/systemd/system/xbox2psp.service बनाएं:

 [Unit] Description=xbox2psp After=syslog.target network.target [Service] Type=simple ExecStart=/usr/local/bin/xbox2psp.o [Install] WantedBy=multi-user.target

3. / etc / systemd / system / folder पर जाएं और कमांड के साथ एक लिंक बनाएं

 > ln -s /lib/systemd/system/xbox2psp.service xbox2psp.service

4. स्टार्टअप डेमन कॉन्फ़िगरेशन को पुनः लोड करें:

 > systemctl daemon-reload

5. एक नई सेवा के ऑटोस्टार्ट को सक्रिय करें

 > systemctl enable xbox2psp.service

6. यदि आवश्यक हो, तो आप तुरंत कमांड के साथ सेवा शुरू कर सकते हैं

 > systemctl start xbox2psp.service

नतीजतन, हमें Xbox 360 नियंत्रक का उपयोग करके PSP को नियंत्रित करने का एक सुविधाजनक अवसर मिला। यदि वांछित है, तो इस परियोजना को कनेक्ट करने के लिए संशोधित किया जा सकता है, उदाहरण के लिए, ब्लूटूथ के माध्यम से ड्यूलशॉक 3।

हम रास्पबेरी पाई का उपयोग करके Xbox 360 से PSP गेमपैड से कनेक्ट करते हैं