Lågpassfilter: allt du behöver veta om denna krets

Spolar och op-förstärkare låter dig skapa mycket intressanta kretsar, som de berömda frekvensfilter. Dessa filter har en mängd applikationer inom elektronikindustrin. Som fallet är med lågpassfilter, högpassfilter etc. De är särskilt intressanta för vissa ljudapplikationer, att kunna filtrera ljud eller mer eller mindre allvarliga ljud beroende på deras frekvens. Därför är de mycket användbara.

Om du vill veta mer om lågpassfilter, och andra filter, och hur de kan hjälpa dig i dina projekt med Arduino eller DIY, jag uppmuntrar dig att fortsätta läsa ...

Elektriska filter

Som namnet antyder är ett filter en krets som består av en serie spolar och kondensatorer, och till och med några driftsförstärkare, i syfte att bara låta vissa delar av en frekvens passera. Det vill säga, av hela spektrumet av tillgängliga frekvenser, kommer de att filtrera en eller flera delar för att förhindra att de passerar igenom.

Om för ejemplo Vi pratar om det spektrum som hörs av människan, som går från 20 Hz till 20 Khz, med filter som du kan eliminera det lägsta eller det högsta för att bara låta de mer eller mindre diskanten / basljuden passera. Det är något som många ljudinspelnings- eller reproduktionssystem använder, till exempel mikrofoner, högtalare etc.

Typ

Enligt filtertyp, eller snarare, beroende på frekvensen de blockerar eller den de släpper igenom, finns det olika typer av kretsar som är:

• Lågpassfilter: de kallas så för att de är de filter som låter de lägsta frekvenserna passera och undertrycka eller minska passet för de högre frekvenserna. De består av en eller flera spolar (i serie med strömförsörjning och belastning) och en eller två shuntkondensatorer med strömförsörjning och belastning. Kom ihåg att lasten förstås vara den enhet som är ansluten till filtret och som samlar upp filterets utgång ... Inom dessa filter finns det också varianter, som L, T och π.
• Högpassfilter: högpassfiltret är motsatsen till lågpasset, i detta fall är det som filtrerar eller begränsar lågfrekvenspasset, vilket låter de högre frekvenserna passera. I detta investeras de elektroniska elementen som komponerar den. Det vill säga här kommer kondensatorerna att vara de i serie med strömförsörjningen och belastningen, medan spolarna kommer att shuntas. Det finns också samma undertyper som i fallet med lågpassfilter.
• Bandpassfilter: Denna typ av filter utövar två frekvensbandspassfrekvensblock. Det vill säga de fungerar både som ett lågpassfilter och som ett högpassfilter, som motsätter sig passagen av de lägsta frekvenserna och också den högsta samtidigt. Med andra ord tillåter det bara att mittfrekvenserna passerar.
• Bandfilter: det är exakt motsatsen till det föregående, vad det gör är att det filtrerar passeringen av mittfrekvenserna och bara släpper igenom de lägsta och högsta frekvenserna.

Kom ihåg det induktanser de släpper igenom låga frekvenser och motsätter sig passering av höga frekvenser. Istället, kondensatorer de släpper igenom höga frekvenser och motsätter sig passage av låga frekvenser.

Jag vill lägga till filtren på en praktisk nivå de är inte perfekta, och de kan alltid passera några låga eller höga frekvenser som du bör blockera. Men de gör sitt jobb ganska bra för de flesta applikationer.

Och slutligen vill jag också klargöra en annan sak, och det är att du säkert har hört talas om EMA- och DEMA-filter. Med EMA-filter (Exponential Moving Average) kan denna typ av filter implementeras på ett enkelt sätt i inbäddade enheter. När det gäller DEMA (Double Exponential Moving Average) har de ett snabbare svar än EMA, vilket bibehåller ett bra undertryck av det ljud som du vill undvika.

Alfafaktor

El alfafaktor, som du kommer att se som visas i Arduino IDE-koder i nästa avsnitt, är parametern som villkorar det exponentiella filterets beteende. Det är relaterat till gränsfrekvensen:

• Alpha = 1: som ger en signal till den ofiltrerade utgången.
• Alpha = 0: filtervärdet kommer alltid att vara 0.
• Alpha = x: andra värden kan få andra ändringar i EMA-filtret. Om du sänker Alpha-faktorn, kommer du att mjuka upp frekvenssignalen mer, och systemets svarstid ökas också (det tar längre tid att stabilisera sig).

Filter och Arduino

Du bör veta att det inte är nödvändigt att skapa kretsen högpassfilter eller lågpassfilter för att ansluta den till ditt Arduino-kort och arbeta med det. Även om du kan experimentera och skapa sådana typer av enkla filter, kan du också testa hur en EMA skulle fungera med bara Arduino-kortet och en enkel kod för Arduino IDE. Det är det enda du behöver för att se hur det ansvarar för att filtrera vissa frekvenser (i det här fallet simuleras åtgärden och vissa heltal / flottörer filtreras helt enkelt simulera vad jag skulle göra filter faktiskt).

Här är några kodprover som du kan använda för att träna.

Exempel på enkelt digitalt filter i Arduino av typen lågpass:

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

Kodexempel för Arduino-typ Hög passage:

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
}

Exempel på Arduino-kod bandpass:

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

Exempel på Arduino-kod för 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);                                
}

Jag råder dig att ändra och experimentera med dessa koder. Resultatet du kan se mycket grafiskt tack till Arduino IDEs seriella plotter ... Kom ihåg att om du har frågor om Arduino-programmering eller hur du använder IDE kan du ladda ner gratis HwLibre-kurs i PDF.