Filtro paso bajo: todo lo que necesitas saber de este circuito

filtro paso bajo, circuito

Las bobinas y los amplificadores operacionales permiten crear circuitos muy interesantes, como son los famosos filtros de frecuencia. Estos filtros tienen en la industria electrónica multitud de aplicaciones. Como es el caso del filtro paso bajo, el filtro paso alto, etc. Son especialmente interesantes para ciertas aplicaciones de sonido, pudiendo filtrar ruidos, o sonidos más o menos graves según su frecuencia. Por tanto, son muy útiles.

Si quieres saber más sobre el filtro paso bajo, y otros filtros, y cómo te pueden ayudar éstos en tus proyectos con Arduino o DIY, te animo a seguir leyendo…

Filtros eléctricos

Como su propio nombre indica, un filtro es un circuito que se compone de una serie de bobinas y condensadores, e incluso de algunos amplificadores operacionales, con la finalidad de dejar pasar solo a determinadas partes de una frecuencia. Es decir, de todo el espectro de frecuencias disponibles, filtrarán una o varias partes para evitar que pasen.

Si por ejemplo hablamos del espectro audible por el ser humano, que va desde los 20 Hz a los 20 Khz, con filtros se podría eliminar las más bajas, o las más altas para así dejar solo paso a los sonidos más o menos agudos/graves. Es algo que usan muchos sistemas de grabación o reproducción de audio, como los micrófonos, altavoces, etc.

Tipos

Según el tipo de filtro, o mejor dicho, según la frecuencia que bloquean o la que dejan pasar, se tienen diferentes tipos de circuitos que son:

  • Filtro paso bajo: se llaman así porque son aquellos filtros que dejan pasar las frecuencias más bajas y suprimen o reducen el paso de las frecuencias más altas. Se componen de una o más bobinas (en serie con la fuente de alimentación y la carga), y uno o dos condensadores en derivación con la fuente de alimentación y carga. Recuerda que se entiende como carga al aparato conectado al filtro y que recoge la salida del filtro… Dentro de estos filtros existen a su vez variantes, como el L, T y π.
  • Filtro paso alto: el filtro paso alto es lo contrario al paso bajo, en este caso, lo que filtrará o limitará es el paso de frecuencias bajas, dejando pasar las más altas. En este se invierten los elementos electrónicos que lo componen. Es decir, aquí los condensadores serán los que estén en serie con la fuente de alimentación y la carga, mientras que las bobinas se colocarán en derivación. Existen también los mismos subtipos que en el caso de los filtros paso bajo.
  • Filtro paso banda: este tipo de filtro se ejercen dos bloqueos de regímenes de paso de banda de frecuencia. Es decir, actúan tanto como un filtro paso bajo como un filtro paso alto, oponiéndose al paso de las frecuencias más bajas y también las más altas a la vez. Dicho de otro modo, solo permite el paso de las frecuencias medias.
  • Filtro para banda: es justamente lo contrario al anterior, lo que hace es que filtra el paso de las frecuencias medias y solo deja pasar las frecuencias más bajas y las más altas.

Recuerda que las inductancias dejan pasar las bajas frecuencias y se oponen al paso de las altas frecuencias. En cambio, los condensadores dejan pasar las altas frecuencias y se oponen al paso de las bajas frecuencias.

Me gustaría agregar que los filtros a nivel práctico no son perfectos, y siempre pueden dejar pasar algunas frecuencias bajas o altas que debería bloquear. No obstante, desempeñan su trabajo de una forma bastante buena para la mayoría de aplicaciones.

Y por último, también me gustaría aclarar otra cosa, y es que seguramente has escuchado hablar de los filtros EMA y DEMA. Los filtros EMA (Exponential Moving Average) permiten implementar este tipo de filtros de una forma sencilla en dispositivos embebidos. En cuanto a DEMA (Double Exponential Moving Average) tienen una respuesta más rápida que el EMA, manteniendo una buena supresión del ruido que se desea evitar.

Factor Alpha

El factor alpha, que verás que aparece en los códigos de Arduino IDE en el siguiente apartado, es el parámetro que condiciona el comportamiento del filtro exponencial. Está relacionado con la frecuencia de corte:

  • Alpha = 1: eso proporciona una señal a la salida sin filtrar.
  • Alpha = 0: el valor de filtrado siempre será 0.
  • Alpha = x: otros valores pueden conseguir otras alteraciones en el filtro EMA. Si disminuyes el factor Alpha vas a suavizar más la señal de frecuencia obtenida, y también se aumenta el tiempo de respuesta del sistema (tarda más en estabilizarse).

Filtros y Arduino

Arduino bus I2C

Para el uso de estos filtros, el uso de una biblioteca para Arduino IDE te facilitará mucho el trabajo. Puedes usar esta misma.

Debes saber, que no es necesario crear el circuito filtro paso alto o filtro paso bajo para conectarlo a tu placa Arduino y trabajar con él. Aunque puedes experimentar y crear este tipo de filtros sencillos, también puedes probar cómo funcionaría un EMA con solo la placa Arduino y un simple código para Arduino IDE. Es lo único que necesitas para ver cómo se encarga de filtrar algunas frecuencias (en este caso se simula la acción y simplemente se filtran algunos enteros/flotantes simulando lo que haría el filtro en realidad).

Aquí te dejo algunos ejemplos de código que puedes usar para practicar.

Ejemplo de filtro sencillo digital en Arduino de tipo paso bajo:


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

Ejemplo de código para Arduino tipo paso alto:


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
}

Ejemplo de código Arduino paso 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);                              
}

Ejemplo de código Arduino para 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);                                
}

Recuerda que ADC es el conversor Analógico Digital de Arduino. Usa un rango de 0-5v, dividiendo en rangos de 0-1023. Si el valor es 0v se toma valor 0 digital, y si es 5v se tomará 1023 como valor de señal, 1v pueden ser 204m, 2v sería 408, etc.

Te aconsejo modificar y experimentar con estos códigos. El resultado lo puedes ver de forma muy gráfica gracias a Serial Plotter del Arduino IDE… Recuerda que si tienes dudas sobre la programación de Arduino o sobre cómo usar el IDE, puedes descargar el curso gratis en PDF de HwLibre.


El contenido del artículo se adhiere a nuestros principios de ética editorial. Para notificar un error pincha aquí.

Sé el primero en comentar

Deja tu comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

*

*

  1. Responsable de los datos: Miguel Ángel Gatón
  2. Finalidad de los datos: Controlar el SPAM, gestión de comentarios.
  3. Legitimación: Tu consentimiento
  4. Comunicación de los datos: No se comunicarán los datos a terceros salvo por obligación legal.
  5. Almacenamiento de los datos: Base de datos alojada en Occentus Networks (UE)
  6. Derechos: En cualquier momento puedes limitar, recuperar y borrar tu información.