Laagdoorlaatfilter: alles wat u moet weten over dit circuit

Met spoelen en opamps kun je zeer interessante circuits maken, zoals de beroemde frequentie filters. Deze filters hebben een veelvoud aan toepassingen in de elektronica-industrie. Net als het laagdoorlaatfilter, het hoogdoorlaatfilter, enz. Ze zijn vooral interessant voor bepaalde geluidstoepassingen, omdat ze geluiden of meer of minder serieuze geluiden kunnen filteren op basis van hun frequentie. Daarom zijn ze erg handig.

Als je meer wilt weten over laagdoorlaatfilter, en andere filters, en hoe ze je kunnen helpen bij je projecten met Arduino of DIY, raad ik je aan om verder te lezen ...

Elektrische filters

Zoals de naam al doet vermoeden, is een filter een circuit dat bestaat uit een reeks spoelen en condensatoren, en zelfs enkele operationele versterkers, met als doel alleen bepaalde delen van een frequentie laten passeren. Dat wil zeggen, van het hele spectrum van beschikbare frequenties zullen ze een of meer delen filteren om te voorkomen dat ze erdoorheen gaan.

Ja voor voorbeeld bekijken We hebben het over het door de mens hoorbare spectrum, dat gaat van 20 Hz tot 20 Khz, met filters zou je de laagste of de hoogste kunnen elimineren om alleen de min of meer hoge / lage tonen door te laten. Het is iets dat veel audio-opname- of reproductiesystemen gebruiken, zoals microfoons, luidsprekers, enz.

Soorten

Volgens filtertype, of beter gezegd, afhankelijk van de frequentie die ze blokkeren of degene die ze doorlaten, zijn er verschillende soorten circuits die:

• Laagdoorlaatfilter: Ze worden zo genoemd omdat het die filters zijn die de lagere frequenties doorlaten en de doorlaat van de hogere frequenties onderdrukken of verminderen. Ze bestaan ​​uit een of meer spoelen (in serie met de voeding en belasting) en een of twee shuntcondensatoren met de voeding en belasting. Onthoud dat onder belasting wordt verstaan ​​het apparaat dat op het filter is aangesloten en dat de output van het filter opvangt ... Binnen deze filters zijn er ook varianten, zoals L, T en π.
• Hoogdoorlaatfilter: het hoogdoorlaatfilter is het tegenovergestelde van het laagdoorlaatfilter, wat het in dit geval filtert of beperkt, is de laagfrequente doorlaat, waardoor de hogere frequenties worden doorgelaten. Hierin worden de elektronische elementen waaruit het bestaat, geïnvesteerd. Dat wil zeggen, hier zullen de condensatoren in serie staan ​​met de voeding en de belasting, terwijl de spoelen worden overbrugd. Er zijn ook dezelfde subtypen als in het geval van laagdoorlaatfilters.
• Banddoorlaatfilter: Dit type filter oefent twee passagesnelheidsblokken van de frequentieband uit. Dat wil zeggen, ze werken zowel als een laagdoorlaatfilter als als een hoogdoorlaatfilter, en gaan tegelijkertijd de doorgang van de laagste frequenties tegen en ook de hoogste. Met andere woorden, het laat alleen de middelste frequenties door.
• Bandfilter: Het is precies het tegenovergestelde van de vorige, wat het doet is dat het de middenfrequentie filtert en alleen de laagste en hoogste frequenties doorlaat.

Vergeet niet dat de inductanties ze laten lage frequenties door en verzetten zich tegen de doorgang van hoge frequenties. In plaats daarvan, condensatoren ze laten hoge frequenties door en verzetten zich tegen de doorgang van lage frequenties.

Ik zou die filters op praktisch niveau willen toevoegen ze zijn niet perfect, en ze kunnen altijd lage of hoge frequenties doorlaten die je zou moeten blokkeren. Ze doen hun werk echter redelijk goed voor de meeste toepassingen.

En tot slot zou ik nog iets anders willen verduidelijken, en dat is dat je zeker gehoord hebt over de EMA- en DEMA-filters. Met EMA-filters (Exponential Moving Average) kan dit type filters op een eenvoudige manier in embedded apparaten worden geïmplementeerd. Wat betreft DEMA (Double Exponential Moving Average), ze reageren sneller dan EMA, waardoor de ruis die u wilt vermijden goed wordt onderdrukt.

Alfa-factor

El alfafactor, die u zult zien in de Arduino IDE-codes in de volgende sectie, is de parameter die het gedrag van het exponentiële filter bepaalt. Het is gerelateerd aan de afsnijfrequentie:

• Alpha = 1: dat geeft een signaal aan de ongefilterde output.
• Alpha = 0: de filterwaarde is altijd 0.
• Alpha = x: andere waarden kunnen andere wijzigingen in het EMA-filter krijgen. Als u de alfafactor verlaagt, verzacht u het verkregen frequentiesignaal meer en neemt de responstijd van het systeem ook toe (het duurt langer om te stabiliseren).

Filters en Arduino

U moet weten dat het niet nodig is om het circuit te maken hoogdoorlaatfilter of laagdoorlaatfilter om het op je Arduino-bord aan te sluiten en ermee te werken. Hoewel je kunt experimenteren en dit soort eenvoudige filters kunt maken, kun je ook testen hoe een EMA zou werken met alleen het Arduino-bord en een eenvoudige code voor de Arduino IDE. Het is het enige dat je nodig hebt om te zien hoe het verantwoordelijk is voor het filteren van sommige frequenties (in dit geval wordt de actie gesimuleerd en worden sommige gehele getallen / floats gewoon gefilterd simuleren wat ik zou doen filter eigenlijk).

Hier zijn enkele codevoorbeelden die u kunt gebruiken om te oefenen.

Voorbeeld van een eenvoudig digitaal filter in Arduino van het type lage pass:

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);

Codevoorbeeld voor Arduino-type Hoge pas:

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
}

Arduino-codevoorbeeld band pass:

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);                              
}

Arduino-codevoorbeeld voor band:

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);                                
}

Ik raad je aan om deze codes aan te passen en ermee te experimenteren. Het resultaat kunt u heel grafisch zien dankzij de seriële plotter van de Arduino IDE ... Onthoud dat als je vragen hebt over Arduino-programmering of het gebruik van de IDE, je de gratis HwLibre-cursus in PDF.