मंजिल के लिए पेडल: पीसी के लिए एक और पैर मैनिपुलेटर बनाएं

ठीक एक महीने पहले, मैं इस लेख को लेकर आया था, जो विम के बारे में बताता है। अपने लंबे तीन मिनट के अध्ययन के बाद, मुझे पता चला कि यह विषय अब नया और काफी लोकप्रिय नहीं है। मैं स्वयं आपातकाल के मामले में विम का उपयोग करता हूं (यदि मुझे कंसोल में काम करना है, तो मुझे नैनो पसंद है), लेकिन आप अन्य अनुप्रयोगों के लिए भी ऐसा कर सकते हैं।

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

मुझे इसकी आवश्यकता क्यों है?

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

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

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

सामान्य तौर पर, मुझे आशा है कि मैंने आपको आश्वस्त किया है, जिसका अर्थ है कि यह सीधे विकास के लिए सीधे शुरू करने का समय है।

आवश्यक संसाधन

• दरअसल, पैडल। इस तथ्य के कारण कुछ कठिनाइयाँ तुरंत सामने आईं कि मैं ऐसे पैडल के लिए एक नाम के बारे में नहीं सोच सकता था। मुझे केवल इतना पता था कि सिलाई मशीनों में ऐसी चीजों का उपयोग किया जाता है। सामान्य तौर पर, इलेक्ट्रिक पेडल के अनुरोध पर , मैं अभी भी खोजने में कामयाब रहा कि मुझे एलीएक्सप्रेस पर क्या चाहिए, और दो बार सोचने के बिना, मैंने 3 टुकड़े का आदेश दिया।
  
• नियंत्रक। पैडलबोर्ड को कीबोर्ड का अनुकरण करना चाहिए और, संभवतः, माउस को बिना अनावश्यक ड्राइवरों के पीसी से कनेक्ट करने में सक्षम होना चाहिए। इसके लिए, अरुडिनो प्रो माइक्रो बोर्ड एकदम सही है, हालांकि, इसमें कुछ निष्कर्ष नहीं हैं, इसे यथासंभव कॉम्पैक्ट बनाया गया है। हम उसी एलिएक्सप्रेस पर जाते हैं, और इस चमत्कार के चीनी संस्करण को खरीदते हैं।
  
• तारों। तालिका के तहत 3 पेडल रखने के लिए, आपको कम से कम एक मीटर की लंबाई के साथ कम से कम चार-तार तार की आवश्यकता होती है। यहां, मुझे लगता है, समस्याएं पैदा नहीं होनी चाहिए।
  
• आरजीबी एलईडी और बटन। पहले मोड को इंगित करने के लिए आवश्यक है, और दूसरा उन्हें स्विच करना है।
  
• ठीक है, निश्चित रूप से, हमें एक Arduino IDE, एक टांका लगाने वाला लोहा और सीधे हथियार चाहिए।
  

डिवाइस आरेख

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



पैडल के लिए, मैंने एक बार में 4 पोर्ट पीबी 1-पीबी 4 आवंटित करने का फैसला किया, यानी बाएं के लिए दो और दाहिने पैर के लिए दो, हालांकि अब तक मेरे पास केवल 3 पैडल हैं। इसके अलावा, वे सभी एक ही समूह में हैं और एक ही स्थान पर स्थित हैं। एलईडी के तहत, मैंने आउटपुट PD0, PD1 और PD4, बटन के नीचे - PD7 लिया।
इस मामले में, हमें किसी भी पुल-अप प्रतिरोधों की आवश्यकता नहीं है, यदि आप उन लोगों का उपयोग करते हैं जो नियंत्रक में निर्मित होते हैं। हालांकि, तब, जब आप एक बटन या पेडल दबाते हैं, तो इनपुट कम होगा, और जब जारी किया जाता है, तो यह उच्च होगा, अर्थात, प्रेस उलटा हो जाएगा, और आपको इस बारे में नहीं भूलना चाहिए।

कोड लेखन

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

ट्रेनिंग

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

struct pedal { char port; //   char state; //  ,   char oldState; //  ,   char pos1; //  1 char pos2; //  2 unsigned char type; //0 —   , 1 —  ; unsigned char act1[16]; // 1 unsigned char act2[16]; // 2 }; 

Arduino में मेमोरी बहुत कम है और 8-बिट भी है, इसलिए जहां संभव हो वहां इंट के बजाय चार का उपयोग करने की कोशिश करना सबसे अच्छा है।

हमें कीबोर्ड के रूप में काम करने के लिए मानक कीबोर्ड लाइब्रेरी की भी आवश्यकता है।

प्रसंस्करण पर क्लिक करें

अब हमें एक दुभाषिया बनाने की ज़रूरत है जो सरणी से डेटा पढ़े और इसे कीस्ट्रोक्स के रूप में मशीन में भेजेगा, साथ ही विभिन्न आंतरिक कमांड के लिए कई मानों का चयन करेगा। हम कुंजी कोड के साथ पृष्ठ खोलते हैं, और देखते हैं कि हम क्या और कैसे क्लिक कर सकते हैं। मैंने सभी प्रकार के कीबोर्ड मानकों का गहरा और अध्ययन नहीं किया, क्योंकि इस तरह की परियोजना के लिए यहां की जानकारी मुझे काफी पसंद आई। पहली छमाही मानक ASCII वर्णों के लिए आरक्षित है (हालांकि उनमें से कुछ मुद्रण योग्य या उपयोग नहीं किए गए हैं), दूसरी छमाही विभिन्न संशोधक कुंजियों के लिए है। बाएं और दाएं कुंजियों के लिए अलग-अलग कोड भी हैं, जो बहुत ही मनभावन था, लेकिन मैंने नंपाद से संख्याओं के लिए कोई विशेष कोड नहीं देखा था, हालांकि, जहां तक ​​मुझे पता है, उन्हें सामान्य संख्याओं की तुलना में सिस्टम में एक विशेष तरीके से माना जाता है। शायद उनके कोड कहीं "छेद" में हैं, सीमाओं के बीच, लेकिन अब उस बारे में नहीं है। तो, सबसे बड़ी कोड अप की - 218 है, जिसका अर्थ है कि 219-255 की सीमा को मुफ्त, अच्छी तरह से माना जा सकता है, या कम से कम कोई महत्वपूर्ण कुंजी नहीं है।

 void pedalAction() { //255  ,     if (pedal1->type == 255) return; //     unsigned char *prg; //     char *pos; if (pedal1->type) { //       int current; if ((current = digitalRead(ports[num])) != oldState[num]) { if (!current) state[num] = !state[num]; oldState[num] = current; } if (!state[num]) { //act1 pos2[num] = 0; pos = &(pos1[num]); prg = pedal1->act1; } else { //act2 pos1[num] = 0; pos = &(pos2[num]); prg = pedal1->act2; } } else { //        if (!digitalRead(ports[num])) { //act1 pos2[num] = 0; pos = &(pos1[num]); prg = pedal1->act1; } else { //act2 pos1[num] = 0; pos = &(pos2[num]); prg = pedal1->act2; } } while (1) { if (prg[*pos] == 254) { // ,   *pos Keyboard.press(prg[++*pos]); } else if (prg[*pos] == 253) { // ,   *pos Keyboard.release(prg[++*pos]); } else if (prg[*pos] == 252) { //" ",    ++*pos; return; } else if (prg[*pos] == 251) { //       *pos+1 *pos = prg[*pos + 1]; return; } else if (prg[*pos] == 255 || prg[*pos] == 0) { // ,   return; } else { //   Keyboard.write(prg[*pos]); } //       ,     if (++*pos>=16) pos = 0; } } 

मुझे लगता है कि यहां तक ​​कि सी के उच्चतम स्तर के ज्ञान वाले व्यक्ति को यहां क्या हो रहा है, इस बारे में कोई सवाल नहीं होगा। सबसे पहले, फ़ंक्शन वांछित पेडल का चयन करता है और निर्धारित करता है, पैडल के मोड और स्थिति के आधार पर, कौन सा कार्यक्रम किया जाना चाहिए। सरणी के प्रत्येक तत्व को पढ़ते समय, यदि यह एक नियंत्रण चरित्र नहीं है, तो Keyboard.write () फ़ंक्शन को कहा जाता है, जो एक कुंजी को दबाने और जारी करने का अनुकरण करता है। नियंत्रण वर्णों को अलग से संसाधित किया जाता है और कुंजी संयोजनों को जकड़ने और कार्यक्रम को नेविगेट करने के लिए आवश्यक है।


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

 struct pedal *pedal1 = {15, 0, 0, 0, 0, 0, "Hello, world!\0", 0}; void prepare () { pinMode(15, 2); //2 - INPUT_PULLUP,        Keyboard.begin(); } void loop() { pedalAction(); } 

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

एक पेडल अच्छा है, और दो बेहतर है

अब कई पैडल से संकेतों के प्रसंस्करण से निपटने का समय है, साथ ही स्विचिंग मोड भी जोड़ें। लेख की शुरुआत में, 4 पोर्ट पेडल के लिए आवंटित किए गए थे, जिनमें से प्रत्येक को सात मोड में काम करने की अनुमति दी जानी चाहिए। क्यों 7? क्योंकि PWM का उपयोग किए बिना, हमारी एलईडी केवल 7 रंग दे सकती है, और आठवें बंद। यह राशि औसत उपयोगकर्ता के लिए काफी पर्याप्त है, लेकिन चरम मामलों में इसे आसानी से बढ़ाया जा सकता है। इसलिए हम पैडल को 7 x 4 के दो-आयामी सरणी में संग्रहीत करेंगे। मेमोरी को रोकना नहीं करने के लिए, कई संरचनाओं, जैसे कि पोर्ट नंबर, के लिए सामान्य मान अलग-अलग सरणियों में निकाले जा सकते हैं। परिणामस्वरूप, हमें कुछ ऐसा मिलता है:

 struct pedal { unsigned char type; unsigned char act1[16]; unsigned char act2[16]; }; struct pedal pedals[7][4] = { { { 255, {"Hello, world!\0"}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} }, { { 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} }, { { 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} }, { { 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} }, { { 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} }, { { 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} }, { { 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}} } }; char ports[4] = {15, 16, 14, 8}; char pos1[4] = {0, 0, 0, 0}; char pos2[4] = {0, 0, 0, 0}; char state[4] = {0, 0, 0, 0}; char oldState[4] = {0, 0, 0, 0}; char mode = 0; //  char curPedal = 0; //   

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

 void prepare(){ pinMode(2, 1); pinMode(3, 1); pinMode(4, 1); pinMode(6, 2); for (int i : ports) pinMode(i, 2); Keyboard.begin(); } void loop() { for (int i = 0; i < 6; i++) { int current; if ((current = digitalRead(modeButton)) != last) { if (!current) { if (++mode >= 7) mode = 0; while (pedals[mode][0].type == 255 && pedals[mode][1].type == 255 && pedals[mode][2].type == 255 && pedals[mode][3].type == 255) if (++mode >= 7) { mode = 0; break; } } last = current; digitalWrite(2, (mode + 1) & 0b001); digitalWrite(3, (mode + 1) & 0b010); digitalWrite(4, (mode + 1) & 0b100); for (int i = 0; i < 4; i++) { pos1[i] = 0; pos2[i] = 0; state[i] = 0; oldState[i] = 0; } delay(50); } curPedal = i; pedalAction } } } 

नियंत्रक अप्रयुक्त मोड पर विचार करेगा यदि इसमें एक भी पेडल घोषित नहीं किया गया है (मोड = 255), जिसका अर्थ है कि जब यह हिट होता है, तो यह तुरंत अगले पर जाएगा, लेकिन पहला मोड हमेशा मौजूद रहेगा। मोड स्विच करते समय, सरणियों में सभी मानों को शून्य कर दिया जाता है, क्योंकि हमें उन्हें प्रत्येक मोड (दाएं?) के लिए सहेजने की आवश्यकता नहीं होती है, और फिर लूप सभी पेडल को बायपास करता है और उनके लिए पेडलशन को कॉल करता है।

साथ ही, पैडलएशन () विधि की शुरुआत में, आपको निम्न पंक्ति जोड़ने की आवश्यकता है ताकि यह समझ सके कि किन संरचनाओं से निपटना है:

 struct pedal *pedal1 = &pedals[mode][curPedal]; 

मौजूदा पेडल 1 संरचना को अनावश्यक के रूप में हटाया जा सकता है।

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

कहना मुश्किल है हाँ करना आसान है

मैंने एक साइकिल का आविष्कार नहीं किया, लेकिन समाप्त ArduinoThread पुस्तकालय लिया। यहां आप थोड़ा पढ़ सकते हैं कि यह कैसे काम करता है और इसे डाउनलोड करता है। आप लाइब्रेरी को Arduino IDE से ही डाउनलोड कर सकते हैं। संक्षेप में, यह आपको समय-समय पर एक निश्चित अंतराल के साथ एक कार्य करने की अनुमति देता है, जबकि यदि आप अंतराल से अधिक समय लेते हैं, तो आप एक अनंत लूप में जाने की अनुमति नहीं देते हैं। आपको क्या चाहिए प्रत्येक पेडल के लिए थ्रेड्स के साथ एक और सरणी बनाएं:

 Thread pedalThreads[6] = {Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10)}; 

अब हमारे पास 6 समान आभासी धागे हैं, लेकिन एक ही समय में वे अलग-अलग वस्तुएं हैं।

चलो नई कार्यक्षमता के साथ काम करने के लिए पैडल बाईपास चक्र को फिर से लिखते हैं:

 ... for (int i = 0; i < 4; i++) { if (pedalThreads[i].shouldRun()) { curPedal = i; pedalThreads[i].run(); } } ... 

अब कार्यक्रम सरणी में मान 252, जो "कुछ नहीं करने से मेल खाती है", 10 मिलीसेकेंड की देरी देगा (हालांकि वास्तव में थोड़ा अधिक है, क्योंकि कोड निष्पादन में भी समय लगता है)। दुभाषिया में कुछ पंक्तियों को जोड़ने से यह कई "क्वांटा" में देरी को सेट करना संभव बना देगा, सरणी के केवल 2 बाइट्स खर्च करना:

 ... if (wait[num]) { wait[num]--; return; } else if (prg[*pos] == 250) { wait[num] = prg[++*pos]; } ... 

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

अब, 2.55 सेकंड की देरी सेट करने की संभावना के साथ, कार्यक्रमों द्वारा कुंजी की परिभाषा के साथ समस्याएं पैदा नहीं होनी चाहिए।

ऑन-द-गो प्रोग्रामिंग

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

 ... if (!digitalRead(modeButton)) { //  Serial.begin(9600); while (!Serial) { PORTD = 0b00000000 + (PORTD & 0b11101100); delay(250); PORTD = 0b00010000 + (PORTD & 0b11101100); delay(250); } Serial.println(F("***Programming mode***")); Serial.println(F("Write the command as <m> <p> <c>")); Serial.println(F("m - number of mode, one digit")); Serial.println(F("p - number of pedal, one digit")); Serial.println(F("c - command, it can be:")); Serial.println(F("\tr - read pedal info")); Serial.println(F("\tw - enter to writing mode and change pedal programm")); Serial.println(F("\te - erase pedal programm and delete it")); Serial.println(F("There are up to 7 modes and 6 pedals per mode can be configured")); Serial.println(F("Mode will be incative if there is no pedal configured in it")); while (1) { while (Serial.available()) { Serial.read(); delay(1); } PORTD = 0b00000001 + (PORTD & 0b11101100); Serial.println(""); Serial.println(F("Enter command")); while (!Serial.available()); PORTD = 0b00000010 + (PORTD & 0b11101100); delay(3); if (Serial.available() == 3) { int curMode = Serial.read() - 48; int curPedal = Serial.read() - 48; char cmd = Serial.read(); if (curMode > 6 || curMode < 0) { Serial.print(F("Mode must be in 0-6. You entered ")); Serial.println(curMode); continue; } if (curPedal > 3 || curPedal < 0) { Serial.print(F("Pedal must be in 0-3. You entered ")); Serial.println(curPedal); continue; } Serial.println(); if (cmd == 'r') { int beginAddress = sizeof(struct pedal) * (curMode * 6 + curPedal); Serial.print("type: "); int curAddress = beginAddress; Serial.println(EEPROM[curAddress++]); Serial.print("act1: "); for (int i = curAddress ; i < curAddress + (sizeof(struct pedal) - 1) / 2; i++) { Serial.print(EEPROM[i]); Serial.print("\t"); } Serial.println(); curAddress = beginAddress + 1 + (sizeof(struct pedal) - 1) / 2; Serial.print("act2: "); for (int i = curAddress ; i < curAddress + (sizeof(struct pedal) - 1) / 2; i++) { Serial.print(EEPROM[i]); Serial.print("\t"); } Serial.println(); } else if (cmd == 'w') { Serial.println(F("Enter type:")); PORTD = 0b00000001 + (PORTD & 0b11101100); while (!Serial.available()); int beginAddress = sizeof(struct pedal) * (curMode * 6 + curPedal); int curAddress = beginAddress; PORTD = 0b00000010 + (PORTD & 0b11101100); EEPROM[curAddress++] = (char)Serial.parseInt(); PORTD = 0b00000001 + (PORTD & 0b11101100); Serial.println(F("Enter act1 in DEC divided by space:")); while (Serial.available()) { Serial.read(); delay(1); } while (!Serial.available()); PORTD = 0b00000010 + (PORTD & 0b11101100); while (Serial.available()) { EEPROM[curAddress++] = (char)Serial.parseInt(); delay(1); } PORTD = 0b00000001 + (PORTD & 0b11101100); curAddress = beginAddress + 1 + (sizeof(struct pedal) - 1) / 2; Serial.println(F("Enter act2 in DEC divided by space:")); while (Serial.available()) { Serial.read(); delay(1); } while (!Serial.available()); PORTD = 0b00000010 + (PORTD & 0b11101100); while (Serial.available()) { EEPROM[curAddress++] = (char)Serial.parseInt(); delay(1); } PORTD = 0b00000001 + (PORTD & 0b11101100); Serial.println(F("Finished, don't forget to verify written data!")); } else if (cmd == 'e') { int beginAddress = sizeof(struct pedal) * (curMode * 6 + curPedal); Serial.println(F("Disabling pedal...")); PORTD = 0b00000010 + (PORTD & 0b11101100); EEPROM[beginAddress] = 255; PORTD = 0b00000001 + (PORTD & 0b11101100); Serial.println(F("Pedal disabled")); } } else { Serial.println(F("Incorrect command, please read help above")); } }; } ... 

इस कोड को इसमें निहित मदद से समझाया गया है: मोड नंबर, पेडल नंबर और एक कमांड के लिए एक स्पेस नंबर दर्ज किया गया है, जिसमें से 3 - पढ़ना, लिखना और प्रोग्राम डिलीट करना है। पेडल पर सभी डेटा एक के बाद एक 33 बाइट्स के क्रम में संग्रहीत किया जाता है, अर्थात्, पेडल का प्रकार, और दो प्रोग्राम, और यह कि हम EEPROM के 1024 बाइट्स के 7 * 4 * 33 = 924 पर कब्जा कर लेते हैं। मैंने मेमोरी में पैडल के गतिशील आकार का उपयोग करने का विकल्प फेंक दिया, क्योंकि इस मामले में जब एक पेडल को रीप्रोग्राम करने पर आपको लगभग सभी कोशिकाओं को अधिलेखित करना होगा, और पुनर्लेखन चक्रों की एक सीमित संख्या है, इसलिए हम इसे यथासंभव कम करने की सलाह देते हैं।


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

छंटनी किए गए संरचनाओं के संरक्षण के साथ, अब हमें किसी तरह अपने डेटा को वहां से बाहर निकालने और इसे "पेडल" में बदलने की जरूरत है:

 ... for (int i = 0; i < 7; i++) { for (int j = 0; j < 4; j++) { struct pedal *p = &pedals[i][j]; int beginAddress = sizeof(struct pedal) * (i * 6 + j); int curAddress = beginAddress; unsigned char type = EEPROM[curAddress++]; if (type == 0 || type == 1) { p->type = type; for (int k = 0 ; k < 16; k++) { p->act1[k] = EEPROM[curAddress++]; } for (int k = 0 ; k < 16; k++) { p->act2[k] = EEPROM[curAddress++]; } } } } ... 

यहां कुछ भी अलौकिक नहीं होता है: नियंत्रक डेटा को मेमोरी से पढ़ता है और इसके साथ मौजूदा संरचनाओं को भरता है।

UART के माध्यम से प्रोग्रामिंग का लाभ यह है कि हमें फिर से किसी विशेष ड्राइवर की आवश्यकता नहीं है, इसलिए आप फोन से भी मैनिपुलेटर के व्यवहार को सेट कर सकते हैं।

प्रदर्शन

पूर्ण स्रोत कोड

अंतभाषण

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

इकट्ठे पेडलबोर्ड: