एवीआर माइक्रो नियंत्रक

Question

के साथ एक रोटरी एन्कोडर का उपयोग करके मुझे एवीआर माइक्रो नियंत्रकों के साथ ठीक से काम करने के लिए रोटरी एन्कोडर प्राप्त करने में परेशानी हो रही है। एन्कोडर एक यांत्रिक ALPS encoder है, और मैं Atmega168 का उपयोग कर रहा हूं।

स्पष्टीकरण

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

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

मैंने एन्कोडर को स्कॉइंग करने का प्रयास किया है, और ऐसा लगता है कि दूसरे पिन परिवर्तनों तक पहले पिन परिवर्तनों से 2 और 4ms के बीच उपयोग करना प्रतीत होता है।

Answer 1

मेरे पास rotary encoders and how to use them का वेबपृष्ठ है, जो आपको उपयोगी लगेगा।

दुर्भाग्य से अधिक जानकारी के बिना मैं आपकी विशेष समस्या का निवारण नहीं कर सकता।

कौन सा माइक्रोकंट्रोलर पिन एन्कोडर से जुड़े हुए हैं, और आप वर्तमान में दालों को डीकोड करने के लिए किस कोड का उपयोग कर रहे हैं?

ठीक है, आप कुछ अलग-अलग मुद्दों से निपट रहे हैं, पहला मुद्दा यह है कि यह एक यांत्रिक एन्कोडर है, इसलिए आपको स्विच शोर (बाउंस, चाप) से निपटना होगा। data sheet इंगित करता है कि भागों को झुकाव रोकने और झूठी आउटपुट बनाने में 3 एमएस तक लग सकते हैं।

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

एटमेगा इतना तेज़ है कि आपको धीरे-धीरे इन चेकों के बारे में चिंता करने की ज़रूरत नहीं है, जब तक कि आप धीमी घड़ी की गति भी नहीं चला रहे हों।

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

Answer 2

आपको वास्तव में क्या समस्याएं हैं? मुझे लगता है कि आप अपने पीआईसी में एन्कोडर के पिन को आपके द्वारा दिए गए फार्नेल पेज से जुड़े तकनीकी विनिर्देशों के अनुसार हुक करने में सक्षम हैं, तो डेटा पढ़ने के साथ समस्या भी है? क्या आपको एन्कोडर से कोई डेटा नहीं मिलता है? क्या आप नहीं जानते कि आप जिस डेटा को वापस प्राप्त कर रहे हैं उसकी व्याख्या कैसे करें?

Answer 3

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

Answer 4

/* into 0 service rutine */ 
if(CHB) 
{ 
    if(flagB) 
    Count++; 
    FlagB=0; 
} 
else 
{ 
    if(FlagB) 
    count--: 
    FlagB=0: 
} 

/* into 1 service rutine */ 
FlagB=1; 

/* make this give to you a windows time of 1/4 of T of the encoder resolution 
    that is in angle term: 360/ (4*resolution) 
*/ 

Answer 5

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

 _________ 
     |   | 
     | Encoder | 
     |_________| 
      | | | 
      | | | 
    100n | O | 100n 
GND O-||-+ GND +-||-O GND 
      |  | 
      \ /
     3K3/ \ 3K3 
      \ /
      |  |  
VCC O-/\/-+  +-\/\-O VCC 
    15K |  | 15K 
      |  | 
      O  O 
      A  B 

आह, ASCII आर्ट के चमत्कार: p

यहाँ AVR पर कार्यक्रम है। AVR पर इनपुट PORTB के लिए ए और बी कनेक्ट करें:

#include <avr/io.h> 

#define PIN_A (PINB&1) 
#define PIN_B ((PINB>>1)&1) 

int main(void){ 
    uint8_t st0 = 0; 
    uint8_t st1 = 0; 
    uint8_t dir = 0; 
    uint8_t temp = 0; 
    uint8_t counter = 0; 
    DDRD = 0xFF; 
    DDRB = 0; 
    while(1){ 
    if(dir == 0){ 
     if(PIN_A & (!PIN_B)){ 
      dir = 2; 
     }else if(PIN_B & (!PIN_A)){ 
      dir = 4; 
     }else{ 
      dir = 0; 
     } 
    }else if(dir == 2){ 
     if(PIN_A & (!PIN_B)){ 
      dir = 2; 
     }else if((!PIN_A) & (!PIN_B)){ 
      counter--; 
      dir = 0; 
     }else{ 
      dir = 0; 
     } 
    }else if(dir == 4){ 
     if(PIN_B & (!PIN_A)){ 
      dir = 4; 
     }else if((!PIN_A) & (!PIN_B)){ 
      counter++; 
      dir = 0; 
     }else{ 
      dir = 0; 
     } 
    }else if(PIN_B & PIN_A){ 
     dir = 0; 
    } 
     PORTD = ~counter; 
    } 
    return 0; 
} 

इस कोड काम करता है जब तक आप वास्तव में तेजी से एनकोडर बारी बारी से। फिर यह एक या दो कदम याद कर सकता है, लेकिन यह महत्वपूर्ण नहीं है, क्योंकि एन्कोडर का उपयोग करने वाले व्यक्ति को यह नहीं पता होगा कि उन्होंने कितने कदम इसे बदल दिए हैं।