🤣 🐥 💑 एमके नियंत्रण के साथ स्वचालित एंटीना स्विच 🎫 🥅 ✨

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

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

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

आप यह पता कर सकते हैं कि वर्तमान में ट्रांसीवर किस सीमा पर काम कर रहा है: आप सिग्नल की आवृत्ति को माप सकते हैं, आप कैट इंटरफ़ेस के माध्यम से डेटा प्राप्त कर सकते हैं, लेकिन मेरे लिए सबसे सरल बात बाहरी एम्पलीफायर को जोड़ने के लिए YAESU ट्रांसीवर इंटरफेस का उपयोग करना है। बाइनरी कोड में इसकी 4 सिग्नल लाइनें हैं, जो वर्तमान सीमा को दर्शाती हैं। वे 0 से 5 वोल्ट तक एक तार्किक संकेत देते हैं और उन्हें एमटी के प्रतिरोधों की एक जोड़ी के माध्यम से पैरों से जोड़ा जा सकता है।

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

इसके अलावा, एमएफजे ट्यूनर रिमोट कंट्रोल को संकेत प्रेषित कर सकता है कि यह ट्यूनिंग है और एंटीना ट्यून है। ऐसा करने के लिए, कंपनी नियंत्रण कक्ष MFJ में दो नियंत्रण एलईडी हैं। एल ई डी के बजाय, मैंने ऑप्टोकोप्लर्स को कनेक्ट किया और उन्हें एमके से संकेत भेजा, ताकि मैं एक डिस्प्ले पर सभी जानकारी देख सकूं। तैयार डिवाइस इस तरह दिखता है।

संक्षेप में सब कुछ की तरह घर का बना। अब सॉफ्टवेयर भाग के बारे में। कोड Atmel स्टूडियो (Atmel वेबसाइट से मुफ्त डाउनलोड) में लिखा गया है। शुरुआती के लिए प्रोजेक्ट लोकप्रिय Atmega8 MK का उपयोग करने की निम्नलिखित विशेषताओं को दर्शाता है:

कनेक्ट बटन
ट्रांसीवर और ट्यूनर से डिजिटल सिग्नल के लिए लाइन इनपुट कनेक्ट करें
एंटीना स्विचिंग रिले के नियंत्रण आउटपुट को कनेक्ट करना
एक सिंगल लाइन एलसीडी डिस्प्ले कनेक्ट करना
बजर कनेक्शन और ध्वनि उत्पादन
एडीसी एनालॉग इनपुट लाइन कनेक्शन और वोल्टेज माप
व्यवधान का उपयोग करना
बटन दबाए जाने के समय को गिनने के लिए टाइमर का उपयोग करना
वॉचडॉग का उपयोग करना
चयनित एंटेना को स्टोर करने के लिए गैर-वाष्पशील मेमोरी का उपयोग करना
डिबग प्रिंटिंग के लिए UART का उपयोग करना
निष्क्रिय एमके में ऊर्जा की बचत

तो चलिए शुरू करते हैं। पाठ के पाठ्यक्रम में, लागू एमके के सभी प्रकार के रजिस्टर नाम और स्थिरांक होंगे। यह arduino नहीं है, यहां, दुर्भाग्य से, आपको एमके पर डेटाशीट पढ़ना होगा। अन्यथा, आप यह नहीं समझ पाएंगे कि इन सभी रजिस्टरों का क्या मतलब है और आप उनके मूल्यों को कैसे बदल सकते हैं। लेकिन एक पूरे के रूप में कार्यक्रम की संरचना समान रहेगी।

सबसे पहले, बटन को एमके से कनेक्ट करें

यह सबसे सरल है। हम एक संपर्क को एमके पैर, दूसरे बटन के संपर्क को जमीन से जोड़ते हैं। काम करने के लिए बटन के लिए, आपको एमके में पुल-अप रोकनेवाला चालू करना होगा। वह + 5 वी बस के प्रतिरोध के माध्यम से बटन को कनेक्ट करेगा। यह करने के लिए काफी सरल है:

PORTB |= (1 << PB2); // pullup resistor

इसी तरह, सभी डिजिटल इनपुट जो एक ग्राउंड फॉल्ट (ऑप्टोकॉपर्स, ट्रांसीवर से सिग्नल लाइन, पीटीटी सिग्नल) द्वारा नियंत्रित होते हैं + 5 वी बस में खींच लिए जाते हैं। कभी-कभी एमके और + 5 वी बस के इनपुट के बीच इस तरह के एक छोटे प्रतिरोध (उदाहरण के लिए 10k) को भौतिक रूप से मिलाप करना बेहतर होता है, लेकिन इस मुद्दे की चर्चा लेख के दायरे से बाहर है। चूंकि परियोजना में सभी इनपुट सिग्नल शायद ही कभी मूल्यों को बदलते हैं, इसलिए उन्हें हस्तक्षेप से बचाने के लिए 10 नैनोफैड कैपेसिटर द्वारा जमीन पर हिलाया जाता है।

अब हमारे पास PB2 इनपुट पर तार्किक 1 है, और जब आप बटन दबाते हैं, तो यह तार्किक होगा। 0. जब आप \ दबाना दबाते हैं, तो आपको बटन के संपर्क बाउंस को ट्रैक करने की आवश्यकता होती है, यह देखते हुए कि सिग्नल स्तर समय के साथ नहीं बदला है, 50 मिलीसेकंड कहते हैं। यह इस तरह से कार्यक्रम में किया जाता है:

  if(!(PINB&(1<<PINB2)) && !timer_on) { //    _delay_ms(50); if( !(PINB&(1<<PINB2)) ) { //        -   passed_secs = 0; timer_on = 1; } }

अब स्क्वीकर को कनेक्ट करें

यह एक ऑडियो पुष्टि संकेत देगा कि एंटीना एमके मेमोरी में दर्ज है। एक ट्वीटर सिर्फ एक पीजोइलेक्ट्रिक तत्व है। यह एमके फुट के लिए एक छोटे प्रतिरोध के माध्यम से जुड़ा हुआ है, और + 5 वी के दूसरे संपर्क से। इस बजर के काम करने के लिए, आपको सबसे पहले एमके फुट को आउटपुट डेटा में कॉन्फ़िगर करना होगा।

 void init_buzzer(void) { PORTB &= ~(1 << PB0); // buzzer DDRB |= (1 << PB0); // output PORTB &= ~(1 << PB0); }

अब इसका उपयोग किया जा सकता है। ऐसा करने के लिए, एक छोटा फ़ंक्शन लिखा जाता है जो एमके पैरों को 0 से 1 तक स्विच करने के लिए समय देरी का उपयोग करता है और इसके विपरीत। आवश्यक देरी के साथ स्विच करना एमके आउटपुट पर लगभग एक चौथाई सेकंड की अवधि के साथ 4 kHz ऑडियो सिग्नल उत्पन्न करना संभव बनाता है, जो कि पीजोइलेक्ट्रिक तत्व की आवाज़ है।

 void buzz(void) { //    4 0,25  for(int i=0; i<1000; i++) { wdt_reset(); //    PORTB |= (1 << PB0); _delay_us(125); PORTB &= ~(1 << PB0); _delay_us(125); } }

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

 #ifndef F_CPU # define F_CPU 16000000UL #endif #include <util/delay.h>

हम एमके रिले स्विचिंग एंटेना से कनेक्ट करते हैं

यहां आपको बस बाहर जाने के लिए एमके फुट को कॉन्फ़िगर करने की आवश्यकता है। एक रीड रिले एक मानक तरीके से एक प्रवर्धक ट्रांजिस्टर के माध्यम से इस पैर से जुड़ा हुआ है।

 void init_tuner_relay(void) { PORTB &= ~(1 << PB1); // relay DDRB |= (1 << PB1); // output PORTB &= ~(1 << PB1); }

कनेक्शन प्रदर्शित करें

मैंने पुराने हार्डवेयर से निकाले गए 1601 सिंगल-लाइन 16 कैरेक्टर एलसीडी डिस्प्ले का इस्तेमाल किया। यह प्रसिद्ध HD44780 नियंत्रक का उपयोग करता है, जिसके प्रबंधन के लिए नेटवर्क पर बहुत सारे पुस्तकालय उपलब्ध हैं। किसी तरह के व्यक्ति ने एक लाइटवेट डिस्प्ले कंट्रोल लाइब्रेरी लिखी, जिसका मैंने प्रोजेक्ट में इस्तेमाल किया। लाइब्रेरी की स्थापना हेडर फ़ाइल में इंगित करने के लिए कम हो गई है HD44780_Config.h वांछित प्रदर्शन पिन से जुड़े एमके पैरों की संख्या। मैंने 4 डेटा लाइनों पर डिस्प्ले कनेक्शन लगाया।

 #define Data_Length 0 #define NumberOfLines 1 #define Font 1 #define PORT_Strob_Signal_E PORTC #define PIN_Strob_Signal_E 5 #define PORT_Strob_Signal_RS PORTC #define PIN_Strob_Signal_RS 4 #define PORT_bus_4 PORTC #define PIN_bus_4 0 #define PORT_bus_5 PORTC #define PIN_bus_5 1 #define PORT_bus_6 PORTC #define PIN_bus_6 2 #define PORT_bus_7 PORTC #define PIN_bus_7 3

मेरे प्रदर्शन उदाहरण की एक विशेषता यह थी कि स्क्रीन पर एक पंक्ति को 8 वर्णों की दो पंक्तियों के रूप में प्रदर्शित किया गया था, इसलिए स्क्रीन के साथ अधिक सुविधाजनक काम के लिए कार्यक्रम में एक मध्यवर्ती स्क्रीन बफर बनाया गया था।

 void init_display(void) { PORTC &= ~(1 << PC0); // display DDRC |= (1 << PC0); // output PORTC &= ~(1 << PC0); PORTC &= ~(1 << PC1); // display DDRC |= (1 << PC1); // output PORTC &= ~(1 << PC1); PORTC &= ~(1 << PC2); // display DDRC |= (1 << PC2); // output PORTC &= ~(1 << PC2); PORTC &= ~(1 << PC3); // display DDRC |= (1 << PC3); // output PORTC &= ~(1 << PC3); PORTC &= ~(1 << PC4); // display DDRC |= (1 << PC4); // output PORTC &= ~(1 << PC4); PORTC &= ~(1 << PC5); // display DDRC |= (1 << PC5); // output PORTC &= ~(1 << PC5); LCD_Init(); LCD_DisplEnable_CursOnOffBlink(1,0,0); } /*   16  0-3   40M     4-8   A:GP  A:IV     9-15    : TUNING=, TUNED==, HI-SWR= */ uchar display_buffer[]={' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; // 16    void update_display() { LCD_Init(); LCD_DisplEnable_CursOnOffBlink(1,0,0); //   16      8         LCD for (uchar i=0; i<8; i++){ LCD_Show(display_buffer[i],1,i); LCD_Show(display_buffer[i+8],2,i); } }

Update_display () फ़ंक्शन आपको स्क्रीन पर बफर की सामग्री को प्रदर्शित करने की अनुमति देता है। बफ़र में बाइट मान आउटपुट वर्णों के ASCII कोड हैं।

COM पोर्ट पर डिबग प्रिंटिंग आउटपुट

एमके में UART है और मैंने इसका उपयोग कार्यक्रम को डीबग करने के लिए किया। एमके को कंप्यूटर से कनेक्ट करते समय, आपको केवल यह याद रखना होगा कि एमके आउटपुट में सिग्नल का स्तर टीटीएल मानक में है, और आरएस 232 नहीं है, इसलिए आपको एक साधारण एडाप्टर की आवश्यकता है। मैंने USB-Serial अडैप्टर का इस्तेमाल किया, जो पूरी तरह से aliexpress पर है। किसी भी टर्मिनल कार्यक्रम, उदाहरण के लिए, आर्डिनो से, डेटा पढ़ने के लिए उपयुक्त है। UART पोर्ट सेटअप कोड:

 #define BAUD 9600 #include <stdio.h> #include <stdlib.h> #include <avr/io.h> // UART      RS232 void uart_init( void ) { /* //   UBRRH = 0; UBRRL = 103; //9600   16  */ #include <util/setbaud.h> UBRRH = UBRRH_VALUE; UBRRL = UBRRL_VALUE; #if USE_2X UCSRA |= (1 << U2X); #else UCSRA &= ~(1 << U2X); #endif //8  , 1  ,    UCSRC = ( 1 << URSEL ) | ( 1 << UCSZ1 ) | ( 1 << UCSZ0 ); //     // UCSRB = ( 1 << TXEN ) | ( 1 <<RXEN ); UCSRB = ( 1 << TXEN ); } int uart_putc( char c, FILE *file ) { //     while( ( UCSRA & ( 1 << UDRE ) ) == 0 ); UDR = c; wdt_reset(); return 0; } FILE uart_stream = FDEV_SETUP_STREAM( uart_putc, NULL, _FDEV_SETUP_WRITE ); stdout = &uart_stream;

आउटपुट स्ट्रीम सेट करने के बाद, आप पोर्ट पर प्रिंट करने के लिए सामान्य प्रिंटफ का उपयोग कर सकते हैं:

 printf( "Start flag after reset = %u\r\n", mcusr_mirror );

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

-Wl,-u,vfprintf -lprintf_flt

टाइमर के साथ काम करें और बाधित करें

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

 //   1    -     void timer1_init( void ) { TCCR1A = 0; //    1 -   /* 16000000 / 1024 = 15625 ,     15625      1  */ //  CTC, ICP1 interrupt sense (falling)(not used) + prescale /1024 +    (not used) TCCR1B = (0 << WGM13) | (1 << WGM12) | (0 << ICES1) | ((1 << CS12) | (0 << CS11) | (1 << CS10)) | (0 << ICNC1); OCR1A = 15625; //  TIMSK |= (1 << OCIE1A); } uchar timer_on = 0; volatile uchar passed_secs = 0; //      e ISR(TIMER1_COMPA_vect) { if (timer_on) passed_secs++; }

प्रोग्राम के मुख्य लूप में pass_secs के मूल्य की जाँच की जाती है। जब बटन दबाया जाता है, तो टाइमर शुरू होता है और फिर मुख्य कार्यक्रम चक्र में टाइमर मूल्य की जांच की जाती है, जबकि बटन दबाया जाता है। यदि यह मान 3 सेकंड से अधिक है, तो EEPROM लिखा जाता है, और टाइमर बंद हो जाता है।

अंतिम लेकिन कम से कम नहीं, सभी प्रारंभिकताओं के बाद, आपको sei () कमांड के साथ इंटरप्ट को सक्षम करने की आवश्यकता है।

ALC स्तर मापन

यह बिल्ट-इन एनालॉग-टू-डिजिटल कनवर्टर (एडीसी) का उपयोग करके बनाया गया है। मैंने ADC7 के इनपुट पर वोल्टेज को मापा। यह याद रखना चाहिए कि आप 0 से 2.5V तक के मान को माप सकते हैं। और मेरा इनपुट वोल्टेज -4 वी से 0 वी तक था। इसलिए, मैंने प्रतिरोधों पर सरलतम वोल्टेज विभक्त के माध्यम से एमके को जोड़ा, ताकि एमके इनपुट पर वोल्टेज स्तर एक निश्चित स्तर पर था। इसके अलावा, मुझे उच्च सटीकता की आवश्यकता नहीं थी, इसलिए मैंने 8-बिट रूपांतरण लागू किया (यह केवल ADCH रजिस्टर से डेटा पढ़ने के लिए पर्याप्त है)। संदर्भ स्रोत के रूप में, मैंने 2.56V पर एक आंतरिक आयन का उपयोग किया, यह गणनाओं को थोड़ा सरल करता है। एडीसी काम करने के लिए, जमीन पर आरईएफ पैर को 0.1 itorF संधारित्र कनेक्ट करना सुनिश्चित करें।

मेरे मामले में ADC लगातार काम करता है, ADC_vect व्यवधान को कॉल करके रूपांतरण के अंत की रिपोर्ट करता है। त्रुटि को कम करने के लिए कई रूपांतरण चक्रों के मूल्यों को औसत करने का अच्छा अभ्यास है। मेरे मामले में, मैंने 2500 परिवर्तनों के औसत का अनुमान लगाया। सभी एडीसी कोड इस तरह दिखता है:

 //        ALC #define SAMPLES 2500 //    #define REFERENCEV 2.56 //       #define DIVIDER 2.0 double realV = 0; //     ALC double current_realV = 0; volatile int sampleCount = 0; volatile unsigned long tempVoltage = 0; //     volatile unsigned long sumVoltage = 0; //         void ADC_init() // ADC7 { //   2,56, 8 bit  -   ADCH ADMUX = (1 << REFS0) | (1 << REFS1) | (1 << ADLAR) | (0 << MUX3) | (1 << MUX2) | (1 << MUX1) | (1 << MUX0); // ADC7 // , free running,   ADCSRA = (1 << ADEN) | (1 << ADFR) | (1 << ADIE) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); //  128 ADCSRA |= (1 << ADSC); // Start ADC Conversion } ISR(ADC_vect) //     2500  { if (sampleCount++) //    tempVoltage += ADCH; if (sampleCount >= SAMPLES) { sampleCount = 0; sumVoltage = tempVoltage; tempVoltage = 0; } ADCSRA |=(1 << ADIF); // Acknowledge the ADC Interrupt Flag } realV = -1.0*(DIVIDER * ((sumVoltage * REFERENCEV) / 256) / SAMPLES - 5.0); //   ALC if (realV < 0.0) realV = 0.0; printf("ALC= -%4.2f\r\n", realV); //

EEPROM का उपयोग करना

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

 EEMEM unsigned char ee_bands[16]; //         unsigned char avr_bands[16]; void EEPROM_init(void) { for(int i=0; i<16; i++) { avr_bands[i] = eeprom_read_byte(&ee_bands[i]); if (avr_bands[i] > 1) avr_bands[i] = ANT_IV; //    EEPROM   ,     FF } }

3 सेकंड के लिए एक बटन दबाने और मेमोरी पर लिखने के लिए प्रोसेसिंग कोड का एक स्निपेट:

  if (!(PINB&(1<<PINB2)) && passed_secs >= 3) { //    3  timer_on = 0; //   read_ant = avr_bands[read_band]; //     cli(); EEPROM_init(); //          sei(); if (read_ant) { avr_bands[read_band] = ANT_GP; } else { avr_bands[read_band] = ANT_IV; } cli(); eeprom_write_byte(&ee_bands[read_band], avr_bands[read_band]); //    EEPROM sei(); buzz(); }

वॉचडॉग का उपयोग करना

यह कोई रहस्य नहीं है कि मजबूत विद्युत चुम्बकीय हस्तक्षेप की शर्तों के तहत एमके फ्रीज कर सकता है। जब रेडियो प्रचालन में होता है, तो ऐसा हस्तक्षेप होता है कि "विडंबना शुरू हो जाती है", इसलिए आपको हैंग होने की स्थिति में एमके का सावधानीपूर्वक पुनः आरंभ सुनिश्चित करना होगा। एक वॉचडॉग टाइमर इस उद्देश्य को पूरा करता है। इसका उपयोग करना बहुत सरल है। सबसे पहले, प्रोजेक्ट में avr / wdt.h हैडर फ़ाइल शामिल करें। कार्यक्रम की शुरुआत में, सभी सेटिंग्स को पूरा करने के बाद, आपको wdt_enable (WDTO_2S) फ़ंक्शन को कॉल करके टाइमर शुरू करना होगा, और फिर समय-समय पर इसे wdt_reset () कॉल करके याद रखना होगा, अन्यथा यह एमके को ही पुनरारंभ करेगा। डिबगिंग के लिए यह पता लगाने के लिए कि एमके को क्यों पुनरारंभ किया गया था, आप विशेष MCUSR रजिस्टर के मूल्य का उपयोग कर सकते हैं, जिसके मूल्य को याद किया जा सकता है और फिर डिबग प्रिंट में आउटपुट किया जा सकता है।

 //        //     uint8_t mcusr_mirror __attribute__ ((section (".noinit"))); void get_mcusr(void) \ __attribute__((naked)) \ __attribute__((section(".init3"))); void get_mcusr(void) { mcusr_mirror = MCUSR; MCUSR = 0; wdt_disable(); } printf( "Start flag after reset = %u\r\n", mcusr_mirror );

पर्यावरण प्रेमियों के लिए ऊर्जा की बचत

जबकि एमके कुछ भी व्यस्त नहीं है, वह सो सकता है और अगले रुकावट के लिए इंतजार कर सकता है। इस मामले में, थोड़ी विद्युत ऊर्जा बचाई जाती है। एक तिपहिया, लेकिन क्यों एक परियोजना में इसका इस्तेमाल नहीं करते। इसके अलावा, यह बहुत सरल है। Avr / sleep.h शीर्ष लेख फ़ाइल शामिल करें। कार्यक्रम के मुख्य भाग में एक अनंत लूप होता है, जिसमें आपको sleep_cpu () फ़ंक्शन को कॉल करने की आवश्यकता होती है, जिसके बाद MC थोड़ा सो जाता है और मुख्य लूप बंद हो जाता है जब तक कि अगली रुकावट नहीं आती। वे टाइमर और एडीसी के संचालन के दौरान होते हैं, इसलिए एमके लंबे समय तक नहीं सोएगा। हाइबरनेशन मोड तब निर्धारित किया जाता है जब एमके को दो कार्यों को कॉल करके आरंभ किया जाता है:

  set_sleep_mode(SLEEP_MODE_IDLE); //     IDLE sleep_enable();

अभी के लिए बस इतना ही। मैंने स्विच बनाया, यह विफलताओं के बिना मेरे शौकिया रेडियो स्टेशन पर सफलतापूर्वक काम करता है। मुझे आशा है कि प्रदान की गई सामग्री शुरुआती के लिए उपयोगी होगी।

73 डे R2AJP

एमके नियंत्रण के साथ स्वचालित एंटीना स्विच