Filtru trece jos: tot ce trebuie să știți despre acest circuit

Bobinele și amplificatoarele de operare vă permit să creați circuite foarte interesante, precum celebrul filtre de frecvență. Aceste filtre au o multitudine de aplicații în industria electronică. La fel ca în cazul filtrului trece jos, al filtrului trece înalt etc. Sunt deosebit de interesante pentru anumite aplicații de sunet, putând filtra zgomotele sau sunete mai mult sau mai puțin grave în funcție de frecvența lor. Prin urmare, sunt foarte utile.

Dacă doriți să aflați mai multe despre filtru trece jos, și alte filtre și cum vă pot ajuta în proiectele dvs. cu Arduino sau DIY, vă încurajez să continuați să citiți ...

Filtre electrice

După cum sugerează și numele său, un filtru este un circuit care este alcătuit dintr-o serie de bobine și condensatori, și chiar din unele amplificatoare operaționale, în scopul lăsând să treacă doar anumite părți ale unei frecvențe. Adică, din întregul spectru de frecvențe disponibile, acestea vor filtra una sau mai multe părți pentru a le împiedica să treacă.

Dacă pentru exemplu Vorbim despre spectrul audibil de către ființa umană, care merge de la 20 Hz la 20 Khz, cu filtre pe care le puteți elimina pe cel mai mic sau cel mai înalt, pentru a permite doar trecerea sunetelor mai mult sau mai puțin înalte / bas. Este ceva pe care îl folosesc multe sisteme de înregistrare sau reproducere audio, cum ar fi microfoane, difuzoare etc.

Tipuri

Conform tip filtru, sau mai bine zis, în funcție de frecvența pe care o blochează sau de cea pe care o lasă să treacă, există diferite tipuri de circuite care sunt:

• Filtru trece jos: se numesc așa deoarece sunt acele filtre care lasă să treacă cele mai mici frecvențe și să suprime sau să reducă trecerea frecvențelor superioare. Acestea constau din una sau mai multe bobine (în serie cu sursa de alimentare și sarcină) și unul sau două condensatori de șunt cu sursa de alimentare și sarcină. Amintiți-vă că încărcătura este înțeleasă a fi dispozitivul conectat la filtru și care colectează ieșirea filtrului ... În cadrul acestor filtre există și variante, cum ar fi L, T și π.
• Filtru trece sus: filtrul de trecere înaltă este opusul trecerii joase, în acest caz, ceea ce va filtra sau limita este trecerea de frecvență joasă, lăsând să treacă frecvențele superioare. În aceasta sunt investite elementele electronice care îl compun. Adică aici condensatoarele vor fi cele în serie cu sursa de alimentare și sarcina, în timp ce bobinele vor fi manevrate. Există, de asemenea, aceleași subtipuri ca și în cazul filtrelor de trecere joasă.
• Filtru de trecere a benzii: Acest tip de filtru exercită două blocări ale ratei de trecere a benzii de frecvență. Adică, ele acționează atât ca un filtru trece jos, cât și ca un filtru trece înalt, opunându-se trecerii frecvențelor cele mai mici și, de asemenea, cele mai înalte în același timp. Cu alte cuvinte, permite doar trecerea frecvențelor medii.
• Filtru de bandă: este exact opusul celei anterioare, ceea ce face este că filtrează trecerea frecvențelor medii și permite doar trecerea celor mai joase și mai mari frecvențe.

Amintiți-vă că inductanțe lasă să treacă frecvențe joase și se opun trecerii frecvențelor înalte. In schimb, condensatoare lasă să treacă frecvențe înalte și se opun trecerii frecvențelor joase.

Aș dori să adaug filtrele respective la nivel practic nu sunt perfecteși pot trece întotdeauna unele frecvențe joase sau înalte pe care ar trebui să le blocați. Cu toate acestea, își fac treaba destul de bine pentru majoritatea aplicațiilor.

Și, în sfârșit, aș dori să clarific un alt lucru, și anume că ați auzit cu siguranță despre Filtre EMA și DEMA. Filtrele EMA (Exponential Moving Average) vă permit să implementați acest tip de filtru într-un mod simplu în dispozitivele încorporate. În ceea ce privește DEMA (Double Exponential Moving Average), acestea au un răspuns mai rapid decât EMA, menținând o bună suprimare a zgomotului pe care doriți să îl evitați.

Factorul alfa

El factor alfa, pe care îl veți vedea care apare în codurile IDE Arduino din secțiunea următoare, este parametrul care condiționează comportamentul filtrului exponențial. Este legat de frecvența de tăiere:

• Alfa = 1: care oferă un semnal la ieșirea nefiltrată.
• Alfa = 0: valoarea filtrului va fi întotdeauna 0.
• Alfa = x: alte valori pot obține alte modificări în filtrul EMA. Dacă micșorați factorul Alpha, veți înmuia mai mult semnalul de frecvență obținut, iar timpul de răspuns al sistemului este, de asemenea, crescut (este nevoie de mai mult timp pentru a se stabiliza).

Filtre și Arduino

Trebuie să știți că nu este necesar să creați circuitul filtru trece sus sau filtru trece jos pentru a o conecta la placa Arduino și a lucra cu ea. Deși puteți experimenta și crea aceste tipuri de filtre simple, puteți testa, de asemenea, modul în care un EMA ar funcționa doar cu placa Arduino și un cod simplu pentru Arduino IDE. Este singurul lucru de care ai nevoie pentru a vedea cum se ocupă filtrarea unor frecvențe (în acest caz acțiunea este simulată și unele numere întregi / plutitoare sunt pur și simplu filtrate simulând ce aș face filtru de fapt).

Iată câteva exemple de cod pe care le puteți folosi pentru a practica.

Exemplu de filtru digital simplu în tipul Arduino pasaj mic:

float   lowpass_prev_out[LOWPASS_ANALOG_PIN_AMT], 
         lowpass_cur_out[LOWPASS_ANALOG_PIN_AMT];
int        lowpass_input[LOWPASS_ANALOG_PIN_AMT];
 
 
int adcsample_and_lowpass(int pin, int sample_rate, int samples, float alpha, char use_previous) {
  // pin:            Pin analógico de Arduino usado
  // sample_rate:    El ratio adecuado
  // samples:        Samples
  // alpha:          El factor Alpha para el filtro paso bajo
  // use_previous:   Si es true se sigue ajustando hasta el valor más reciente. 
 
  float one_minus_alpha = 1.0-alpha;
  int micro_delay=max(100, (1000000/sample_rate) - 160);  
  if (!use_previous) { 
    lowpass_input[pin] = analogRead(pin);
    lowpass_prev_out[pin]=lowpass_input[pin]; 
  }
  int i;
  for (i=samples;i>0;i--) {
    delayMicroseconds(micro_delay);
    lowpass_input[pin] = analogRead(pin);
    lowpass_cur_out[pin] = alpha*lowpass_input[pin] + one_minus_alpha*lowpass_prev_out[pin];
    lowpass_prev_out[pin]=lowpass_cur_out[pin];
  }
  return lowpass_cur_out[pin];
}
 
int resulting_value;
 
void setup() {
   Serial.begin(9600);
   resulting_value = adcsample_and_lowpass(0, 1000, 300, 0.015, false); 
}
 
void loop() {
   resulting_value = adcsample_and_lowpass(0, 1000, 150, 0.015, true);  
   Serial.println(resulting_value);

Exemplu de cod pentru tipul Arduino Trecere inalta:

int sensorPin = 0;    //pin usado para el ADC
int sensorValue = 0;  //Inicia sensor variable equivalente a EMA Y
float EMA_a = 0.3;    //Inicialización del EMA Alpha
int EMA_S = 0;        //Iniciación del EMA s
int highpass = 0;
 
void setup(){
  Serial.begin(115200);              
  EMA_S = analogRead(sensorPin);     
}
 
void loop(){
  sensorValue = analogRead(sensorPin);              //Lee el valor del sensor ADC
  EMA_S = (EMA_a*sensorValue) + ((1-EMA_a)*EMA_S);  //Ejecuta el filtro EMA
  highpass = sensorValue - EMA_S;                   //Calcula la seña alta
 
  Serial.println(highpass);
   
  delay(20);                                //Espera 20ms
}

Exemplu de cod Arduino trece bandă:

int sensorPin = 0;        //Pin para el ADC
int sensorValue = 0;      //Inicia la variable del sensor, equivale a EMA Y
 
float EMA_a_low = 0.3;    //Inicia EMA Alpha
float EMA_a_high = 0.5;
 
int EMA_S_low = 0;        //Inicia EMA S
int EMA_S_high = 0;
 
int highpass = 0;
int bandpass = 0;
 
void setup(){
  Serial.begin(115200);                   
   
  EMA_S_low = analogRead(sensorPin);      
  EMA_S_high = analogRead(sensorPin);
}
 
void loop(){
  sensorValue = analogRead(sensorPin);    //Lee el valor del sensor ADC
   
  EMA_S_low = (EMA_a_low*sensorValue) + ((1-EMA_a_low)*EMA_S_low);  //Ejecuta EMA
  EMA_S_high = (EMA_a_high*sensorValue) + ((1-EMA_a_high)*EMA_S_high);
   
  highpass = sensorValue - EMA_S_low;     
  bandpass = EMA_S_high - EMA_S_low;     
 
  Serial.print(highpass);
  Serial.print(" ");
  Serial.println(bandpass);
   
  delay(20);                              
}

Exemplu de cod Arduino pentru trupă:

int sensorPin = 0;          //Pin usado para el ADC
int sensorValue = 0;        //Inicio para EMA Y
 
float EMA_a_low = 0.05;     //Inicio de EMA alpha 
float EMA_a_high = 0.4;
 
int EMA_S_low = 0;          //Inicia EMA S
int EMA_S_high = 0;
 
int highpass = 0;
int bandpass = 0;
int bandstop = 0;
 
void setup(){
  Serial.begin(115200);                     
   
  EMA_S_low = analogRead(sensorPin);        
  EMA_S_high = analogRead(sensorPin);
}
 
void loop(){
  sensorValue = analogRead(sensorPin);      //Lee el valor del sensor ADC
   
  EMA_S_low = (EMA_a_low*sensorValue) + ((1-EMA_a_low)*EMA_S_low);          //Ejecuta EMA
  EMA_S_high = (EMA_a_high*sensorValue) + ((1-EMA_a_high)*EMA_S_high);
   
  bandpass = EMA_S_high - EMA_S_low;       
 
  bandstop = sensorValue - bandpass;        
 
  Serial.print(sensorValue);
  Serial.print(" ");
  Serial.print(EMA_S_low);
  Serial.print(" ");
  Serial.println(bandstop);
   
  delay(20);                                
}

Vă sfătuiesc să modificați și să experimentați aceste coduri. Rezultatul pe care îl poți vezi foarte grafic mulțumită Serial Plotter al Arduino IDE ... Amintiți-vă că, dacă aveți întrebări despre programarea Arduino sau despre cum să utilizați IDE, puteți descărca curs gratuit HwLibre în PDF.