Filtro passa basso: tutto quello che c'è da sapere su questo circuito

Bobine e amplificatori operazionali consentono di creare circuiti molto interessanti, come i famosi filtri di frequenza. Questi filtri hanno una moltitudine di applicazioni nell'industria elettronica. Come nel caso del filtro passa basso, del filtro passa alto, ecc. Sono particolarmente interessanti per alcune applicazioni sonore, essendo in grado di filtrare rumori, o suoni più o meno gravi in ​​base alla loro frequenza. Pertanto, sono molto utili.

Se vuoi saperne di più sul filtro passa basso, e altri filtri, e come possono aiutarti nei tuoi progetti con Arduino o DIY, ti incoraggio a continuare a leggere ...

Filtri elettrici

Come suggerisce il nome, un filtro è un circuito costituito da una serie di bobine e condensatori, e anche alcuni amplificatori operazionali, allo scopo di lasciando passare solo alcune parti di una frequenza. Cioè, dell'intero spettro di frequenze disponibili, filtreranno una o più parti per impedirne il passaggio.

Sì per ejemplo Parliamo dello spettro udibile dall'essere umano, che va dai 20 Hz ai 20 Khz, con filtri si potrebbero eliminare il più basso, o il più alto, in modo da far passare solo i suoni più o meno alti / bassi. È qualcosa che molti sistemi di registrazione o riproduzione audio utilizzano, come microfoni, altoparlanti, ecc.

Tipo

Secondo il tipo di filtro, o meglio, a seconda della frequenza che bloccano o di quella che lasciano passare, esistono diversi tipi di circuiti che sono:

• Filtro passa basso: si chiamano così perché sono quei filtri che lasciano passare le frequenze più basse e sopprimono o riducono il passaggio delle frequenze più alte. Sono costituiti da una o più bobine (in serie con l'alimentazione e il carico) e uno o due condensatori di derivazione con l'alimentazione e il carico. Ricorda che per carico si intende il dispositivo collegato al filtro e che raccoglie l'uscita del filtro ... All'interno di questi filtri sono presenti anche varianti, come L, T e π.
• Filtro passa alto: il filtro passa alto è l'opposto del passa basso, in questo caso ciò che filtrerà o limiterà è il passaggio delle basse frequenze, lasciando passare le frequenze più alte. In questo vengono investiti gli elementi elettronici che lo compongono. Cioè, qui i condensatori saranno quelli in serie con l'alimentazione e il carico, mentre le bobine saranno deviate. Ci sono anche gli stessi sottotipi del caso dei filtri passa basso.
• Filtro passa banda: Questo tipo di filtro esercita due blocchi della velocità di passaggio della banda di frequenza. Cioè, agiscono sia come filtro passa basso che come filtro passa alto, opponendosi al passaggio delle frequenze più basse e allo stesso tempo anche delle più alte. In altre parole, consente il passaggio solo delle frequenze medie.
• Filtro a banda: è esattamente l'opposto del precedente, ciò che fa è che filtra il passaggio delle frequenze medie e lascia passare solo le frequenze più basse e più alte.

Ricordalo induttanze lasciano passare le basse frequenze e si oppongono al passaggio delle alte frequenze. Anziché, condensatori lasciano passare le alte frequenze e si oppongono al passaggio delle basse frequenze.

Vorrei aggiungere che i filtri a livello pratico non sono perfettee possono sempre far passare alcune frequenze basse o alte che dovresti bloccare. Tuttavia, fanno il loro lavoro abbastanza bene per la maggior parte delle applicazioni.

E infine, vorrei anche chiarire un'altra cosa, e cioè che sicuramente ne avrete sentito parlare Filtri EMA e DEMA. I filtri EMA (Exponential Moving Average) consentono di implementare questo tipo di filtro in modo semplice nei dispositivi embedded. Per quanto riguarda DEMA (Double Exponential Moving Average), hanno una risposta più rapida rispetto all'EMA, mantenendo una buona soppressione del rumore che si desidera evitare.

Fattore alfa

El fattore alfa, che vedrai comparire nei codici IDE di Arduino nella prossima sezione, è il parametro che condiziona il comportamento del filtro esponenziale. È correlato alla frequenza di taglio:

• Alpha = 1: che fornisce un segnale all'uscita non filtrata.
• Alpha = 0: il valore del filtro sarà sempre 0.
• Alpha = x: altri valori possono ottenere altre alterazioni nel filtro EMA. Se si diminuisce il fattore Alpha, si ammorbidisce maggiormente il segnale in frequenza ottenuto e si aumenta anche il tempo di risposta del sistema (ci vuole più tempo per stabilizzarsi).

Filtri e Arduino

Dovresti sapere che non è necessario creare il circuito filtro passa alto o filtro passa basso per collegarlo alla tua scheda Arduino e lavorarci. Sebbene tu possa sperimentare e creare questi tipi di filtri semplici, puoi anche testare come funzionerebbe un EMA con solo la scheda Arduino e un semplice codice per l'IDE di Arduino. È l'unica cosa di cui hai bisogno per vedere come è incaricato di filtrare alcune frequenze (in questo caso l'azione è simulata e alcuni numeri interi / float vengono semplicemente filtrati simulando cosa farei filtro in realtà).

Di seguito sono riportati alcuni esempi di codice che puoi utilizzare per esercitarti.

Esempio di semplice filtro digitale in Arduino di tipo passa basso:

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

Esempio di codice per il tipo Arduino Alto passaggio:

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
}

Esempio di codice Arduino passa banda:

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

Esempio di codice Arduino per banda:

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

Ti consiglio di modificare e sperimentare questi codici. Il risultato puoi vedere molto graficamente grazie al Serial Plotter dell'IDE di Arduino ... Ricorda che se hai domande sulla programmazione di Arduino o su come utilizzare l'IDE, puoi scaricare il corso gratuito HwLibre in PDF.