iir1
Bugfix release
Une bibliothèque de filtre à réponse impulsionnelle infinie (IIR) pour Linux, Mac OSX et Windows qui implémente les filtres Butterworth, RBJ, Chebychev et peut facilement importer des coefficients générés par Python (SCIPY).
Le filtre traite l'échantillon de données par échantillon pour un traitement en temps réel.
Il utilise des modèles pour allouer la mémoire requise afin qu'il puisse s'exécuter sans commandes malloc / nouvelles. La mémoire est allouée au moment de la compilation afin qu'il n'y ait jamais le risque de fuites de mémoire.
Tout le code de filtre en temps réel est dans les fichiers d'en-tête qui garantit une intégration efficace dans le programme principal et le compilateur peut optimiser à la fois le code filtre et le programme principal en même temps.
Ajoutez l'inclusion d'inclusion suivante à votre code:
#include "Iir.h"
L'approche de codage général est que le filtre est d'abord instancié spécifiant son ordre, puis les paramètres sont définis avec la setup de la fonction, puis il est prêt à être utilisé pour un échantillon par exemple de filtrage en temps réel.
L'idée est d'allouer la mémoire du filtre au moment de la compilation avec un argument de modèle pour éviter de nouvelles commandes. Cela empêche les fuites de mémoire et peut être optimisé au moment de la compilation. La order fournie au modèle (par exemple ici pour un filtre à bascule):
Iir::Butterworth::LowPass<order> f;
est utilisé comme ordre par défaut par la commande setup ci-dessous mais peut être remplacé par une commande inférieure si nécessaire.
setupTous les filtres sont disponibles sous forme de filtres PASPASS, High Pass, Band Pass et Bandstop / Notch. Butterworth / Chebyshev propose également des carreaux bas / haut / bande avec gain de bande passante spécifiée et un gain de 0 dB dans la bande d'arrêt.
Les fréquences peuvent être des analogiques contre la vitesse d'échantillonnage ou des taux normalisés entre 0..1 / 2 où 1/2 est la fréquence de Nyquist. Notez que les fréquences normalisées sont simplement F = F / FS et sont en unités de 1 / échantillons. En interne, la bibliothèque utilise des fréquences normalisées et les commandes de configuration se divisent simplement par le taux d'échantillonnage si elles sont données. Choisissez entre:
setup : taux d'échantillonnage et fréquences de coupure analogiquesetupN : fréquences normalisées dans 1 / échantillons entre f = 0..1 / 2 où 1/2 = nyquist. Par défaut, setup utilise la commande fournie par l'argument du modèle mais peut être remplacée par des commandes de filtre plus bas.
Voir les fichiers d'en-tête dans iir ou la documentation pour les arguments des commandes setup .
Les exemples ci-dessous sont pour les filtres passe-bas:
Butterworth.h Filtre standard adapté à la plupart des applications. Réponse monotone. const int order = 4; // 4th order (=2 biquads)
Iir::Butterworth::LowPass<order> f;
const float samplingrate = 1000; // Hz
const float cutoff_frequency = 5; // Hz
f.setup (samplingrate, cutoff_frequency);
ou spécifiez une fréquence normalisée entre 0..1 / 2:
f.setupN(norm_cutoff_frequency);
ChebyshevI.h avec une ondulation de bande passante autorisée en DB. Iir::ChebyshevI::LowPass<order> f;
const float passband_ripple_in_db = 5;
f.setup (samplingrate,
cutoff_frequency,
passband_ripple_in_dB);
ou spécifiez une fréquence normalisée entre 0..1 / 2:
f.setupN(norm_cutoff_frequency,passband_ripple_in_dB);
ChebyshevII.h avec le pire rejet de bande d'arrêt autorisé en db. Iir::ChebyshevII::LowPass<order> f;
double stopband_ripple_in_dB = 20;
f.setup (samplingrate,
cutoff_frequency,
stopband_ripple_in_dB);
ou spécifiez une fréquence normalisée entre 0..1 / 2:
f.setupN(norm_cutoff_frequency,stopband_ripple_in_dB);
RBJ.h 2nd Ordre Filtres avec coupure et facteur Q. Iir::RBJ::LowPass f;
const float cutoff_frequency = 100;
const float Q_factor = 5;
f.setup (samplingrate, cutoff_frequency, Q_factor);
ou spécifiez une fréquence normalisée entre 0..1 / 2:
f.setupN(norm_cutoff_frequency, Q_factor);
Custom.h ########
# Python
# See "elliptic_design.py" for the complete code.
from scipy import signal
order = 4
sos = signal.ellip(order, 5, 40, 0.2, 'low', output='sos')
print(sos) # copy/paste the coefficients over & replace [] with {}
///////
// C++
// part of "iirdemo.cpp"
const double coeff[][6] = {
{1.665623674062209972e-02,
-3.924801366970616552e-03,
1.665623674062210319e-02,
1.000000000000000000e+00,
-1.715403014004022175e+00,
8.100474793174089472e-01},
{1.000000000000000000e+00,
-1.369778997100624895e+00,
1.000000000000000222e+00,
1.000000000000000000e+00,
-1.605878925999785656e+00,
9.538657786383895054e-01}
};
const int nSOS = sizeof(coeff) / sizeof(coeff[0]); // here: nSOS = 2 = order / 2
Iir::Custom::SOSCascade<nSOS> cust(coeff);
Les échantillons sont traités un par un. Dans l'exemple ci-dessous, un échantillon x est traité avec la commande filter puis enregistré en y . Les types de x et y peuvent être flottants ou doubles (entier est également autorisé mais est toujours traité en interne en point flottant):
y = f.filter(x);
Ceci est ensuite répété pour chaque échantillon entrant dans une boucle ou un gestionnaire d'événements.
Les valeurs non valides fournies à setup() lanceront une exception. Les paramètres fournis à setup() qui entraînent que les coefficients sont NAN lancera également une exception.
Vous pouvez désactiver la gestion de l'exception en définissant IIR1_NO_EXCEPTIONS via CMake ou dans votre programme.
Si vous utilisez CMake comme système de construction, ajoutez simplement à vos CMakeLists.txt les lignes suivantes pour la bibliothèque dynamique:
find_package(iir)
target_link_libraries(... iir::iir)
ou pour le statique:
find_package(iir)
target_link_libraries(... iir::iir_static)
Linez-le à la bibliothèque dynamique (UNIX / Mac: -liir , Windows: iir.lib ) ou la bibliothèque statique (UNIX / Mac: libiir_static.a , Windows: libiir_static.lib ).
Si vous utilisez Ubuntu LTS, vous pouvez installer cette bibliothèque en tant que package pré-compilé.
Ajoutez ce référentiel à votre système:
sudo add-apt-repository ppa:berndporr/dsp
Ensuite, installez les packages:
sudo apt install iir1sudo apt install iir1-devIl est disponible pour des Intel 64 bits et un bras de 32,64 bits (Raspberry Pi, etc.). La documentation du package de développement et les exemples de programmes se trouvent:
/usr/share/doc/iir1-dev/
L'outil de construction est cmake qui génère les fichiers de maquille et de projet pour les différentes plates-formes. cmake est disponible pour Linux, Windows et Mac. Il compile également directement sur un Raspberry Pi.
Courir
cmake .
qui génère le makefile. Puis courez:
make
sudo make install
qui l'installe sous /usr/local/lib et /usr/local/include .
GCC et Clang ont été testés.
cmake -G "Visual Studio 16 2019" -A x64 .
Voir cmake pour les différentes options de construction. Ci-dessus est pour une construction 64 bits. Démarrez ensuite Visual C ++ et ouvrez la solution. Cela créera la DLL et les fichiers lib. Sous Windows, il est fortement recommandé d'utiliser la bibliothèque statique et de la lier au programme d'application.
Exécutez des tests unitaires en tapant make test ou simplement ctest . Ces tests si après une impulsion delta, tous les filtres se détendent à zéro, que leurs sorties ne deviennent jamais NAN et si le formulaire direct I & II filtre les séquences attendues en les comparant à partir des résultats créés par la sortie de Scipy's sosfilt .
Vous pouvez désactiver la génération de tests en définissant IIR1_BUILD_TESTING TO OFF.
La façon la plus simple d'apprendre est des exemples qui sont dans le répertoire demo . Une impulsion delta en tant que signal de test est envoyée dans les différents filtres et enregistrée dans un fichier. Avec le script Python plot_impulse_fresponse.py vous pouvez ensuite tracer les réponses de fréquence.
Vous pouvez désactiver la compilation des démos en définissant IIR1_BUILD_DEMO .
Le répertoire contenant également les tests unitaires fournit des exemples pour chaque type de filtre.
Un PDF de toutes les classes, méthodes et en particulier les fonctions setup se trouve dans le répertoire docs/pdf .
La documentation en ligne est ici: http://berndporr.github.io/iir1
Ces réponses ont été générées par iirdemo.cpp dans le répertoire /demo/ puis tracées avec plot_impulse_fresponse.py .
Cette bibliothèque a été développée à partir de la grande œuvre originale de Vinnie Falco qui peut être trouvée ici:
https://github.com/vinniefalco/dspfilters
Alors que la bibliothèque d'origine traite les tableaux audio, cette bibliothèque a été adaptée pour effectuer un échantillon de traitement en temps réel rapide par échantillon. La commande setup ne nécessitera pas l'ordre du filtre et ne se souvient plutôt de l'argument du modèle. La structure de classe a été simplifiée et toutes les fonctions documentées pour le doxygen. Au lieu d'avoir des instructions affirmer (), cette Libary lance des exceptions au cas où un paramètre serait faux. Toute conception de filtre nécessitant une optimisation (par exemple les filtres ellipiques) a été supprimée et une fonction a été ajoutée qui peut importer des coefficients facilement à partir de SciPy.
Bernd Porr - http://www.berndporr.me.uk
