Les bobines i els amplificadors operacionals permeten crear circuits molt interessants, com són els famosos filtres de freqüència. Aquests filtres tenen en la indústria electrònica multitud d'aplicacions. Com és el cas de l'filtre pas baix, el filtre pas alt, etc. Són especialment interessants per a certes aplicacions de so, podent filtrar sorolls, o sons més o menys greus segons la seva freqüència. Per tant, són molt útils.
Si vols saber més sobre el filtre pas baix, I altres filtres, i com et poden ajudar aquests en els teus projectes amb Arduino o DIY, t'animo a seguir llegint ...
filtres elèctrics
Com el seu propi nom indica, un filtre és un circuit que es compon d'una sèrie de bobines i condensadors, i fins i tot d'alguns amplificadors operacionals, amb la finalitat de deixar passar només a determinades parts d'una freqüència. És a dir, de tot l'espectre de freqüències disponibles, filtraran una o diverses parts per evitar que passin.
si per EXEMPLE parlem de l'espectre audible per l'ésser humà, que va des dels 20 Hz als 20 Khz, amb filtres es podria eliminar les més baixes, o les més altes per així deixar sol pas als sons més o menys aguts / greus. És una cosa que fan servir molts sistemes d'enregistrament o reproducció d'àudio, com els micròfons, altaveus, etc.
Tipus
-
- Filtre pas baix
-
- Filtre pas alt
-
- Gràfiques de filtres de freqüències
Segons el tipus de filtre, O millor dit, segons la freqüència que bloquegen o la que deixen passar, es tenen diferents tipus de circuits que són:
- Filtre pas baix: Es diuen així perquè són aquells filtres que deixen passar les freqüències més baixes i suprimeixen o redueixen el pas de les freqüències més altes. Es componen d'una o més bobines (en sèrie amb la font d'alimentació i la càrrega), i un o dos condensadors en derivació amb la font d'alimentació i càrrega. Recorda que s'entén com a càrrega a l'aparell connectat a el filtre i que recull la sortida de l'filtre ... Dins d'aquests filtres hi al seu torn variants, com el L, T i π.
- Filtre pas alt: El filtre pas alt és el contrari a el pas sota, en aquest cas, el que filtrarà o limitarà és el pas de freqüències baixes, deixant passar les més altes. En aquest s'inverteixen els elements electrònics que el componen. És a dir, aquí els condensadors seran els que estiguin en sèrie amb la font d'alimentació i la càrrega, mentre que les bobines es col·locaran en derivació. Existeixen també els mateixos subtipus que en el cas dels filtres pas baix.
- Filtre pas banda: Aquest tipus de filtre s'exerceixen XNUMX bloquejos de règims de pas de banda de freqüència. És a dir, actuen tant com un filtre pas baix com un filtre pas alt, oposant-se a el pas de les freqüències més baixes i també les més altes alhora. Dit d'una altra manera, només permet el pas de les freqüències mitjanes.
- Filtre per a banda: És justament el contrari a l'anterior, el que fa és que filtra el pas de les freqüències mitjanes i només deixa passar les freqüències més baixes i les més altes.
Recorda que les inductàncies deixen passar les baixes freqüències i s'oposen a el pas de les altes freqüències. En canvi, els condensadors deixen passar les altes freqüències i s'oposen a el pas de les baixes freqüències.
M'agradaria afegir que els filtres a nivell pràctic no són perfectes, I sempre poden deixar passar algunes freqüències baixes o altes que hauria de bloquejar. No obstant això, exerceixen el seu treball d'una forma bastant bona per a la majoria d'aplicacions.
I finalment, també m'agradaria aclarir una altra cosa, i és que segurament has sentit parlar dels filtres EMA i DEMA. Els filtres EMA (Exponential Moving Average) permeten implementar aquest tipus de filtres d'una manera senzilla en dispositius encastats. Pel que fa a DEMA (Double Exponential Moving Average) tenen una resposta més ràpida que el EMA, mantenint una bona supressió de soroll que es vol evitar.
factor Alpha
El factor alpha, Que veuràs que apareix en els codis d'Arduino IDE en el següent apartat, és el paràmetre que condiciona el comportament de l'filtre exponencial. Està relacionat amb la freqüència de tall:
- Alpha = 1: això proporciona un senyal a la sortida sense filtrar.
- Alpha = 0: el valor de filtrat sempre serà 0.
- Alpha = x: altres valors poden aconseguir altres alteracions en el filtre EMA. Si disminueixes el factor Alpha vas a suavitzar més el senyal de freqüència obtinguda, i també s'augmenta el temps de resposta de sistema (triga més a estabilitzar-se).
Filtres i Arduino
Has de saber, que no és necessari crear el circuit filtre pas alt o filtre pas baix per connectar-lo a la teva placa Arduino i treballar amb ell. Encara pots experimentar i crear aquest tipus de filtres senzills, també pots provar com funcionaria un EMA amb sol la placa Arduino i un simple codi per Arduino IDE. És l'únic que necessites per veure com s'encarrega de filtrar algunes freqüències (en aquest cas es simula l'acció i simplement es filtren alguns sencers / flotants simulant el que faria el filtre en realitat).
Aquí et deixo alguns exemples de codi que pots utilitzar per practicar.
Exemple de filtre senzill digital en Arduino de tipus pas sota:
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);
Exemple de codi per Arduino tipus pas alt:
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
}
Exemple de codi Arduino pas 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);
}
Exemple de codi Arduino per a 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);
}
T'aconsello modificar i experimentar amb aquests codis. El resultat el pots veure de forma molt gràfica gràcies a Serial Plotter de l'Arduino IDE ... Recorda que si tens dubtes sobre la programació d'Arduino o sobre com fer servir l'IDE, pots descarregar el curs gratis en PDF de HwLibre.