Aluláteresztő szűrő: minden, amit erről az áramkörről tudni kell

A tekercsek és az op erősítők lehetővé teszik, hogy nagyon érdekes áramköröket hozzon létre, például a híreseket frekvencia szűrők. Ezeknek a szűrőknek sokféle alkalmazása van az elektronikai iparban. Ahogy az aluláteresztő szűrő, a felüláteresztő szűrő stb. Különösen bizonyos hangalkalmazások szempontjából érdekesek, mivel a zajokat vagy a frekvenciájuk szerint többé-kevésbé komoly hangokat képesek szűrni. Ezért nagyon hasznosak.

Ha többet szeretne tudni a aluláteresztő szűrő, és egyéb szűrőket, és hogyan segíthetnek az Arduino vagy a DIY projektjeiben, javasolom, hogy folytassa az olvasást ...

Elektromos szűrők

Ahogy a neve is mutatja, a szűrő egy áramkör, amely tekercsekből és kondenzátorokból, sőt néhány műveleti erősítőből áll, a frekvencia csak bizonyos részeinek átengedése. Vagyis a rendelkezésre álló frekvenciák teljes spektrumából egy vagy több részt leszűrnek, hogy megakadályozzák áthaladásukat.

Igen ejemplo Az emberi lény által hallható spektrumról beszélünk, amely 20 Hz-ről 20 Khz-re változik, olyan szűrőkkel, amelyek kiküszöbölhetnék a legalacsonyabbat, vagy a legmagasabbat, hogy csak a többé-kevésbé magas / mély hangokat engedjék át. Olyan dolog, amit sok hangrögzítő vagy reprodukáló rendszer használ, például mikrofonok, hangszórók stb.

Típusai

: Aluláteresztő szűrő

: Magasáramú szűrő

: Frekvenciaszűrő grafikonok

Szerint szűrő típusa, vagy inkább az általuk blokkolt frekvenciától vagy az átengedett frekvenciától függően különböző típusú áramkörök vannak:

Aluláteresztő szűrő: azért hívják őket, mert azok a szűrők engedik át a legalacsonyabb frekvenciákat, és elnyomják vagy csökkentik a magasabb frekvenciák áthaladását. Ezek egy vagy több tekercsből állnak (sorban az áramellátással és a terheléssel), valamint egy vagy két sönt kondenzátorból, amelyek tápellátással és terheléssel rendelkeznek. Ne feledje, hogy a terhelés alatt a szűrőhöz csatlakoztatott eszközt értjük, amely összegyűjti a szűrő kimenetét ... Ezekben a szűrőkben vannak olyan változatok is, mint L, T és π.
Magasáramú szűrő: a felüláteresztő szűrő ellentétes az aluláteresztővel, ebben az esetben az alacsony frekvenciás áteresztés szűrhető vagy korlátozható, a magasabb frekvenciák átengedése. Ebbe fektetik az azt alkotó elektronikus elemeket. Vagyis itt a kondenzátorok sorosak lesznek az áramellátással és a terheléssel, miközben a tekercseket tolják. Vannak ugyanazok az altípusok is, mint az aluláteresztő szűrők esetében.
Sáváteresztő szűrő: Ez a típusú szűrő két frekvenciasáv-átviteli sebesség-zárat hajt végre. Vagyis mind aluláteresztő, mind pedig felüláteresztő szűrőként működnek, szemben a legalacsonyabb és egyben a legmagasabb frekvenciák áthaladásával. Más szavakkal, csak a középfrekvenciákat engedi át.
Sávszűrő: pontosan ellentétes az előzővel, amit csinál, hogy kiszűri a középfrekvenciák áthaladását, és csak a legalacsonyabb és a legmagasabb frekvenciákat engedi át.

Emlékezz erre induktivitások alacsony frekvenciákat engednek át és ellenzik a magas frekvenciák áthaladását. Helyette, kondenzátorok átengedik a magas frekvenciákat és ellenzik az alacsony frekvenciák áthaladását.

Szeretném hozzátenni, hogy a szűrőket gyakorlati szinten nem tökéletesek, és mindig át tudnak adni néhány alacsony vagy magas frekvenciát, amelyeket blokkolnia kell. A legtöbb alkalmazásnál azonban elég jól végzik munkájukat.

És végül még egy dolgot szeretnék tisztázni, mégpedig azt, hogy biztosan hallottál a EMA és DEMA szűrők. Az EMA (Exponential Moving Average) szűrők lehetővé teszik az ilyen típusú szűrők egyszerű megvalósítását a beágyazott eszközökben. Ami a DEMA-t (dupla exponenciális mozgóátlag) illeti, az EMA-nál gyorsabban reagálnak, fenntartva az elkerülni kívánt zaj jó elnyomását.

Alfa faktor

El alfa faktor, amelyet látni fog, hogy megjelenik az Arduino IDE kódokban a következő szakaszban, az a paraméter, amely feltételezi az exponenciális szűrő viselkedését. Ez összefügg a határértékkel:

Alpha = 1: ez jelet ad a szűretlen kimenetre.
Alpha = 0: a szűrő értéke mindig 0 lesz.
Alpha = x: más értékek más módosításokat is elérhetnek az EMA szűrőben. Ha csökkenti az Alfa-tényezőt, akkor lágyítja a kapott frekvenciajelet, és a rendszer válaszideje is megnő (hosszabb ideig tart a stabilizálás).

Szűrők és Arduino

Ezeknek a szűrőknek a használatával az Arduino IDE könyvtárának használata sokkal megkönnyíti a munkáját. Te tudod használni ugyanaz.

Tudnia kell, hogy nem szükséges létrehozni az áramkört felüláteresztő vagy aluláteresztő szűrő hogy csatlakoztassa az Arduino táblához és dolgozzon vele. Bár kísérletezhet és létrehozhat ilyen típusú egyszerű szűrőket, kipróbálhatja, hogy egy EMA hogyan működne csak az Arduino táblával és az Arduino IDE egyszerű kódjával. Ez az egyetlen dolog, amit látnia kell, hogy hogyan felelős egyes frekvenciák szűréséért (ebben az esetben a műveletet szimulálják, és egyes egész számokat / úszókat egyszerűen kiszűrnek szimulálva, mit tennék szűrő valójában).

Íme néhány kódminta, amelyek segítségével gyakorolhat.

Példa az Arduino típusú egyszerű digitális szűrőre aluláteresztő:

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

Kódpélda Arduino típusra Magas passz:

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 kód példa zenekar bérlet:

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 kód példa zenekar számára:

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

Ne feledje, hogy az ADC az Arduino Analog Digital átalakító. Használjon 0-5v tartományt, 0-1023 tartományokra osztva. Ha az érték 0v, akkor 0 értéket veszünk fel egy digitális értékre, és ha értéke 5v, akkor 1023-at veszünk jelértéknek, az 1v lehet 204m, a 2v 408 stb.

Azt tanácsolom, hogy módosítsa és kísérletezzen ezekkel a kódokkal. Az eredmény, amit tudsz lásd nagyon grafikusan hála az Arduino IDE soros plotterének ... Ne feledje, hogy ha kérdései vannak az Arduino programozásával vagy az IDE használatával kapcsolatban, letöltheti a ingyenes HwLibre tanfolyam PDF formátumban.

Hardwarelibre

Aluláteresztő szűrő: minden, amit tudnia kell erről az áramkörről

Elektromos szűrők

Típusai

Alfa faktor

Szűrők és Arduino

Hagyja megjegyzését Mégsem válaszát