DIY क्लिकर

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

समस्या का बयान

कार्य, स्पष्ट रूप से, दो भागों में विभाजित है:

• माइक्रोकंट्रोलर हार्डवेयर, और
• सॉफ्टवेयर जो कंप्यूटर पर चलता है और उस पर नियंत्रण करता है।

चूंकि हम AVR के साथ काम कर रहे हैं, तो Arduino क्यों नहीं?

हम समस्या का समाधान करते हैं।
हार्डवेयर मंच:
HW1। फिक्सिंग के बिना बटन द्वारा प्रबंधन किया जाता है;
HW2। हम 3 बटन की सेवा करते हैं (सामान्य तौर पर, कितने नहीं);
HW3। दबाने को कम से कम 100 मिलीसेकंड के लिए बटन पकड़ना माना जाता है;
HW4। लंबे समय तक प्रेस की अनदेखी की जाती है। एक बार में 1 से अधिक बटन का प्रसंस्करण नहीं किया जाता है;
HW5। जब एक बटन दबाया जाता है, तो कंप्यूटर पर एक निश्चित कार्रवाई शुरू की जाती है;
HW6। अंतर्निहित सेरियल / यूएसबी-कनवर्टर के माध्यम से एक कंप्यूटर के साथ एक संचार इंटरफ़ेस प्रदान करें;
सॉफ्टवेयर प्लेटफॉर्म:
SW1। एक चयन योग्य सीरियल पोर्ट के माध्यम से कंप्यूटर के साथ संचार इंटरफ़ेस प्रदान करें;
SW2। वांछित ऑडियो प्लेयर को दिए गए ऑपरेटिंग सिस्टम की घटनाओं के लिए संचार इंटरफ़ेस के माध्यम से आने वाले कमांड को कनवर्ट करें।
SW3। कमांड प्रसंस्करण रोकें। जिसमें रिमोट कंट्रोल से कमांड शामिल है।

खैर, इसकी एक अतिरिक्त आवश्यकता है: यदि यह समय के गंभीर निवेश को पेश नहीं करता है, तो समाधान को यथासंभव सार्वभौमिक बनाएं।

डिजाइन और समाधान

HW1

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

और इसलिए - प्रत्येक बटन के लिए।

HW2

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

बटन वर्ग कुछ इस तरह दिखेगा:

 class Button { public: Button(uint8_t pin, ::Command command) : pin(pin), command(command) {} void Begin() { pinMode(pin, INPUT); digitalWrite(pin, 1); } bool IsPressed() { return !digitalRead(pin); } ::Command Command() const { return command; } private: uint8_t pin; ::Command command; }; 

इस कदम के बाद, हमारे बटन सार्वभौमिक और फेसलेस हो गए हैं, लेकिन आप उनके साथ उसी तरह काम कर सकते हैं।

बटन एक साथ रखें और उन्हें पिन असाइन करें:

 Button buttons[] = { Button(A0, Command::Previous), Button(A1, Command::PauseResume), Button(A2, Command::Next), }; 

सभी बटन का आरंभीकरण प्रत्येक बटन के लिए Begin() विधि को कॉल करके किया जाता है:

 for (auto &button : buttons) { button.Begin(); } 

यह निर्धारित करने के लिए कि कौन सा बटन दबाया गया है, हम बटन पर पुनरावृति करेंगे और जांच करेंगे कि क्या कुछ दबाया गया है। हम बटन इंडेक्स, या एक विशेष मान लौटाते हैं: "कुछ भी नहीं दबाया जाता है" और "एक से अधिक बटन दबाया जाता है।" विशेष मूल्य, निश्चित रूप से मान्य बटन संख्याओं के साथ ओवरलैप नहीं कर सकते हैं।

 int GetPressed() { int index = PressedNothing; for (byte i = 0; i < ButtonsCount; ++i) { if (buttons[i].IsPressed()) { if (index == PressedNothing) { index = i; } else { return PressedMultiple; } } } return index; } 

HW3

बटन एक निश्चित अवधि (कहते हैं, 10 एमएस) के साथ मतदान किया जाएगा, और हम मान लेंगे कि प्रेस एक ही बटन (और ठीक एक) मतदान चक्रों की एक संख्या के लिए आयोजित किया गया था। मतदान अवधि (10 एमएस) से निर्धारण समय (100 एमएस) को विभाजित करें, हमें 10 मिलते हैं।
हम एक डिक्रीमेंट काउंटर शुरू करेंगे, जिसमें हम प्रत्येक पीरियड को दबाने पर 10, और प्रत्येक अवधि में डीरेसमेंट लिखते हैं। जैसे ही यह 1 से 0 हो जाता है, हम प्रसंस्करण शुरू करते हैं (एचडब्ल्यू 5 देखें)

HW4

यदि काउंटर पहले से ही 0 है, तो कोई कार्रवाई नहीं की जाती है।

HW5

जैसा कि ऊपर उल्लेख किया गया है, एक निष्पादन योग्य कमांड प्रत्येक बटन के साथ जुड़ा हुआ है। इसे संचार इंटरफेस के माध्यम से प्रेषित किया जाना चाहिए।

इस स्तर पर, आप एक कीबोर्ड रणनीति लागू कर सकते हैं।

 void HandleButtons() { static int CurrentButton = PressedNothing; static byte counter; int button = GetPressed(); if (button == PressedMultiple || button == PressedNothing) { CurrentButton = button; counter = -1; return; } if (button == CurrentButton) { if (counter > 0) { if (--counter == 0) { InvokeCommand(buttons[button]); return; } } } else { CurrentButton = button; counter = PressInterval / TickPeriod; } } void loop() { HandleButtons(); delay(TickPeriod); } 

HW6

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

Arduino कार्यान्वयन

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

 const int TickPeriod = 10; //ms const int PressInterval = 100; //ms enum class Command : char { None = 0, Previous = 'P', Next = 'N', PauseResume = 'C', SuspendResumeCommands = '/', }; class Button { public: Button(uint8_t pin, Command command) : pin(pin), command(command) {} void Begin() { pinMode(pin, INPUT); digitalWrite(pin, 1); } bool IsPressed() { return !digitalRead(pin); } Command GetCommand() const { return command; } private: uint8_t pin; Command command; }; Button buttons[] = { Button(A0, Command::Previous), Button(A1, Command::PauseResume), Button(A2, Command::Next), Button(12, Command::SuspendResumeCommands), }; const byte ButtonsCount = sizeof(buttons) / sizeof(buttons[0]); void setup() { for (auto &button : buttons) { button.Begin(); } Serial.begin(9600); } enum { PressedNothing = -1, PressedMultiple = -2, }; int GetPressed() { int index = PressedNothing; for (byte i = 0; i < ButtonsCount; ++i) { if (buttons[i].IsPressed()) { if (index == PressedNothing) { index = i; } else { return PressedMultiple; } } } return index; } void InvokeCommand(const class Button& button) { Serial.write((char)button.GetCommand()); } void HandleButtons() { static int CurrentButton = PressedNothing; static byte counter; int button = GetPressed(); if (button == PressedMultiple || button == PressedNothing) { CurrentButton = button; counter = -1; return; } if (button == CurrentButton) { if (counter > 0) { if (--counter == 0) { InvokeCommand(buttons[button]); return; } } } else { CurrentButton = button; counter = PressInterval / TickPeriod; } } void loop() { HandleButtons(); delay(TickPeriod); } 

और हाँ, मैंने एक और बटन बनाया जो क्लाइंट को कमांड के हस्तांतरण को रोकने में सक्षम हो।

पीसी के लिए ग्राहक

हम दूसरे भाग को पास करते हैं।
चूंकि हमें एक जटिल इंटरफ़ेस की आवश्यकता नहीं है, और विंडोज के लिए बाध्यकारी, हम अलग-अलग तरीकों से जा सकते हैं, जैसे कि आप जैसे: WinAPI, MFC, डेल्फी, .NET (विंडोज फॉर्म, WPF, आदि), या एक ही प्लेटफार्मों पर कंसोल ( अच्छी तरह से, MFC को छोड़कर)।

SW1

यह आवश्यकता चयनित सॉफ़्टवेयर प्लेटफ़ॉर्म पर सीरियल पोर्ट के साथ संचार के माध्यम से बंद है: पोर्ट से कनेक्ट करें, बाइट्स पढ़ें, प्रक्रिया बाइट्स।

SW2

शायद सभी ने मल्टीमीडिया कीज़ के साथ कीबोर्ड देखे। कीबोर्ड पर प्रत्येक कुंजी, जिसमें मल्टीमीडिया एक भी शामिल है, का अपना कोड है। हमारी समस्या का सबसे सरल समाधान कीबोर्ड पर मल्टीमीडिया कुंजियों के कीस्ट्रोक्स का अनुकरण करना है। कुंजी कोड मूल स्रोत में पाया जा सकता है - MSDN । यह सीखना रहता है कि उन्हें सिस्टम में कैसे भेजा जाए। यह भी मुश्किल नहीं है: WinAPI में SendInput फ़ंक्शन है।
प्रत्येक कीस्ट्रोक दो घटनाएं हैं: दबाने और जारी करना।
यदि हम C / C ++ का उपयोग करते हैं, तो हम बस हेडर फ़ाइलों को शामिल कर सकते हैं। अन्य भाषाओं में, कॉल अग्रेषण किया जाना चाहिए। इसलिए, उदाहरण के लिए, .NET पर विकास करते समय आपको निर्दिष्ट फ़ंक्शन को आयात करना होगा और तर्कों का वर्णन करना होगा। मैंने एक इंटरफ़ेस विकसित करने की सुविधा के लिए .NET चुना।
मैंने परियोजना से केवल मूल भाग का चयन किया है, जो एक वर्ग तक Internals : Internals ।
यहाँ उसका कोड है:

  internal class Internals { [StructLayout(LayoutKind.Sequential)] [DebuggerDisplay("{Type} {Data}")] private struct INPUT { public uint Type; public KEYBDINPUT Data; public const uint Keyboard = 1; public static readonly int Size = Marshal.SizeOf(typeof(INPUT)); } [StructLayout(LayoutKind.Sequential)] [DebuggerDisplay("Vk={Vk} Scan={Scan} Flags={Flags} Time={Time} ExtraInfo={ExtraInfo}")] private struct KEYBDINPUT { public ushort Vk; public ushort Scan; public uint Flags; public uint Time; public IntPtr ExtraInfo; private long spare; } [DllImport("user32.dll", SetLastError = true)] private static extern uint SendInput(uint numberOfInputs, INPUT[] inputs, int sizeOfInputStructure); private static INPUT[] inputs = { new INPUT { Type = INPUT.Keyboard, Data = { Flags = 0 // Push } }, new INPUT { Type = INPUT.Keyboard, Data = { Flags = 2 // Release } } }; public static void SendKey(Keys key) { inputs[0].Data.Vk = (ushort) key; inputs[1].Data.Vk = (ushort) key; SendInput(2, inputs, INPUT.Size); } } 

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

SW3

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

एक निष्कर्ष के बजाय

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

आपका ध्यान के लिए धन्यवाद।