गैर ईई, सॉफ्टवेयर एपीआई संदर्भों में "कम-पास फिल्टर"

Question

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

अब, सॉफ्टवेयर एपीआई और प्रलेखन के माध्यम से पढ़ते समय, मैं देखता हूं कि लोग समय क्षेत्र में सेंसर डेटा के लिए एलपीएफ लागू कर रहे हैं। मुझे पता है कि आप अंतर समीकरणों के उपयोग के माध्यम से ऐसा करते हैं (जैसे y [i] = y [i-1] + 2 * x [i]), लेकिन मैंने अपने ईई वर्ग में सीखा कि एलपीएफ आम तौर पर कनवल्शन ऑपरेशन के माध्यम से लागू होते हैं जहाँ आप एक साइन लहर (उदाहरण के लिए) के गुणांक के साथ और एक विशिष्ट कट-ऑफ आवृत्ति के साथ समय संकेत का विश्वास करते हैं। तो "लो-पास फ़िल्टर" का बोलचाल का उपयोग मेरे लिए पर्याप्त सटीक नहीं है।

उदाहरण के लिए, Google Android API के पास यह दस्तावेज़ है: http://developer.android.com/reference/android/hardware/SensorEvent.html#values

 public void onSensorChanged(SensorEvent event)
 {
      // alpha is calculated as t / (t + dT)
      // with t, the low-pass filter's time-constant
      // and dT, the event delivery rate

      final float alpha = 0.8;

      gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
      gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
      gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];

      linear_acceleration[0] = event.values[0] - gravity[0];
      linear_acceleration[1] = event.values[1] - gravity[1];
      linear_acceleration[2] = event.values[2] - gravity[2];
 }

मैं उस कम-पास फिल्टर की व्याख्या कैसे करूं? कट-ऑफ फ्रीक्वेंसी क्या है? संक्रमण बैंडविड्थ क्या है? क्या वे इस एलपीएफ का उपयोग केवल औसत करने के लिए कर रहे हैं?

Comments

अच्छा यह मुझे परेशान करता है

— Sibbs जुआ

Answer 1

आपके उदाहरण में फ़िल्टर एक प्रथम-क्रम अनंत आवेग प्रतिक्रिया (IIR) फ़िल्टर है। इसका स्थानांतरण कार्य है:

$$H(z) = \frac{1 - \alpha}{1 - \alpha z^{-1}}$$

जो एक अलग समीकरण से मेल खाता है:

$$y[n] = \alpha y[n-1] + (1-\alpha) x[n]$$

जहाँ फ़िल्टर इनपुट है और y [ n ] फ़िल्टर आउटपुट है।$x[n]$$y[n]$

$\alpha$$\alpha$$[0,1)$$\alpha = 0$$\alpha$$\alpha = 1$

$\alpha$$1-\alpha$

$\alpha = 0.8$

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

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

Comments

धन्यवाद! कुछ अनुवर्ती प्रश्न: (1) आपने कहा कि आपका समीकरण H (z) = ... एक अंतर समीकरण है; यह वास्तव में एक हस्तांतरण समारोह है, है ना? मुझे लगा कि टाइम डोमेन के लिए एक अंतर समीकरण सख्ती से है। (२) आपके टपकाने वाले इंटीग्रेटर में, १ नमूना के अनुरूप है १_ नमूनाकरण / २ (मैटलैब की तरह)? (3) एफआईआर बनाम आईआईआर के बारे में, क्या मेरी समझ सही है कि आईआईआर अंतर समीकरण को ओ (एन) में लागू किया जा सकता है, लेकिन एफएफटी-आधारित कनवल्शन के साथ ओ (एन ^ 2) या ओ (एन एलजीएन) है? (४) क्या आप सॉफ्टवेयर प्रोग्रामर्स के लिए इन डीएसपी विचारों को लागू करने के लिए एक पुस्तक की सिफारिश कर सकते हैं? जैसे कि एंड्रॉइड कोड उदाहरण क्या कर रहा है।

— stackoverflowuser2010

$\pi$$+\pi$$O(N)$$N$$N$

मुझे पता है कि (i) अंतर समीकरण को लागू करने वाला O (N) है। लेकिन मैंने सोचा था कि (ii) गुणा-और-जोड़ (songho.ca/dsp/convolution/convolution.html) पर सम्मिश्रण ऑपरेशन का उपयोग एफएफटी-आधारित कार्यान्वयन के साथ O (N ^ 2) या O (N lgN) है । सभी मामलों में, N फ़िल्टर क्रम है - जहाँ मैं फ़िल्टर क्रम मान रहा हूँ और समय संकेत लंबाई परिमाण का समान क्रम है (उदाहरण दोनों 256)। तो (i) और (ii) अलग नहीं हैं? इसके अलावा, मैंने अमेज़ॅन डॉट कॉम पर लियोन की किताब देखी, लेकिन मैं सी / जावा सॉफ्टवेयर प्रोग्रामर्स के लिए कुछ और लिखने की उम्मीद कर रहा था।

— stackoverflowuser2010

$O(N)$$~N$$O(N^2)$$M$$N$$O(MN)$$M$$N$

— जेसन आर

$O(M \times (N+M))$$i \in N$$O(N^2)$$O(NM)$

— stackoverflowuser2010

Answer 2

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

जैसा कि एक IIR एक अनंत लंबाई आवेग प्रतिक्रिया का अर्थ है, दृढ़ संकल्प या तो गणना करने के लिए या एक सन्निकटन के उपयोग के लिए हमेशा की आवश्यकता होगी।

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

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

Answer 3

मैं अपने आप को इस पोस्ट समय और समय पर फिर से आ रहा हूँ। सवाल पूछने के लिए धन्यवाद। सी में टपकने वाले इंटीग्रेटर (एक माइक्रोकंट्रोलर के लिए इरादा) का एक शानदार, कम्प्यूटेशनल-अनुकूल कार्यान्वयन है।

सबसे पहले, कुछ पुनर्व्यवस्था: y = α * x + (1 - α) * y_last = α * (x - y_last) + y_last

यदि हम α को लगभग 12%, 25%, 50%, (1/8, 1/4, 1/2, ...) तक सीमित रखते हैं। हम कुछ कुशल बिट-शिफ्टिंग का लाभ उठा सकते हैं। 1/8, 8 => 2 ^ 3 => का मामला उठाते हुए (3 बार घटा)

= (x - y_last) / 8 + y_last

#define SMOOTHING_FACTOR       (3)

int16_t FilterSample(int16_t new_sample)
{
  static int16_t last_result = 0;

  // Each bit shift down is equivalent to dividing-by-two
  last_result = (new_sample - last_result) >> SMOOTHING_FACTOR) + last_result;

  return last_result;
}

आशा करता हूँ की ये काम करेगा।