शुरुआत: कुछ दिनों में 2/3 माइक्रोसेकंड और अतिप्रवाह के एक चरण के साथ माइक्रोकंट्रोलर पर काउंटर करें

अक्सर जब एक माइक्रोकंट्रोलर डिवाइस के साथ काम करते हैं, तो "एन्थ्रोपोमोर्फिक" समय की गणना करने की आवश्यकता होती है - एक सेकंड के कितने अंश एलईडी लाइट्स, अधिकतम समय अंतराल डबल-क्लिक इत्यादि, सामान्य तौर पर, न केवल नैनो और माइक्रोसेकंड, बल्कि दसियों मिलीसेकंड, और यहां तक ​​कि सेकंड भी गिनते हैं। , मिनट और यहां तक ​​कि घंटे (मैं दिन के बारे में कहने से डरता हूं ...)।

एक ही समय में, माइक्रोकंट्रोलर में अक्सर माइक्रोसेकंड के साथ सौदा करने के लिए आवश्यक होता है - दालों की अवधि, एंटी-बाउंस प्रतीक्षा, आदि।

ऐसे उपकरण भी हैं जो लगातार कई घंटों तक काम करते हैं और यहां तक ​​कि एक दिन भी - विमान, ऑटोमोबाइल, डाउनहोल डिवाइस (वहां हम कई दिनों तक लगातार काम करने की बात कर रहे हैं)। इन मामलों में, टाइमर और 8-बिट चर का अतिप्रवाह अस्वीकार्य है।

मैं इन सभी को एक सुरुचिपूर्ण और सार्वभौमिक समाधान में संयोजित करना चाहता हूं - कई दिनों के लिए अतिप्रवाह नहीं, माइक्रोसेकंड की सटीकता के साथ समय को मापने का साधन।

क्यों नहीं? मैंने थोड़ी देर के लिए सामना किया और 8-बिट एवीआर माइक्रोकंट्रोलर्स के लिए एक समाधान को जन्म दिया। ऐसा करने के लिए, मैंने 8-बिट टाइमर काउंटर और 4-बाइट चर का उपयोग किया। मैं PICs और AT89 के साथ काम नहीं कर रहा हूं, और मैं अन्य एम्बेडेड प्लेटफार्मों के साथ दोस्त नहीं हूं। हालांकि, अगर पाठक मदद करते हैं, तो मैं उनके लिए करूंगा।

लाभ - कोड अत्यधिक दोहराने योग्य है (मैं पहले से ही इसके साथ 5 वीं डिवाइस करता हूं); काम में सादगी (काम के एक ग्राहक हिस्से के लिए रुकावट का उपयोग नहीं किया जाता है); कोड का क्लाइंट हिस्सा सशर्त रूप से प्लेटफ़ॉर्म-स्वतंत्र है; रुकावट में - समन का एक ऑपरेशन (लेकिन, हालांकि, 4-बाइट मान के लिए); कोई बाहरी उपकरण नहीं - वास्तविक समय टाइमर।

मुझे एक खामी मिली - एक ऐसा उपयोगी और हमेशा आवश्यक टाइमर व्यस्त है ...

लेख मुख्य रूप से शुरुआती लोगों के लिए दिलचस्प होगा - मैंने यहां अमेरिका की खोज नहीं की है।

सिद्धांत

इसलिए, मेरे पास 12MHz क्वार्ट्ज के साथ Atmega16A पर आधारित एक डिवाइस है। हम इसका टाइमर काउंटर लेते हैं। 0. यह आठ अंकों का टाइमर है - जो हमारे लिए पर्याप्त है। क्यों? हम मानते हैं:

1. हम क्वार्ट्ज से 12 मेगाहर्ट्ज लेते हैं और विभाजन गुणांक को 8 से लेते हैं - हमें 1500 KHz की आवृत्ति मिलती है;
2. हम CTC मोड लेते हैं (संयोग होने पर रीसेट करें) और 150 के साथ मेल खाने के लिए रुकावट सेट करें - हमें 10 KHz की बाधा प्रतिक्रिया आवृत्ति मिलती है;
3. इस बहुत ही रुकावट पर चर में वृद्धि (प्रत्येक 0.1 मिलीसेकंड की वृद्धि हुई है);
4. यदि यह एक अहस्ताक्षरित 32-बिट मान है, तो यह लगभग बाद में बह जाएगा
   
   
   • 429496729.6 मिलीसेकंड;
   • 42949.7 सेकंड;
   • 7158.3 मिनट;
   • 119.3 घंटे;
   • 4.97 दिन।

दूसरे शब्दों में, इस तरह का एक समाधान मेरे लिए एक टाइमर बनाता है जिसकी सटीकता 0.1 मिलीसेकंड है (लगभग) 5 दिनों के लिए (यह सच है, हालांकि, वास्तविक क्वार्ट्ज में एक त्रुटि है - उस पर और बाद में)। और अगर आप टाइमर 0 के मूल्य का भी विश्लेषण करते हैं - तो यह हर 2/3 माइक्रोसेकंड में बढ़ा हुआ है - आप 0.67 माइक्रोसेकंड की सटीकता के साथ एक काउंटर प्राप्त कर सकते हैं।

बहुत हो? मेरे लिए - आँखों के लिए। मेरी परियोजनाओं में 0.1 मिलीसेकंड काउंटर का उपयोग करना:

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

और यह सब शांति से एक ATmega16 कंट्रोलर में इंटरमेडल है! और यह असेंबलर नहीं है, लेकिन क्रॉस-प्लेटफ़ॉर्म सी! और कोई बाहरी वास्तविक समय काउंटर नहीं!

बुरा नहीं है, है ना?

AVR के लिए सेटअप

AVR में यह सब कैसे करें?

सबसे पहले, हम एक बाहरी चर शुरू करते हैं, जिसे मैं "DeciMilliSecond" कहता हूं:

//  main.h typedef unsigned long dword; //  32-  extern volatile dword dmsec; // 0.1msec //  main.c volatile dword dmsec;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि @ नो-स्मोकिंग सही ढंग से बताया गया है, इस चर को अस्थिर होना चाहिए ताकि इसका संकलक अनुकूलन का प्रयास न करे।

मैं फंक्शन में इस वेरिएबल का इनिशियलाइज़ेशन करता हूँ:

 dmsec = 0;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अगला, मैंने टाइमर 0 के ऑपरेशन मोड को सेट किया:

 // .  0 – 0.1msec Timer0_Mode (TIMER_Mode_CTC | TIMER0_Clk_8); Timer0_Cntr (149); Timer_Int (Timer0_Cmp);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उसी समय, कुछ MCU_init.h में मुझे वह सब कुछ घोषित करना चाहिए जो आवश्यक है:

 //  mcu_init.h #include <mega16.h> // . TIMSK #define Timer0_Cmp (1 << 1) //   0 // . TCCRn #define WGM1 (1 << 3) #define CS1 (1 << 1) // .     0 #define TIMER0_Clk_8 CS1 //  8 // .    #define TIMER_Mode_CTC WGM1 // CTC (  ) // .   #define Timer_Int(Mode) TIMSK = (Mode) #define Timer0_Mode(Mode) TCCR0 = (Mode) #define Timer0_Cntr(Cntr) OCR0 = (Cntr)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ठीक है, तब, जब संभव हो, मैं हस्तक्षेप करने की अनुमति देता हूं:

 #asm ("SEI")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह रुकावट का वर्णन करने के लिए बनी हुई है। यह पिछले सभी की तुलना में सरल है:

 #include <mega16.h> interrupt [TIM0_COMP] Timer0_Compare (void) { ++dmsec; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सब कुछ, टाइमर का वर्णन, कॉन्फ़िगर और चल रहा है!

PIC के लिए सेटअप

यहाँ सम्मानित PIC प्रशंसकों ने मुझे क्या सुझाव दिया है:



चोटियों पर, यह टिमर 2 मॉड्यूल का उपयोग करके आसानी से दोहराया जाता है। यह संयोग से एक समान रुकावट कार्य है।



PR2 = 75 - वह मान जिस पर टाइमर शून्य पर रीसेट हो जाएगा और एक अवरोध उत्पन्न करेगा

T2CON.T2CKPS = 2 - प्रीस्कूलर 1:16

T2CON.T2OUTPS = 0 - पोस्ट-स्केलर के बिना

T2CON.TMR2ON = पर - टाइमर चालू है



IPR1.TMR2IP = 1 - उच्च प्राथमिकता बाधा

PIR1.TMR2IF = बंद - बाधा ध्वज को साफ़ करें

PIE1.TMR2IE = पर - TMR2 और PR2 के संयोग से अवरोध को सक्षम करें

INTCON.GIE = ​​ऑन - इंटरप्ट हैंडलिंग को सक्षम करें



जैसा कि आप देख सकते हैं, यहां प्रीस्कूलर 2 गुना अधिक है, क्योंकि PR2 2 गुना कम है।

ये सेटिंग्स 48 मेगाहर्ट्ज की एक सिस्टम आवृत्ति पर 10 kHz की आवृत्ति के साथ रुकावट उत्पन्न करेंगी (फॉक्स / 4 टाइमर पर जाता है) - यूएसबी फुल स्पीड के लिए मानक आवृत्ति।

के उपयोग

इस टाइमर के क्लाइंट के लिए कोड क्रॉस-प्लेटफॉर्म है (AVR में टाइमर 0 के मूल्य तक पहुंचने के अलावा)।

यहाँ USB साझाकरण कोड का एक टुकड़ा है:

 #include "main.h" //   dmsec, next_USB_timeout #include "FT245R.h" //      USB #include "..\Protocol.h" //     -  // ** // **    USB // ** void AnalyzeUSB (void) { #define RECEIVE_BYTE(B) while (!FT245R_IsToRead)\ { if (dmsec > end_analyze) return; }\ B = FT245_ReadByte (); #define RECEIVE_WORD(W) //   2  #define RECEIVE_DWORD(W) //   4  dword end_analyze, d; NewAnalyze: if (!FT245R_IsToRead) //  ? return; end_analyze = dmsec + max_USB_timeout; // timeout    next_USB_timeout = dmsec + MaxSilence_PC_DEV; // timeout    RECEIVE_BYTE (b) //   switch (b) { case SetFullState: RECEIVE_DWORD (d); //   is_initialized = 1; //  ChangeIndicator (); break; } // switch (pack) goto NewAnalyze; #undef RECEIVE_BYTE //  #define #undef RECEIVE_WORD #undef RECEIVE_DWORD }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मैक्रो फ़ंक्शन RECEIVE_BYTE, RECEIVE_WORD, RECEIVE_DWORD किसी दिए गए एक्सचेंज चरण के लिए टाइमआउट को ध्यान में रखते हुए पढ़ी गई प्रक्रियाओं को लागू करता है। नतीजतन, अगर कुछ दूसरी तरफ लटका हुआ है, तो माइक्रोकंट्रोलर हाइबरनेशन में नहीं जाएगा। कृपया ध्यान दें - वॉचडॉग की आवश्यकता नहीं थी! और चर / निरंतर max_USB_timeout के लिए सभी धन्यवाद, जो 0.1 मिलीसेकेंड की सटीकता के साथ टाइमआउट सेट करता है।

इसी तरह, अगले next_USB_timeout के "हवा पर चुप्पी" का विश्लेषण लागू किया गया है। यह माइक्रोकंट्रोलर 1) को यह पता लगाने की अनुमति देता है कि कंप्यूटर कहीं गायब हो गया है, 2) किसी तरह इसे संकेत करने के लिए (मेरे मामले में, "त्रुटि" एलईडी लाइट्स)। निरंतर / चर MaxSilence_PC_DEV आपको व्यापक श्रेणी में "मौन" की अवधारणा को भिन्न करने की अनुमति देता है - एक मिलीसेकंड के एक अंश से कई दिनों तक।

इसी तरह, अन्य सभी क्षणों का एहसास होता है।

यदि आपको माइक्रोसेकंड काउंटर का उपयोग करने की आवश्यकता है, तो एक तुलना फ़ंक्शन दिखाई देता है:

 #define GetUSec(A,B) { #asm ("CLI"); A = dmsec; B = TCNT0; #asm ("SEI"); } // ** // **         2/3usec // ** dword Difference (dword prev_dmsec, byte prev_usec) { dword cur_dmsec; byte cur_usec; dword dif; // .    GetUSec (cur_dmsec, cur_usec); //   dif = cur_dmsec - prev_dmsec; dif <<= 8; if (cur_usec < prev_usec) dif += 255 + (dword) cur_usec - prev_usec; else dif += cur_usec - prev_usec; return dif; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फ़ंक्शन को समय के पिछले क्षण में पारित किया जाता है - dmsec और टाइमर का पिछला मान 0।

सबसे पहले, गेटस्क मैक्रो के साथ, हम इंटरप्ट को रोकते हैं ताकि नकल के समय dmsec और काउंटर मान दूषित न हों। और वर्तमान समय की प्रतिलिपि बनाएँ।

अगला, हम समय के अंतर को ध्यान में रखते हुए 2/3 माइक्रोसेकंड प्रारूप में प्रस्तुत करते हैं।

खैर, हम इस बार लौटते हैं।

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

परिणाम

यह टाइमर मेरे लिए एक अत्यंत सुविधाजनक समाधान निकला। मुझे लगता है कि वह काम आएगा। और मैंने इसे अपनी निम्नलिखित परियोजनाओं में लागू किया:

• बाड़ लगाने की स्थितियों पर स्विच करें । यह केंद्र और ATmega64 के रूप में दो सहायक (दाएं और बाएं पक्ष) के रूप में तीन नियंत्रकों के साथ एक हेमट्टी आधा मीटर बोर्ड है। तीन नियंत्रकों और उनके घटकों के बीच कोई गैल्वेनिक कनेक्शन नहीं है - आयनस्टोर्स पर आधारित बिजली की आपूर्ति, ऑप्टोकॉपर्स के माध्यम से संचार। केंद्रीय नियंत्रक एक आयनिस्टर के समूहों को चार्ज करता है और इस समय अन्य आयनिस्टर के दोनों किनारों को खिलाता है। यहां हमें रिश्ते को कम से कम करने के लिए इस सब के लिए एक मल्टी-स्टेज स्विचिंग एल्गोरिदम बनाना पड़ा। विशेष रूप से, हम 8 रिले के समन्वित कार्य के बारे में बात कर रहे हैं - यहां टाइमर 3.3ms (गारंटी रिले प्रतिक्रिया समय) के लिए काम करते हैं। खैर, वास्तव में, दोनों पक्ष 10 रिले को नियंत्रित करते हैं और यहां तक ​​कि सैकड़ों मल्टीप्लेक्सर्स के साथ भी। यह सभी खेत स्पष्ट रूप से परिभाषित समय विशेषताओं (1 एमएस की सटीकता के साथ, 6 सेकंड की अधिकतम अवधि) के साथ संचालित होते हैं। खैर, और, अंत में, USB, UART के लिए केनल टाइमआउट।
• गहराई सेंसर यहां मैं एक और समस्या (प्रोजेक्ट में काम) हल करता हूं। दो कंडक्टर (मल्टी-मीटर) हैं जो स्थिति को "1 सेमी से ऊपर" और "1 सेमी से नीचे शिफ्ट करें" को निर्दिष्ट करते हैं। एक दिशा निर्दिष्ट करने के कई तरीके हैं। किसी भी मामले में, ये आवेगों के कुछ निश्चित संयोजन हैं। इस टाइमर के साथ, मैं उछाल, एक स्थिर नाड़ी की अवधि निर्धारित करता हूं। कंप्यूटर से, अधिकतम स्वीकार्य उछाल समय निर्धारित है (10 माइक्रोसेकंड यहां पर्याप्त हैं), एंटी-बाउंस प्रतीक्षा, न्यूनतम / अधिकतम पल्स अवधि। खैर, डिबगिंग मोड है - सेंसर एक तार्किक विश्लेषक बन जाता है। यह आपको लाइन को डीबग करने और गुणांक को समायोजित करने की अनुमति देता है। खैर, फिर से, टाइमआउट, एल.ई.डी.
• एनालॉग सिग्नल का सेंसर । ट्राइट 8-चैनल एडीसी। यहां मैं आवश्यक ठहराव को बनाए रखने के लिए एक टाइमर का उपयोग करता हूं।

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



युपीडी

क्वार्ट्ज गुंजयमान यंत्र की स्थिरता के बारे में कुछ शब्द

जैसा कि nerudo ने मुझे टिप्पणियों में बिल्कुल ठीक किया है, इसे 2/3 माइक्रोसेकंड के वेतन वृद्धि में लगभग 5 दिन माना जा सकता है, लेकिन इन गणनाओं में त्रुटि शून्य नहीं है ...

मेरे द्वारा उपयोग किए जाने वाले 12 MHz HC49 / S क्वार्ट्ज को ही लें। KSS निर्माता ने सटीकता -15 का दावा किया ... + -50 x 1e-6 एक ही पीपीएम है । अगर मैं गलत नहीं हूं, तो इसका मतलब है कि 1 सेकंड में 15 माइक्रोसेकंड की एक त्रुटि आएगी। तो, 4.97 दिनों में हमें 268 मिलीसेकंड की त्रुटि मिलती है। यदि हम एक क्वार्ट्ज अचानक लेते हैं - कहते हैं, 1 पीपीएम के साथ, तो हमें एक ही समय में 18 मिलीसेकंड मिलते हैं।

एक फव्वारा नहीं - एक तरफ। दूसरी ओर - हम एक उच्च अंत क्रोनोमीटर नहीं बनाते हैं! कम से कम मैं अपने आप को इस तरह के काम के लिए तैयार नहीं करता। इस तथ्य को ध्यान में रखा जाना चाहिए।

हमें इस समस्या का भी सामना करना पड़ा - दो स्थानिक उपकरणों के बीच 45 मिनट में 1 मिलीसेकंड की सटीकता कैसे प्राप्त करें। लेकिन इस दूसरी बार के बारे में।