पीसी और सॉकेट्स के लिए आईआर रिमोट। भाग २

भाग 1
कल मैंने एक Arduino- आधारित USB-IRPC बनाने के बारे में बात की। क्यों? यह दिखाने के लिए कि लेआउट को कैसे जल्दी से इकट्ठा किया जाए और जटिलता यहां विशेष नहीं है।
आज हम उम्मीद के मुताबिक सब कुछ करेंगे। शुरुआत से ही - कॉन्सेप्ट, PCB, LUT से। हम पन्नी-लेपित फाइबरग्लास के एक टुकड़े को एक मुट्ठी भर भागों के साथ समाप्त डिवाइस में बदल देंगे। बेशक मामले के साथ, हम सावधान रहना चाहते हैं, है ना?
यहाँ हमारा लक्ष्य है:

USB-IRPC नंगे मोर्चा

USB-IRPC समाप्त हुई

तो, हम अवधारणा के साथ शुरू करते हैं। केवल USB-IRPC को आरेख में दिखाया जाएगा, क्योंकि रिले के साथ सॉकेट मॉड्यूल और LED के साथ IR रिसीवर "बाह्य" हैं और हम इसका उपयोग बदलावों के बिना करेंगे।
मैंने निम्नलिखित कारणों से एक सर्किट और एक सर्किट बोर्ड बनाने के लिए DipTrace का उपयोग किया:

• यह 1000 निष्कर्षों तक मुफ्त है, जो मेरे शौकिया उद्देश्यों के लिए पर्याप्त है।
• वह समस्याओं के बिना एकल-पक्षीय बोर्डों को फैलाने में अच्छा है।
• इसका उपयोग करना ईगल की तुलना में आसान और अधिक सुविधाजनक है, जो, मेरी राय में, एक बहुत ही विशिष्ट इंटरफ़ेस है।

इसमें एक महत्वपूर्ण दोष है - तत्वों का बहुत समृद्ध पुस्तकालय नहीं, और उस पर सबसे सुविधाजनक खोज भी नहीं। लेकिन आइटम संपादित करना बहुत मुश्किल नहीं है। सामान्य तौर पर, अब तक यह मेरे लिए सबसे कम असुविधाजनक कार्यक्रम है :)
यहाँ स्वयं आरेख है (लिंक पर क्लिक करके और मूल आकार में खुलकर पूर्ण आकार के संस्करण को देखना बेहतर है):

USB-IRPC योजना
केंद्र में हमारे पास U1 है - मैंने Atmega168PA-AU का उपयोग किया, लेकिन Atmega88 और Atmega328P करेगा। फर्मवेयर का आकार 4 केबी से थोड़ा अधिक है।
16 MHz की आवृत्ति पर माइक्रोकंट्रोलर (MK) के संचालन को क्वार्ट्ज X1 के साथ कैपेसिटर C4 और C5 द्वारा प्रदान किया जाता है।
सी 2 - बस एक अवरुद्ध संधारित्र, पावर सर्किट में तरंग को थोड़ा चिकना करता है।
R3 और U2 का एक ब्लॉक पीसी पावर बटन को "प्रेस" करने का काम करता है।
जे 1 - पावर बटन के समानांतर मदरबोर्ड से कनेक्ट करने के लिए कनेक्टर।
S1 - रीसेट बटन। यह डिबगिंग के समय काम आ सकता है।
J5 और J6 - ISP6 कनेक्टर इन-सर्किट प्रोग्रामिंग (फर्मवेयर)।
J2 - सॉकेट मॉड्यूल को रिले के साथ जोड़ने के लिए सॉकेट।
J3 - IR रिसीवर मॉड्यूल को एलईडी से जोड़ने के लिए कनेक्टर।
डी 1 - एक वर्तमान-सीमित अवरोधक आर 1 के माध्यम से जुड़ा एक एलईडी बोर्ड पर एक बाहरी एलईडी की नकल करता है। डिबगिंग के लिए उपयोगी, विधानसभा के बाद यह बॉक्स के अंदर दिखाई नहीं देता है, इसलिए यह टांका लगाना आवश्यक नहीं है। आर 4 - रिसीवर मॉड्यूल पर रिमोट एलईडी के लिए रोकनेवाला।
जे 4 - यूएसबी मिनी-बी कनेक्टर।
D2 और D3 3.6V जेनर डायोड हैं।
R5, R6, R7 - V-USB ऑपरेशन के लिए प्रतिरोधक।
यहां, वास्तव में, पूरी योजना।
लेख के अंत में, इसे .sch प्रारूप में डाउनलोड करने के लिए लिंक (DipTrace)
मुद्रित सर्किट बोर्ड को अलग करना अधिक कठिन हो गया। यह मेरा पहला अनुभव है और एक परत में एक कंडक्टर को अलग करना संभव नहीं था, मुझे जम्पर छोड़ना पड़ा। इसके अलावा, मैं भूल गया कि बोर्ड पर प्लग दूसरी तरफ स्थापित किए जाएंगे, और फिर मुझे प्रोग्रामर के लिए एक अलग प्लग बनाना होगा। मैंने भी गलती से ऑप्टोकॉप्लर को गलती से तैनात कर दिया था, लेकिन यह इसे टांका लगाने से नहीं रोकता था। मैंने यह सब मुद्रित सर्किट बोर्ड के संस्करण में तय किया था जिसे मैंने डाउनलोड के लिए पोस्ट किया था। तो आपका बोर्ड मेरी तस्वीरों में एक से थोड़ा अलग होगा। बेहतर के लिए :)
तत्वों की सीलिंग के दौरान, मैंने पाया कि तांबे की पटरियों के बहुत करीब से भरने से असुविधा बढ़ जाती है और भराव बदल जाता है, जिससे द्वीपों से छुटकारा मिल जाता है और पटरियों को चौड़ा कर दिया जाता है।
यहाँ क्या हुआ:

रेड कार्पेट एक ऐसा जम्पर है जिसे पार्टिसिपेट नहीं किया जा सकता है।
एक अच्छा बोनस DipTrace - मुद्रित सर्किट बोर्ड कैसे दिखेगा देखने की क्षमता। दुर्भाग्य से, पुस्तकालय में सभी तत्व नहीं हैं, लेकिन एक सपाट रूप में समग्र परिणाम अभी भी बहुत अधिक दृश्य है:

यह देखा जा सकता है कि बोर्ड पर मैंने जे 7 कनेक्टर को जोड़ा है - पीसी केस से पावर बटन कनेक्टर को जोड़ने के लिए जे 1 के साथ समानांतर एक जोड़ी अधिक पिन।
ठीक है, सर्किट और सैंपल पीसीबी तैयार हैं, हम पुर्जे खरीदते हैं और निर्माण करते हैं।

भागों की सूची:

U1 - Atmega168PA-AU - TQFP-32 पैकेज में - 64 रूबल (icdarom में, न्यूनतम आदेश 1500 रगड़ना, डिलीवरी 200) से है, आप 130 रगड़ खरीद सकते हैं। Atmega88PA-AU या Atmega328P-AU करेगा

आउटपुट तत्व:
U2 - PC817, PDIP4 संलग्नक
एस 1 - डीटीएस -61 बटन 6x4-6.3।
डी 2, डी 3 - 3.6 वी जेनर डायोड
जे 2, जे 3 - पीबीएस -4
जे 5, जे 6 - पीबीएस -3
जे 1, जे 7 - पीबीएस -2

SMD तत्वों का आकार 0805 है
R1, R4 - 390ohm
R5, R6 - 68ohm
R7 - 2.2 kOhm
डी 1 - एलईडी (कोई भी रंग, मेरे पास नारंगी है)
जे 4 - यूएसबी मिनीबी कनेक्टर
सी 1, सी 2 - 0.1 μF सिरेमिक कैपेसिटर।
सी 4, सी 5 - 22 पीएफ सिरेमिक कैपेसिटर
X1- 16MHz क्वार्ट्ज
आर 3 - 100 ओम।
आर 2 - 10 कोहम

रेडियो बाजार पर आउटपुट तत्वों को खरीदा जाता है - लगभग 50 रूबल।
मैंने $ 9.85 के पैक के लिए तुरंत एसएमडी तत्वों को खरीदा - प्रत्येक रोकनेवाला मूल्य के 40 टुकड़े होते हैं और प्रत्येक संधारित्र के 30।

मैंने बॉक्स को 40p के लिए icdarom में लिया था, लेकिन यह 65 रंगों के आसपास के विभिन्न रंगों के अन्य BOX-KA08 स्टोर में भी है।
यह पारदर्शी भी होता है:


मैं आपको बोर्ड नहीं बनाना सिखाऊँगा कि कैसे LUT - DiHALT ने सब कुछ सरल और स्पष्ट रूप से वर्णित किया। वैसे, उन्हें जाम के दिन बधाई। :)
मैं केवल डिपट्रेस के लिए विशिष्ट क्षणों पर ध्यान केन्द्रित करूंगा। जब मुद्रण, दर्पण और घटक रूपरेखा के मुद्रण को अक्षम करने के लिए मत भूलना:

आप डिप्ट्रेस के बिना कर सकते हैं। मैंने एक PNG फ़ाइल को निर्यात किया, FastStone व्यूअर को लें और इस तरह प्रिंट करें:

अधिकतम करने के लिए गुणवत्ता प्रिंट, अक्षम करें, अधिकतम करने के लिए संकल्प।
600 पीपीआई में तैयार पीएनजी।
फिर सब कुछ हमेशा की तरह होता है: अनुवाद, जहर, टोनर धोना, कट, टिन, ड्रिल:

« यूएसबी-IRPC »
मेरा पेपर मैट था और टोनर किनारों के चारों ओर थोड़ा ऊपर लुढ़का हुआ था - शायद यह लोहे की तरह नहीं था, लेकिन इसमें कुछ भी महत्वपूर्ण नहीं है, केवल सौंदर्यशास्त्र का नुकसान हुआ है और यह बहुत ज्यादा नहीं है।
घटकों को मिलाएं और चिह्नित करें:

USB-IRPC नंगे मोर्चा

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

विधानसभा और डिजाइन

मैं आपको 1: 1 (USB-IRPC_pcb.jpg) के पैमाने में तत्वों के शिलालेखों के साथ एक रंगीन चित्र मुद्रित करने की सलाह देता हूं और सीलिंग तत्वों और ड्रिलिंग छेद के लिए एक धोखा पत्र के रूप में उपयोग करता हूं।
एक फ़ाइल का उपयोग करके, बॉक्स में छेदों को सावधानीपूर्वक काट लें। हम एक मार्कर या पेंसिल के साथ मामले पर छेद के आकृति को रेखांकित करते हैं, एक लिपिक चाकू के साथ पेपर टेम्पलेट में आकृति को काटते हैं और मामले को टेम्पलेट संलग्न करते हैं। ओर हमने एक miniUSB कनेक्टर के लिए एक नाली देखी। हम बोर्ड डालते हैं और कोशिश करते हैं:

« यूएसबी-IRPC »
यदि आप फर्मवेयर को संशोधित करने की योजना नहीं बनाते हैं, तो आईएसपी के लिए छेद को काटने के लिए आवश्यक नहीं है - पिन कवर को समाप्त नहीं करते हैं।
फिर चिह्नों को प्रिंट और पेस्ट करें। संग्रह में आपको आईएसपी के साथ और बिना स्टिकर संस्करण मिलेगा। इस पर निर्भर करता है कि आप उनके नीचे छेद काटते हैं या नहीं। (मैंने रीसेट के लिए एक छेद ड्रिल किया था, लेकिन इसे स्टिकर में नहीं काटा, इसे टूथपिक के साथ छेद किया जा सकता है, यदि आवश्यक हो, लेकिन अभी तक उपयोगी नहीं है)।

सब कुछ, हार्डवेयर तैयार है।

USB-IRPC आकार
मैं सिर्फ गर्म पिघल चिपकने वाला आईआर मॉड्यूल में भर गया और इसे एक दो तरफा टेप पर मॉनिटर लेग से जोड़ दिया।

" USB-IRPC IR-LED मॉड्यूल "
मुझे घर पर उज्ज्वल प्रकाश पसंद नहीं है, और सामान्य प्रकाश व्यवस्था में यह लगभग अगोचर है - आकार 1x3 सेमी है।

प्रोग्रामिंग डिवाइस

फर्मवेयर सी में कोड :: ब्लॉक आईडीई में लिखा गया है। कंपाइलर - AVR टूलकिन से AVR GCC
मैं यहां मुख्य बिंदुओं को समझाऊंगा ताकि आप प्रोजेक्ट कोड को समझ सकें। स्रोत परियोजना पृष्ठ पर हैं, लेख के अंत में लिंक।
मैंने DigitalRead और DigitalWrite फ़ंक्शन की एक प्रति लिखी, जैसे मैं Arduino से कुछ पुस्तकालयों को लेता हूं और, उन्हें फिर से लिखने के लिए नहीं, मैं सिर्फ उन्हें वायरिंग फ़ंक्शन के मेरे संस्करण को कॉल करता हूं।
ir.h एक IR रिसीवर वाला इंटरफेस है। आईआर रिमोट कंट्रोल के साथ प्रयोग करने के लिए चीनी सेट के साथ जो उदाहरण आया वह बेशर्मी से अनुकूलित था। लगभग अपरिवर्तित।
usb_comm.h - एक पीसी और डेटा संरचना जिसमें वे प्रेषित होते हैं, के साथ विनिमय के लिए कमांड कोड को परिभाषित करता है।

//USB Commands #define cmdGetIRPCState 1 //   IRPC #define cmdSetDigitalPinStates 2 //       -   #define cmdDisableIR 3 //       #define cmdEnableIR 4 //       #define cmdGetIRBtnMapping 5 //         #define cmdSetIRBtnMapping 6 //         #define cmdGetIRBtn 7 //       (     ) #define cmdSetLedState 8 // /  #define cmdDoInternalFunc 9 //    IRPC #define cmdSaveToEEPROM 10 //       EEPROM #define cmdLoadFromEEPROM 11 //       EEPROM //USB pinstate bits #define PWRRelay1Bit 0 #define PWRRelay2Bit 1 #define ledBit 7 //Internal functions #define fRelay1Switch 1 #define fRelay2Switch 2 #define fPCPwrSwitch 3 struct irpcdata_t //      { uint8_t cmd; // Switches state uint8_t data[4]; // data }; 

USB पिनस्टेट बिट्स - रिले के लिए नियंत्रण बिट्स की संख्या और पैकेज में एलईडी।
आंतरिक IRPC विशेषताएं:
fRelay1Switch - स्विच रिले 1
fRelay2Switch - रिले 2 स्विच करें
fPCPwrSwitch - पीसी पावर बटन दबाएं

irpcdata_t डिवाइस और पीसी के बीच आदान प्रदान पैकेज संरचना है।
पीसी के अनुरोध पर एक्सचेंज होता है।
cmd - कमांड कोड (जैसे cmdGetIRPCState)
डेटा [] - 4 बाइट्स का डेटा सरणी। प्रत्येक टीम इसे अपने तरीके से व्याख्या करती है।

irc.h - बस सुविधा के लिए, बटन कोड के पत्राचार। मैंने अपने रीमेक के लिए रिकॉर्ड किया। कुछ इस तरह:

 //AverMedia RM-FR #define amTVFM 0xFE01 #define amPWR 0xFF00 #define amB1 0xFA05 #define amB2 0xF906 #define amB3 0xF807 #define amB4 0xF609 

Usbconfig.h फ़ाइल में, V-USB लाइब्रेरी सेटिंग्स। मैंने इस लेख से जानकारी खींची।
यदि आप यूएसबी प्रोटोकॉल को नहीं समझते हैं, तो आप वहां कुछ भी नहीं छू सकते हैं।
आधारित कार्यक्रम main.c.

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

 //Usefull macroses #define SetPinState(Pin, State, bit) digitalWrite(Pin, State); if (State>0) pinStates |=_BV(bit); else pinStates &= ~_BV(bit); //PORTB #define PWRPin 16 // PC2 #define ledPin 9 // PB1 //PORTD #define PWRRelay1 6 // PD6 #define PWRRelay2 5 // PD5 #define MaxBtnMapings 15 

चर (मैंने अपने लिए टिप्पणियां की हैं, इसलिए फ़ाइल में वे ज्यादातर अनाड़ी अंग्रेजी में हैं :)

 // uint8_t ledState = 0; //   uint8_t PWRRelay1State = 1; //   1 uint8_t PWRRelay2State = 1; //  2 uint8_t PWRPinState=0; //     uint8_t IRBtnL, IRBtnH; // ,        uint8_t IREnabled=1; //     struct btn_mapping btn_mappings[MaxBtnMapings]; //     //-- uint8_t cmd; //    uint8_t pinStates=0x00; //    (0-PWRRelay1State, 1-PWRRelay2State) uint8_t cmdReceived=0; //  PC  () //IR variables uint16_t btn; //    uint16_t LastBtn=0x00; //     //----------------- USB Section--------------------------- struct irpcdata_t pdata, pcdata; //pdata - output buffer, pcdata - input buffer 

पीसी से प्राप्त कमांड को पीसीडेटा में संग्रहीत किया जाता है, भेजे गए लोगों को पीडीटा में संग्रहीत किया जाता है।

मुख्य चक्र

 int main(void) { //Initialize ports DDRB = 0b00000010; // PB1 -  DDRC = 0b00000100; // PC2 -  DDRD = 0b01100000; // PD5, PD6 -  //clear btn mappings for (i=0; i<MaxBtnMapings;i++){ btn_mappings[i].func=0; btn_mappings[i].btn_code=0; } loadStateFromEEPROM(); //USB Init & connect cli(); // Clear interrupts while perfoorming time-critical operations usbInit(); usbDeviceDisconnect(); //    ,       ! uchar i = 0; while(--i){ //  > 250 ms _delay_ms(1); } usbDeviceConnect(); //  sei(); //   //Timer1 Init for IR timer1_init(); // init IR timer loop(); return 0; } 

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

 void loop() { // Main loop for(;;){ //    usbPoll(); //        ,     - 50 ms if (cmdReceived) {processUSBcmd();} else if (IREnabled) { remote_decode(); process_IR(); } } return; } 

यहाँ सब कुछ सरल है:

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

जब पीसी हमें पैकेज देना चाहता है, तो usbFunctionWrite फ़ंक्शन को कहा जाता है, जब यह डेटा पैकेट - usbFunctionRead फ़ंक्शन का अनुरोध करता है।

आइए उनका विश्लेषण करें:

 uchar usbFunctionRead(uchar *data, uchar len) { if(len > bytesRemaining) len = bytesRemaining; uchar *buffer = (uchar*)&pdata; if(!currentAddress) //       . { //     pdata.cmd=cmd; //last received cmd switch(cmd){ case cmdGetIRPCState: pdata.data[0]=pinStates; pdata.data[1]=IRBtnH; pdata.data[2]=IRBtnL; if (IREnabled){ //clear IR button code IRBtnL=0; IRBtnH=0; } break; case cmdGetIRBtnMapping: pdata.data[0]=pcdata.data[0]; pdata.data[1]=(btn_mappings[pcdata.data[0]].btn_code>>8); pdata.data[2]=(btn_mappings[pcdata.data[0]].btn_code & 0xFF); pdata.data[3]=btn_mappings[pcdata.data[0]].func; break; } } uchar j; for(j=0; j<len; j++) data[j] = buffer[j+currentAddress]; currentAddress += len; bytesRemaining -= len; return len; } 

सबसे पहले, pdata संरचना को भरें - अगर हमें डिवाइस की स्थिति (cmdGetIRPCState) से पूछा गया था, तो पिनस्टेट्स और रिमोट पर दबाए गए बटन का कोड लिखें
यदि आपने आंतरिक कार्यों के लिए पत्राचार में से एक का अनुरोध किया है, तो हम इसे भेजे गए पीसी पैकेज (pcdata.data [0]) के पहले बाइट से फ़ंक्शन संख्या लेकर लौटाते हैं।
यदि आप कमांड को नहीं पहचानते हैं, तो बस pdata संरचना दें - जब कमांड को संसाधित करते हैं, तो परिणाम इसके लिए लिखे जाते हैं
फिर, बाइट-बाय-बिट हम डेटा पैरामीटर में पारित सूचक का उपयोग करके अपना पैकेज लिखते हैं।

 uchar usbFunctionWrite(uchar *data, uchar len) { uchar *buffer = (uchar*)&pcdata; uchar j; for(j=0; j<len; j++) buffer[j]=data[j]; cmdReceived=1; //     return 1; } 

यहां यह और भी सरल है - हम बस पीसीडेटा में डेटा पैकेट को फिर से लिखते हैं, यह जानने के बिना कि क्या है, प्रसंस्करण प्रक्रियाUSUScmd () द्वारा किया जाएगा, और हमें जल्द से जल्द नियंत्रण वापस करने की आवश्यकता है - फ़ंक्शन एक बाधा का कारण बनता है।

और यहाँ, वास्तव में, वह:

 void processUSBcmd(){ cmd=pcdata.cmd; switch(cmd) { case cmdSetDigitalPinStates: //Get pin states from USB cmd PWRRelay1State=(pcdata.data[0] & _BV(PWRRelay1Bit)); PWRRelay2State=(pcdata.data[0] & _BV(PWRRelay2Bit)); ledState=(pcdata.data[0] & _BV(ledBit)); //Execute cmd SetPinState(PWRRelay1, PWRRelay1State, PWRRelay1Bit); SetPinState(PWRRelay2, PWRRelay2State, PWRRelay2Bit); break; case cmdGetIRPCState: if (PWRRelay1State>0) pinStates |=_BV(PWRRelay1Bit); else pinStates &= ~_BV(PWRRelay1Bit); if (PWRRelay2State>0) pinStates |=_BV(PWRRelay2Bit); else pinStates &= ~_BV(PWRRelay2Bit); if (ledState>0) pinStates |=_BV(ledBit); else pinStates &= ~_BV(ledBit); break; case cmdGetIRBtn: pdata.data[1]=IRBtnH; pdata.data[2]=IRBtnL; IRBtnL=0; IRBtnH=0; break; case cmdSetLedState: ledState=(pcdata.data[0] & _BV(ledBit)); SetPinState(ledPin, ledState, ledBit); break; case cmdEnableIR: IREnabled=1; break; case cmdDisableIR: IREnabled=0; IRBtnL=0xFF; IRBtnH=0xFF; break; case cmdSetIRBtnMapping: btn_mappings[pcdata.data[0]].btn_code=(uint16_t)(pcdata.data[1]<<8)+pcdata.data[2]; btn_mappings[pcdata.data[0]].func=pcdata.data[3]; break; case cmdDoInternalFunc: switch (pcdata.data[0]){ case fRelay1Switch: PWRRelay1State=!PWRRelay1State; SetPinState(PWRRelay1, PWRRelay1State, PWRRelay1Bit); break; case fRelay2Switch: PWRRelay2State=!PWRRelay2State; SetPinState(PWRRelay2, PWRRelay2State, PWRRelay2Bit); break; case fPCPwrSwitch: digitalWrite(PWRPin, 1); _delay_ms(100); digitalWrite(PWRPin, 0); break; } break; case cmdLoadFromEEPROM: loadStateFromEEPROM(); break; case cmdSaveToEEPROM: saveStatetoEEPROM(); break; } _delay_ms(5); cmdReceived=0; } 

प्राप्त कमांड (pcdata.cmd फ़ील्ड में इसका कोड) के आधार पर, हम pcdata.data पैकेज को पार्स करते हैं
मुझे लगता है कि यहां सब कुछ बहुत पारदर्शी है।
कमांड निष्पादित करने के बाद, cmdReceived ध्वज रीसेट करें।

Process_IR () फ़ंक्शन में, हम 16-बिट बटन कोड एकत्र करते हैं:

  // button code is 16 bit btn=(adrH_code << 8) + adrL_code; 

यदि कोड 0 नहीं है, तो कुछ दबाया गया है, पीसी को स्थानांतरित करने के लिए सहेजें और झंडा सेट करें जिसे आपको एलईडी को प्रकाश में लाने की आवश्यकता है - यह दिखाएं कि हमने दबाए गए बटन को देखा।

  //Button pressed if (btn>0x00) { LastBtn=btn; IRBtnL=adrL_code; IRBtnH=adrH_code; ledState=1; } 

अगला, मैं अपने रिमोट कंट्रोल के बटन कोड को संसाधित करता हूं:

  //Button is "Power" if ((btn==ykPWR) || (btn==amPWR)) { PWRPinState=1; } switch (LastBtn){ // case ykB1: case amSNAPSHOT: PWRRelay1State=!PWRRelay1State; SetPinState(PWRRelay1, PWRRelay1State, PWRRelay1Bit); break; // case ykB2: case am16CH: PWRRelay2State=!PWRRelay2State; SetPinState(PWRRelay2, PWRRelay2State, PWRRelay2Bit); break; } 

"पावर" बटन पर, रिमोट कंट्रोल बटन जारी होने तक पीसी पावर बटन दबाएं।
दो अन्य बटनों द्वारा मैं रिले स्थिति स्विच करता हूं।

फिर हम आंतरिक कार्यों के लिए बटन कोड के निर्दिष्ट पत्राचार की सरणी की जांच करते हैं - यह अन्य रिमोट के साथ उपयोग के लिए है, पत्राचार पीसी cmdSetIRBtnMapping आदेशों के साथ सेट किया गया है - प्रति बटन एक कमांड। इस कमांड की प्रोसेसिंग जो हमने ऊपर देखी है processUSBcmd () में

  for (i=0; i<MaxBtnMapings;i++){ if (btn==btn_mappings[i].btn_code) { switch (btn_mappings[1].func){ case fRelay1Switch: PWRRelay1State=!PWRRelay1State; SetPinState(PWRRelay1, PWRRelay1State, PWRRelay1Bit); break; case fRelay2Switch: PWRRelay2State=!PWRRelay2State; SetPinState(PWRRelay2, PWRRelay2State, PWRRelay2Bit); break; case fPCPwrSwitch: digitalWrite(PWRPin, 1); _delay_ms(100); digitalWrite(PWRPin, 0); break; } } } 

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

अब पीसी प्रोग्राम पर जाएं।
मैं प्रमुख बिंदुओं पर ध्यान केंद्रित करूंगा ताकि आप स्रोत को समझ सकें।
मैं आपको MKey के लिए एक प्लगइन का एक उदाहरण दिखाऊंगा - यह समझना आसान है।
प्लगइन डेल्फी 7 में लिखा गया है क्योंकि यह पता चला है कि एमके यूनिकोड का समर्थन नहीं करता है, और डेल्फी 2010 में आपको एएनएसआई से परेशान होने की आवश्यकता है।
अतिरिक्त पुस्तकालयों में से, केवल JVCL का उपयोग किया जाता है।

मुख्य कार्य uHID.pas मॉड्यूल में किया जाता है
यह डिवाइस में उसी कमांड कॉन्स्टेंट को परिभाषित करता है, मैं उन्हें डुप्लिकेट नहीं करूंगा।
पैकेज का वर्णन करने वाला एक ही रिकॉर्ड, इसके अलावा - रिपोर्टआईडी - हम इसका समर्थन नहीं करते हैं और हमेशा 0 होता है, लेकिन सामान्य तौर पर डिवाइस में एक से अधिक रिपोर्ट हो सकती हैं। हमारे लिए बस एक ही काफी है।
अतिरिक्त स्थिरांक केवल आईडी डिवाइस हैं - वेंडर आईडी (विद), उत्पाद आईडी (पीआईडी) और डिवाइसनेम। Vid और Pid द्वारा, हम अपने कनेक्ट किए गए HID उपकरणों में खोज करेंगे।

 const //USB-IRPC IDs Vid=$16C0; Pid=$05DF; DeviceName='USB-IRPC'; //PC<->IRPC TIRPCReport= packed record reportID:byte; //not used, shoud be 0 cmd:byte; data: array [0..3] of byte; end; 

डिवाइस के साथ सभी संचार कार्य एक कक्षा में एकत्र किए जाते हैं

  TIRPC=class private Dev:TJvHidDevice; HID:TJvHidDeviceController; fIRButtons:TStringList; fIRName:string; fIRLoaded:boolean; function IsConnected: boolean; public constructor Create; destructor Destroy; override; procedure Connect; procedure Disconnect; function ReadIRPCState(var Report:TIRPCReport):boolean; procedure WriteIRPCcmd(cmd:TIRPCReport); procedure LoadIRcodes(irFile:string); function BtnName(btnCode:word):string;overload; function BtnName(btnCode:string):string;overload; property Connected:boolean read IsConnected; property Device:TJvHidDevice read Dev; property IRButtons:TStringList read fIRButtons; property IRName:string read fIRName; end; 

देव फ़ील्ड डिवाइस वर्ग के लिए एक संकेतक है, हम इसे तब प्राप्त करते हैं जब डिवाइस का कनेक्शन सफल होता है (कनेक्ट)।
जब डिस्कनेक्ट किया गया (डिस्कनेक्ट) यह शून्य पर सेट है।

विधियां बहुत सरल हैं, इसलिए मैं उदाहरण के लिए एक दिखाऊंगा, बाकी जटिलता के उसी क्रम के बारे में हैं:

 procedure TIRPC.Connect; begin if Assigned(dev) then Exit; HID.CheckOutByID(Dev,VID,Pid); end; 

कनेक्शन स्थिति (कनेक्टेड संपत्ति) देव सूचक द्वारा निर्धारित की जाती है - यदि यह खाली नहीं है, तो कनेक्शन सफल था।

WriteIRPCcmd (cmd: TIRPCReport) विधि उस पैकेट के साथ कमांड भेजती है जिसे आप डिवाइस में प्री-पॉप्युलेट करते हैं।
ReadIRPCState विधि (var रिपोर्ट: TIRPCReport): बूलियन zaroshivaet एक डिवाइस पर एक पैकेट। यदि पैकेट सफलतापूर्वक प्राप्त हुआ था, तो यह सही लौटाता है, और पैकेट स्वयं रिपोर्ट पैरामीटर को लिखा जाता है।

प्रक्रिया लोडिरकोड्स (irFile: string); - रिमोट कंट्रोल के बटनों के नाम के पत्राचार की फाइल को उनके कोड में लोड करता है। फ़ाइल का एक सरल प्रारूप है: प्रत्येक पंक्ति में अल्पविराम से अलग बटन का नाम और कोड होता है
TVFM, $ FE01
यह विधि प्लगइन में मांग में नहीं है - बटन कोड को मिक्स को प्रेषित किया जाता है, आप खुद इसे कहते हैं कि आप क्या चाहते हैं, क्योंकि कार्यक्रम यह नहीं दिखाता है कि आपने इसे क्या भेजा है। लेकिन अपने कार्यक्रम में आप सामान्य मानव बटन नाम दिखा सकते हैं।
BtnName फ़ंक्शन 16 बिट मान या हेक्स के साथ स्ट्रिंग के रूप में पारित कोड के अनुसार बटन का नाम लौटाता है।
फ़ंक्शन BtnName (btnCode: शब्द): स्ट्रिंग; अधिभार;
फ़ंक्शन BtnName (btnCode: string): स्ट्रिंग; अधिभार;
IRButtons प्रॉपर्टी में बटन और उनके कोड की एक सूची होती है
संपत्ति IRButtons: TStringList पढ़ें fIRButtons;
IRname संपत्ति - लोडरकोड विधि द्वारा लोड किए गए रिमोट कंट्रोल का नाम (फ़ाइल का नाम .ir एक्सटेंशन के बिना)।
प्रॉपर्टी IRName: string read fIRName;

डिवाइस से पैकेज कैसे प्राप्त करें?

 function TIRPC.ReadIRPCState; begin Result:=false; if not Assigned(dev) then Exit; Result:=dev.GetFeature(report,sizeof(TIRPCReport){Dev.Caps.FeatureReportByteLength}); end; 

GetFeature पद्धति का उपयोग करते हुए, हम पैकेट के लिए बफर को स्थानांतरित करते हैं, हम पैकेट को इसमें प्राप्त करते हैं। यदि कोई कनेक्शन नहीं है, तो विधि झूठी वापस आ जाएगी।
पैकेट को उसी तरह डिवाइस में स्थानांतरित किया जाता है:

  dev.SetFeature(cmd,SizeOf(cmd)); 

दरअसल प्लगइन खुद एक dll के रूप में बना है।
उसके द्वारा अपेक्षित कार्य कार्यान्वित किए जाते हैं:
सक्षम, अक्षम, GetName, GetInfo, GetVer, GetAuthor, IsInteractive, IsHavetettings;
तदनुसार, सक्षम में, हम कनेक्ट विधि का उपयोग करके डिवाइस से कनेक्ट करते हैं, टाइमर शुरू करते हैं, जो रीडस्टेट का उपयोग करके प्रत्येक 500 एमएस को डिवाइस को प्रदूषित करेगा, और यदि यह बटन कोड प्राप्त करता है, तो इसे MKey को भेजें:

 function Enable: boolean; stdcall; begin IRPCPlugin:=TIrPCPlugin.Create; IRPCPlugin.IRPC.Connect; tmrReadState:=TTimer.Create(nil); tmrReadState.Interval:=500; tmrReadState.OnTimer:=IRPCPlugin.ReadState; tmrReadState.Enabled:=true; result:=true; end; 

 procedure TIRPCPlugin.ReadState(Sender: TObject); var mainWnd:hWnd; pluginact:string; Btn:Word; begin IRPCPlugin.IRPC.Connect; If not IRPCPlugin.IRPC.Connected then MessageBox(0,'IRPC device not connected', 'IRPC', MB_ICONEXCLAMATION); if rep.cmd<>cmdGetIRPCState then begin rep.cmd:=cmdGetIRPCState; IRPCPlugin.IRPC.WriteIRPCcmd(rep); end; IRPCPlugin.IRPC.ReadIRPCState(rep); Btn:=rep.data[1] shl 8+rep.data[2]; If btn<>0 then begin pluginact:=Format('%x',[Btn]); mainwnd:=Findwindow('TMainForm', 'MKey'); SendMessage(mainwnd, WM_PLUGIN, plugin_interface_version, DWORD(PChar(pluginact))); end; end; 

अक्षम करने की प्रक्रिया में, डिवाइस से डिस्कनेक्ट करें:

 function Disable: boolean; stdcall; begin IRPCPlugin.IRPC.Disconnect; FreeAndNil(IRPCPlugin); FreeAndNil(tmrReadState); result:=true; end; 

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

• अधिसूचना क्षेत्र में सहयोग करता है।
• क्लिक पर खुलासा होता है।
• मतदान अवधि सेटिंग में कॉन्फ़िगर की गई है
• एस - EEPROM में राज्य बचाओ
• एल - EEPROM से लोडिंग राज्य
• पावर बीटीएन - फ़ंक्शन को करता है fPCPwrSwitch (यानी, पीसी पर पावर बटन दबाता है)
• शो लॉग घटनाओं की एक सूची दिखाएगा - एक पीसी सोते हुए / सोते हुए। (मेरे पास नींद के लिए एक पावर बटन है)।
• बाकी टेस्ट बटन हैं।
• तीन बल्बों में से एक पर क्लिक करके, हम तदनुसार स्विच करते हैं - एलईडी, रिले 1, रिले 2 (टूलटिप्स यह पता लगाने में मदद करेंगे)

ऐसा लगता है कि उन्होंने सब कुछ महत्वपूर्ण बताया। यदि आपके कोई प्रश्न हैं, तो टिप्पणियों में पूछें, मैं उत्तर देने का प्रयास करूंगा।

स्रोत कोड

• USB-IRPC फर्मवेयर स्रोत
• योजनाबद्ध आरेख, प्रिंट सर्किट बोर्ड, स्टिकर, डिप्रेस और पिंग प्रारूप में असेंबली के लिए चित्र-धोखा शीट ।
• MKey के लिए प्लगइन के स्रोत
• प्रबंधन कार्यक्रम - डेल्फी 2010 पर अल्फा संस्करण ।