Laagdeurfilter: alles wat u oor hierdie stroombaan moet weet

Spoele en op versterkers stel u in staat om baie interessante stroombane te skep, soos die beroemde frekwensie filters. Hierdie filters het 'n verskeidenheid toepassings in die elektroniese industrie. Soos die geval is met die laagdeurlaatfilter, die hoogdeurlaatfilter, ens. Dit is veral interessant vir sekere klanktoepassings, om geluide te filter of meer of minder ernstige klanke volgens hul frekwensie. Daarom is dit baie nuttig.

As u meer wil weet oor laagdeurlaatfilter, en ander filters, en hoe dit u kan help in u projekte met Arduino of DIY, raai ek u aan om voort te gaan lees ...

Elektriese filters

Soos die naam aandui, is 'n filter 'n stroombaan wat bestaan ​​uit 'n reeks spoele en kondensators, en selfs enkele bedryfsversterkers, met die doel om slegs sekere dele van 'n frekwensie te laat slaag. Dit wil sê, van die hele spektrum beskikbare frekwensies, sal hulle een of meer dele filter om te verhoed dat dit deurgaan.

As vir ejemplo Ons praat oor die spektrum wat deur die mens hoorbaar is, wat van 20 Hz tot 20 Khz gaan, met filters wat u die laagste of die hoogste kan elimineer om die min of meer treble / basgeluide te laat slaag. Dit is iets wat baie klankopname- of reproduksiestelsels gebruik, soos mikrofone, luidsprekers, ens.

Tipes

Volgens filter tipeOf eerder, afhangende van die frekwensie wat hulle blokkeer of die deurlaat, is daar verskillende soorte stroombane:

• Laegdeurlaatfilter: dit word sogenaamd omdat dit die filters is wat die laagste frekwensies laat slaag en die deurgang van die hoër frekwensies onderdruk of verminder. Dit bestaan ​​uit een of meer spoele (in serie met die kragbron en las), en een of twee shunt-kondensators met die kragvoorsiening en las. Onthou dat die las verstaan ​​word as die toestel wat aan die filter gekoppel is en dat die filter se uitset versamel ... Binne hierdie filters is daar ook variante, soos L, T en π.
• Hoogdeurlaatfilter: die hoogdeurlaatfilter is die teenoorgestelde van die laagdeurlaat, in hierdie geval, wat dit sal filter of beperk, is die laefrekwensie deurgang, wat die hoër frekwensies laat slaag. Hierin word die elektroniese elemente wat dit saamstel belê. Dit wil sê, hier is die kondensators die in serie met die kragbron en die lading, terwyl die spoele geskud word. Daar is ook dieselfde subtipes as in die geval van lae deurlaatfilters.
• Band slaagfilter: Hierdie tipe filter oefen twee slaagsyfers van die frekwensieband deur. Dit wil sê, hulle tree beide op as 'n laagdeurlaatfilter en as 'n hoogdeurlaatfilter, wat teen die gang van die laagste frekwensies en terselfdertyd die hoogste is. Met ander woorde, dit laat net die middelfrekwensies toe om deur te gaan.
• Bandfilter: dit is presies die teenoorgestelde van die vorige, wat dit doen is dat dit die deurgang van die middelfrekwensies filtreer en slegs die laagste en hoogste frekwensies deurlaat.

Onthou dat die induktansies hulle laat lae frekwensies deur en weerstaan ​​die deurgang van hoë frekwensies. In plaas daarvan, kapasitors hulle laat hoë frekwensies deur en is teen die gang van lae frekwensies.

Ek wil die filters op 'n praktiese vlak byvoeg hulle is nie perfek nie, en hulle kan altyd lae of hoë frekwensies slaag wat u moet blokkeer. Hulle doen hul werk egter redelik goed vir die meeste aansoeke.

En ten slotte wil ek ook 'n ander saak opklaar, en dit is dat u sekerlik van die EMA- en DEMA-filters. Met EMA (Exponential Moving Average) filters kan hierdie tipe filters op 'n eenvoudige manier in ingebedde toestelle geïmplementeer word. Wat DEMA (Double Exponential Moving Average) betref, hulle reageer vinniger as EMA, en behou 'n goeie onderdrukking van die geraas wat u wil vermy.

Alfa faktor

El alfafaktor, wat u in die volgende afdeling in die Arduino IDE-kodes sal sien, is die parameter wat die gedrag van die eksponensiële filter bepaal. Dit hou verband met die afsnyfrekwensie:

• Alfa = 1: gee 'n sein aan die ongefilterde uitset.
• Alfa = 0: die filterwaarde sal altyd 0 wees.
• Alpha = x: ander waardes kan ander veranderings in die EMA-filter kry. As u die Alpha-faktor verlaag, versag u die frekwensie sein wat verkry word, en die reaksietyd van die stelsel word ook verhoog (dit neem langer om te stabiliseer).

Filters en Arduino

U moet weet dat dit nie nodig is om die stroombaan te skep nie hoogdeurlaatfilter of laagdeurlaatfilter om dit aan u Arduino-bord te koppel en daarmee te werk. Alhoewel u sulke eenvoudige filters kan eksperimenteer en maak, kan u ook toets hoe 'n EMA net met die Arduino-bord en 'n eenvoudige kode vir die Arduino IDE sal werk. Dit is die enigste ding wat u nodig het om te sien hoe dit verantwoordelik is vir die filter van sommige frekwensies (in hierdie geval word die aksie gesimuleer en sommige heelgetalle / vlotte word eenvoudig gefiltreer simuleer wat ek sou doen filter eintlik).

Hier is 'n paar voorbeelde van kode wat u kan gebruik om te oefen.

Voorbeeld van eenvoudige digitale filter in Arduino van die tipe laag slaag:

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

Kode voorbeeld vir Arduino tipe Hoë aangee:

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 kode voorbeeld bandpas:

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 kode voorbeeld vir 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);                                
}

Ek raai u aan om hierdie kodes aan te pas en te eksperimenteer. Die resultaat wat u kan sien baie grafies dankie aan die Serial Plotter van die Arduino IDE ... Onthou dat as u vrae het oor Arduino-programmering of hoe om die IDE te gebruik, u die gratis HwLibre-kursus in PDF.