17 changed files with 1120 additions and 429 deletions
-
8CMakeLists.txt
-
8README.md
-
27mainwindow.cpp
-
59mainwindow.ui
-
294src/filter_algo_mgr.cpp
-
99src/filter_algo_mgr.hpp
-
204src/filter_group/algo/fir_filter.cpp
-
37src/filter_group/algo/fir_filter.hpp
-
0src/filter_group/algo/iflytop_simple_filter.cpp
-
0src/filter_group/algo/iflytop_simple_filter.h
-
41src/filter_group/fir_filter_group.cpp
-
39src/filter_group/fir_filter_group.hpp
-
100src/filter_group/if/if_filter_group.hpp
-
119src/filter_group/iir_filter_group.cpp
-
102src/filter_group/iir_filter_group.hpp
@ -0,0 +1,204 @@ |
|||
#include "fir_filter.hpp"
|
|||
|
|||
static double sinc(const double x) |
|||
{ |
|||
if (x == 0) |
|||
return 1; |
|||
|
|||
return sin(M_PI * x) / (M_PI * x); |
|||
} |
|||
|
|||
FIR_filter::FIR_filter( int taps, double f1, double f2, const char* type, |
|||
const char* window): h(taps, 0), samples(taps, 0) |
|||
{ |
|||
this->idx = 0; |
|||
this->taps = taps; |
|||
|
|||
std::vector<double> h; // Buffer FIR coefficients
|
|||
std::vector<double> w; // Buffer window coefficients
|
|||
|
|||
// Calculate the coefficient corresponding to the filter type
|
|||
if (!strcmp(type, "lp")) { |
|||
h = lowPass_coefficient(taps, f1); |
|||
} |
|||
else if (!strcmp(type, "hp")) { |
|||
h = highPass_coefficient(taps, f1); |
|||
} |
|||
else if (!strcmp(type, "bp")) { |
|||
h = bandPass_coefficient(taps, f1, f2); |
|||
} |
|||
else if (!strcmp(type, "sb")) { |
|||
h = bandStop_coefficient(taps, f1, f2); |
|||
} |
|||
|
|||
// Calculate the window to improve the FIR filter
|
|||
if (!strcmp(window, "hamming")) { |
|||
w = window_hammig(taps); |
|||
} |
|||
else if (!strcmp(window, "triangle")) { |
|||
w = window_triangle(taps); |
|||
} |
|||
else if (!strcmp(window, "hanning")) { |
|||
w = window_hanning(taps); |
|||
} |
|||
else if (!strcmp(window, "blackman")) { |
|||
w = window_blackman(taps); |
|||
} |
|||
|
|||
if (!strcmp(window, "")) { |
|||
this->h = h; |
|||
} |
|||
else |
|||
{ |
|||
for(int n = 0; n < taps; n++) { |
|||
this->h[n] = h[n] * w[n]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
FIR_filter::~FIR_filter() |
|||
{ |
|||
|
|||
} |
|||
|
|||
std::vector<double> FIR_filter::getCoefficients() |
|||
{ |
|||
return this->h; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::lowPass_coefficient(int taps, double f) |
|||
{ |
|||
std::vector<int> n(taps, 0); |
|||
std::vector<double> h(taps, 0); |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
n[i] = i - int(taps/2); |
|||
} |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
h[i] = 2.0*f*sinc(2.0*f*n[i]); |
|||
} |
|||
|
|||
return h; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::highPass_coefficient(int taps, double f) |
|||
{ |
|||
std::vector<int> n(taps, 0); |
|||
std::vector<double> h(taps, 0); |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
n[i] = i - int(taps/2); |
|||
} |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
h[i] = sinc(n[i]) - 2.0*f*sinc(2.0*f*n[i]); |
|||
} |
|||
|
|||
return h; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::bandPass_coefficient(int taps, double f1, double f2) |
|||
{ |
|||
std::vector<int> n(taps, 0); |
|||
std::vector<double> h(taps, 0); |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
n[i] = i - int(taps/2); |
|||
} |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
h[i] = 2.0*f1*sinc(2.0*f1*n[i]) - 2.0*f2*sinc(2.0*f2*n[i]); |
|||
} |
|||
|
|||
return h; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::bandStop_coefficient(int taps, double f1, double f2) |
|||
{ |
|||
std::vector<int> n(taps, 0); |
|||
std::vector<double> h(taps, 0); |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
n[i] = i - int(taps/2); |
|||
} |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
h[i] = 2.0*f1*sinc(2.0*f1*n[i]) - 2.0*f2*sinc(2.0*f2*n[i]) + sinc(n[i]); |
|||
} |
|||
|
|||
return h; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::window_hammig(int taps) |
|||
{ |
|||
std::vector<int> n(taps, 0); |
|||
std::vector<double> w(taps, 0); |
|||
|
|||
double alpha = 0.54; |
|||
double beta = 0.46; |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
w[i] = alpha - beta * cos(2.0 * M_PI * i / (taps - 1)); |
|||
} |
|||
|
|||
return w; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::window_hanning(int taps) |
|||
{ |
|||
std::vector<double> w(taps, 0); |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
w[i] = sin(((double) M_PI * i) / (taps - 1)) * |
|||
sin(((double) M_PI * i) / (taps - 1)); |
|||
} |
|||
|
|||
return w; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::window_triangle(int taps) |
|||
{ |
|||
std::vector<double> w(taps, 0); |
|||
|
|||
double l = taps; |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
w[i] = 1 - abs((i - (((double)(taps-1)) / 2.0)) / (((double)l) / 2.0)); |
|||
} |
|||
|
|||
return w; |
|||
} |
|||
|
|||
std::vector<double> FIR_filter::window_blackman(int taps) |
|||
{ |
|||
std::vector<double> w(taps, 0); |
|||
|
|||
double alpha0 = 0.42; |
|||
double alpha1 = 0.5; |
|||
double alpha2 = 0.08; |
|||
|
|||
for(int i = 0; i < taps; i++) { |
|||
w[i] = alpha0 - alpha1 * cos(2.0 * M_PI * i / (taps - 1)) |
|||
- alpha2 * cos(4.0 * M_PI * i / (taps - 1)); |
|||
} |
|||
|
|||
return w; |
|||
} |
|||
|
|||
double FIR_filter::filter(double new_sample) |
|||
{ |
|||
double result = 0; |
|||
|
|||
// Save the new sample
|
|||
this->samples[this->idx] = new_sample; |
|||
|
|||
// Calculate the output
|
|||
for(int n = 0; n < this->taps; n++) |
|||
result += this->samples[(this->idx + n) % this->taps] * this->h[n]; |
|||
|
|||
// Increase the round robin index
|
|||
this->idx = (this->idx + 1) % this->taps; |
|||
|
|||
return result; |
|||
} |
|||
@ -0,0 +1,37 @@ |
|||
#ifndef FIR_FILTER_H
|
|||
#define FIR_FILTER_H
|
|||
|
|||
#include <stdlib.h>
|
|||
#include <string.h>
|
|||
|
|||
#include <cmath>
|
|||
#include <vector>
|
|||
|
|||
class FIR_filter { |
|||
public: |
|||
FIR_filter(int taps = 0, double f1 = 0, double f2 = 0, const char* type = "", const char* window = ""); |
|||
~FIR_filter(); |
|||
|
|||
std::vector<double> getCoefficients(); |
|||
|
|||
double filter(double new_sample); |
|||
|
|||
private: |
|||
std::vector<double> lowPass_coefficient(int taps, double f); |
|||
std::vector<double> highPass_coefficient(int taps, double f); |
|||
std::vector<double> bandPass_coefficient(int taps, double f1, double f2); |
|||
std::vector<double> bandStop_coefficient(int taps, double f1, double f2); |
|||
|
|||
std::vector<double> window_hammig(int taps); |
|||
std::vector<double> window_triangle(int taps); |
|||
std::vector<double> window_hanning(int taps); |
|||
std::vector<double> window_blackman(int taps); |
|||
|
|||
std::vector<double> h; // FIR coefficients
|
|||
std::vector<double> samples; // FIR delay
|
|||
|
|||
int idx; // Round robin index
|
|||
int taps; // Number of taps of the filter
|
|||
}; |
|||
|
|||
#endif // FIR_FILTER_H
|
|||
@ -0,0 +1,41 @@ |
|||
#include "fir_filter_group.hpp"
|
|||
|
|||
using namespace iflytop; |
|||
|
|||
void FirFilterGroup::initialize() { |
|||
lpfilter = new FIR_filter(1000, 0.1, 0, "lp", "hamming"); |
|||
hpfilter = new FIR_filter(1000, 0.1, 0, "hp", "hamming"); |
|||
notchfilter = new FIR_filter(1000, 0.1, 0, "bp", "hamming"); |
|||
} |
|||
int32_t FirFilterGroup::processData(int32_t data) { |
|||
std::lock_guard<std::recursive_mutex> lock(lock_); |
|||
|
|||
float v0 = (float)data; |
|||
if (lpfilter) { |
|||
v0 = lpfilter->filter(v0); |
|||
v0 = lpfilter->filter(v0); |
|||
} |
|||
|
|||
if (lpfilter) { |
|||
v0 = hpfilter->filter(v0); |
|||
v0 = hpfilter->filter(v0); |
|||
} |
|||
|
|||
if (notchfilter) { |
|||
v0 = notchfilter->filter(v0); |
|||
v0 = notchfilter->filter(v0); |
|||
} |
|||
|
|||
return (int32_t)v0; |
|||
} |
|||
|
|||
void FirFilterGroup::updateParameter() { |
|||
std::lock_guard<std::recursive_mutex> lock(lock_); |
|||
if(lpfilter) delete lpfilter; |
|||
if(hpfilter) delete hpfilter; |
|||
if(notchfilter) delete notchfilter; |
|||
|
|||
if (_LPFilter_Enable) lpfilter = new FIR_filter(_windows_size, _LPFilter_CutoffFreqHz, 0, "lp", _windowType.c_str()); |
|||
if (_HPFilter_Enable) hpfilter = new FIR_filter(_windows_size, _HPFilter_CutoffFreqHz, 0, "hp", _windowType.c_str()); |
|||
if (_NOTCHFilter_Enable) notchfilter = new FIR_filter(_windows_size, _NOTCHFilter_CenterFreqHz - _NOTCHFilter_NotchWidthHz, _NOTCHFilter_CenterFreqHz + _NOTCHFilter_NotchWidthHz, "sb", _windowType.c_str()); |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
#pragma once
|
|||
#include <fstream>
|
|||
#include <functional>
|
|||
#include <iostream>
|
|||
#include <list>
|
|||
#include <map>
|
|||
#include <memory>
|
|||
#include <mutex>
|
|||
#include <set>
|
|||
#include <sstream>
|
|||
#include <string>
|
|||
#include <thread>
|
|||
#include <vector>
|
|||
|
|||
#include "algo/fir_filter.hpp"
|
|||
#include "algo/iflytop_simple_filter.h"
|
|||
#include "if/if_filter_group.hpp"
|
|||
|
|||
namespace iflytop { |
|||
using namespace std; |
|||
|
|||
class FirFilterGroup : public IF_FilterGroup { |
|||
private: |
|||
std::recursive_mutex lock_; |
|||
|
|||
FIR_filter* lpfilter = nullptr; |
|||
FIR_filter* hpfilter = nullptr; |
|||
FIR_filter* notchfilter = nullptr; |
|||
|
|||
|
|||
public: |
|||
virtual void initialize() override; |
|||
virtual int32_t processData(int32_t data) override; |
|||
|
|||
virtual void updateParameter() override; |
|||
|
|||
|
|||
}; |
|||
} // namespace iflytop
|
|||
@ -0,0 +1,100 @@ |
|||
#pragma once
|
|||
#include <fstream>
|
|||
#include <functional>
|
|||
#include <iostream>
|
|||
#include <list>
|
|||
#include <map>
|
|||
#include <memory>
|
|||
#include <mutex>
|
|||
#include <set>
|
|||
#include <sstream>
|
|||
#include <string>
|
|||
#include <thread>
|
|||
#include <vector>
|
|||
|
|||
namespace iflytop { |
|||
using namespace std; |
|||
|
|||
class IF_FilterGroup { |
|||
protected: |
|||
float _sampleTimeMs; |
|||
|
|||
bool _LPFilter_Enable = false; |
|||
float _LPFilter_CutoffFreqHz = 0; |
|||
float _LPFilter_Order = 1; |
|||
|
|||
bool _HPFilter_Enable = false; |
|||
float _HPFilter_CutoffFreqHz = 0; |
|||
float _HPFilter_Order = 1; |
|||
|
|||
bool _NOTCHFilter_Enable = false; |
|||
float _NOTCHFilter_CenterFreqHz = 0; |
|||
float _NOTCHFilter_NotchWidthHz = 0; |
|||
float _NOTCHFilter_Order = 1; |
|||
|
|||
int _windows_size = 1000; |
|||
|
|||
const string kwindow_type_hamming = "hamming"; |
|||
const string kwindow_type_triangle = "triangle"; |
|||
const string kwindow_type_hanning = "hanning"; |
|||
const string kwindow_type_blackman = "blackman"; |
|||
|
|||
string _windowType = "hamming"; |
|||
|
|||
public: |
|||
virtual ~IF_FilterGroup() {} |
|||
|
|||
virtual void initialize() = 0; |
|||
|
|||
virtual int32_t processData(int32_t data) = 0; |
|||
|
|||
virtual void updateParameter() = 0; |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 通用参数 * |
|||
***********************************************************************************************************************/ |
|||
virtual void setSampleTimeMs(float sampleTimeMs) { _sampleTimeMs = sampleTimeMs; } |
|||
virtual float getSampleTimeMs() { return _sampleTimeMs; } |
|||
virtual void setWindowsSize(int windows_size) { _windows_size = windows_size; } |
|||
virtual int getWindowsSize() { return _windows_size; } |
|||
virtual void setWindowsType(string windowType) { _windowType = windowType; } |
|||
virtual string getWindowType() { return _windowType; } |
|||
static vector<string> windowsTypes() { return {"hamming", "triangle", "hanning", "blackman"}; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 低通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
virtual void LPFilter_setEnable(bool enable) { _LPFilter_Enable = enable; } |
|||
virtual void LPFilter_setCutoffFreqHz(float cutoffFreqHz) { _LPFilter_CutoffFreqHz = cutoffFreqHz; } |
|||
virtual void LPFilter_setOrder(int order) { _LPFilter_Order = order; } |
|||
|
|||
virtual bool LPFilter_getEnable() { return _LPFilter_Enable; } |
|||
virtual float LPFilter_getCutoffFreqHz() { return _LPFilter_CutoffFreqHz; } |
|||
virtual int LPFilter_getOrder() { return _LPFilter_Order; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 高通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
virtual void HPFilter_setEnable(bool enable) { _HPFilter_Enable = enable; } |
|||
virtual void HPFilter_setCutoffFreqHz(float cutoffFreqHz) { _HPFilter_CutoffFreqHz = cutoffFreqHz; } |
|||
virtual void HPFilter_setOrder(int order) { _HPFilter_Order = order; } |
|||
|
|||
virtual bool HPFilter_getEnable() { return _HPFilter_Enable; } |
|||
virtual float HPFilter_getCutoffFreqHz() { return _HPFilter_CutoffFreqHz; } |
|||
virtual int HPFilter_getOrder() { return _HPFilter_Order; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 带阻滤波器 * |
|||
***********************************************************************************************************************/ |
|||
virtual void NOTCHFilter_setEnable(bool enable) { _NOTCHFilter_Enable = enable; } |
|||
virtual void NOTCHFilter_setCenterFreqHz(float centerFreqHz) { _NOTCHFilter_CenterFreqHz = centerFreqHz; } |
|||
virtual void NOTCHFilter_setNotchWidthHz(float notchWidthHz) { _NOTCHFilter_NotchWidthHz = notchWidthHz; } |
|||
virtual void NOTCHFilter_setOrder(int order) { _NOTCHFilter_Order = order; } |
|||
|
|||
virtual bool NOTCHFilter_getEnable() { return _NOTCHFilter_Enable; } |
|||
virtual float NOTCHFilter_getCenterFreqHz() { return _NOTCHFilter_CenterFreqHz; } |
|||
virtual float NOTCHFilter_getNotchWidthHz() { return _NOTCHFilter_NotchWidthHz; } |
|||
virtual int NOTCHFilter_getOrder() { return _NOTCHFilter_Order; } |
|||
}; |
|||
} // namespace iflytop
|
|||
@ -0,0 +1,119 @@ |
|||
#include "iir_filter_group.hpp"
|
|||
#include "libzqt\zexception.hpp"
|
|||
#include "ify_hrs_protocol\heart_rate_sensor_protocol.h"
|
|||
|
|||
#include <mutex>
|
|||
|
|||
using namespace iflytop; |
|||
|
|||
void IIRFilterGroup::initialize() {} |
|||
|
|||
int32_t IIRFilterGroup::processData(int32_t data) { //
|
|||
std::lock_guard<std::recursive_mutex> lock(lock_); |
|||
|
|||
float v0 = (float)data; |
|||
for (int i = 0; i < __lpfilter_order; i++) { |
|||
v0 = LPFilter_Update(&lpfilter[i], v0); |
|||
} |
|||
|
|||
for (int i = 0; i < __hpfilter_order; i++) { |
|||
v0 = HPFilter_Update(&hpfilter[i], v0); |
|||
} |
|||
|
|||
for (int i = 0; i < __notchfilter_order; i++) { |
|||
v0 = NOTCHFilter_Update(¬chfilter[i], v0); |
|||
} |
|||
|
|||
return (int32_t)v0; |
|||
} |
|||
|
|||
void IIRFilterGroup::updateParameter() { |
|||
std::lock_guard<std::recursive_mutex> lock(lock_); |
|||
|
|||
for (int i = 0; i < FILTER_MAX_ORDER; i++) { |
|||
LPFilter_Init(&lpfilter[i], LPFilter_cutoffFreqHz, sampleTimeMs / 1000.0, lpfilter_enable); |
|||
} |
|||
for (int i = 0; i < FILTER_MAX_ORDER; i++) { |
|||
HPFilter_Init(&hpfilter[i], HPFilter_cutoffFreqHz, sampleTimeMs / 1000.0, hpfilter_enable); |
|||
} |
|||
for (int i = 0; i < FILTER_MAX_ORDER; i++) { |
|||
NOTCHFilter_Init(¬chfilter[i], NOTCHFilter_centerFreqHz, NOTCHFilter_notchWidthHz, sampleTimeMs / 1000.0, notchfilter_enable); |
|||
} |
|||
|
|||
__lpfilter_order = lpfilter_order; |
|||
__hpfilter_order = hpfilter_order; |
|||
__notchfilter_order = notchfilter_order; |
|||
} |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 通用参数 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
void IIRFilterGroup::setSampleTimeMs(float sampleTimeMs) { |
|||
if (sampleTimeMs < 0.4) { |
|||
throw zexception(kifyhrs_ecode_upper_exception, "sampleTimeMs must be greater than 0.4ms"); |
|||
} |
|||
this->sampleTimeMs = sampleTimeMs; |
|||
} |
|||
float IIRFilterGroup::getSampleTimeMs() { return sampleTimeMs; } |
|||
|
|||
void IIRFilterGroup::LPFilter_setOrder(int order) { |
|||
if (order < 1) { |
|||
order = 1; |
|||
} |
|||
if (order > FILTER_MAX_ORDER) { |
|||
order = FILTER_MAX_ORDER; |
|||
} |
|||
lpfilter_order = order; |
|||
} |
|||
int IIRFilterGroup::LPFilter_getOrder() { return lpfilter_order; } |
|||
void IIRFilterGroup::HPFilter_setOrder(int order) { |
|||
if (order < 1) { |
|||
order = 1; |
|||
} |
|||
if (order > FILTER_MAX_ORDER) { |
|||
order = FILTER_MAX_ORDER; |
|||
} |
|||
hpfilter_order = order; |
|||
} |
|||
int IIRFilterGroup::HPFilter_getOrder() { return hpfilter_order; } |
|||
void IIRFilterGroup::NOTCHFilter_setOrder(int order) { |
|||
if (order < 1) { |
|||
order = 1; |
|||
} |
|||
if (order > FILTER_MAX_ORDER) { |
|||
order = FILTER_MAX_ORDER; |
|||
} |
|||
notchfilter_order = order; |
|||
} |
|||
int IIRFilterGroup::NOTCHFilter_getOrder() { return notchfilter_order; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 低通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
void IIRFilterGroup::LPFilter_setEnable(bool enable) { lpfilter_enable = enable; } |
|||
void IIRFilterGroup::LPFilter_setCutoffFreqHz(float cutoffFreqHz) { LPFilter_cutoffFreqHz = cutoffFreqHz; } |
|||
|
|||
bool IIRFilterGroup::LPFilter_getEnable() { return lpfilter_enable; } |
|||
float IIRFilterGroup::LPFilter_getCutoffFreqHz() { return LPFilter_cutoffFreqHz; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 高通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void IIRFilterGroup::HPFilter_setEnable(bool enable) { hpfilter_enable = enable; } |
|||
void IIRFilterGroup::HPFilter_setCutoffFreqHz(float cutoffFreqHz) { HPFilter_cutoffFreqHz = cutoffFreqHz; } |
|||
|
|||
bool IIRFilterGroup::HPFilter_getEnable() { return hpfilter_enable; } |
|||
float IIRFilterGroup::HPFilter_getCutoffFreqHz() { return HPFilter_cutoffFreqHz; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 带阻滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void IIRFilterGroup::NOTCHFilter_setEnable(bool enable) { notchfilter_enable = enable; } |
|||
void IIRFilterGroup::NOTCHFilter_setCenterFreqHz(float centerFreqHz) { NOTCHFilter_centerFreqHz = centerFreqHz; } |
|||
void IIRFilterGroup::NOTCHFilter_setNotchWidthHz(float notchWidthHz) { NOTCHFilter_notchWidthHz = notchWidthHz; } |
|||
|
|||
bool IIRFilterGroup::NOTCHFilter_getEnable() { return notchfilter_enable; } |
|||
float IIRFilterGroup::NOTCHFilter_getCenterFreqHz() { return NOTCHFilter_centerFreqHz; } |
|||
float IIRFilterGroup::NOTCHFilter_getNotchWidthHz() { return NOTCHFilter_notchWidthHz; } |
|||
@ -0,0 +1,102 @@ |
|||
#pragma once
|
|||
#include <fstream>
|
|||
#include <functional>
|
|||
#include <iostream>
|
|||
#include <list>
|
|||
#include <map>
|
|||
#include <memory>
|
|||
#include <mutex>
|
|||
#include <set>
|
|||
#include <sstream>
|
|||
#include <string>
|
|||
#include <thread>
|
|||
#include <vector>
|
|||
|
|||
#include "algo/iflytop_simple_filter.h"
|
|||
#include "if/if_filter_group.hpp"
|
|||
|
|||
namespace iflytop { |
|||
using namespace std; |
|||
#define FILTER_MAX_ORDER 20
|
|||
|
|||
class IIRFilterGroup : public IF_FilterGroup { |
|||
private: |
|||
LPFilter_t lpfilter[FILTER_MAX_ORDER] = {0}; |
|||
HPFilter_t hpfilter[FILTER_MAX_ORDER] = {0}; |
|||
NOTCHFilter_t notchfilter[FILTER_MAX_ORDER] = {0}; |
|||
|
|||
int __lpfilter_order = 1; |
|||
int __hpfilter_order = 1; |
|||
int __notchfilter_order = 1; |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 缓存参数 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
bool lpfilter_enable = false; |
|||
bool hpfilter_enable = false; |
|||
bool notchfilter_enable = false; |
|||
|
|||
int lpfilter_order = 1; |
|||
int hpfilter_order = 1; |
|||
int notchfilter_order = 1; |
|||
|
|||
float LPFilter_cutoffFreqHz = 0; |
|||
float HPFilter_cutoffFreqHz = 0; |
|||
float NOTCHFilter_centerFreqHz = 0; |
|||
float NOTCHFilter_notchWidthHz = 0; |
|||
|
|||
float sampleTimeMs = 2; // 1ms
|
|||
|
|||
std::recursive_mutex lock_; |
|||
|
|||
public: |
|||
virtual void initialize() override; |
|||
|
|||
virtual int32_t processData(int32_t data) override; |
|||
|
|||
virtual void updateParameter() override; |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 通用参数 * |
|||
***********************************************************************************************************************/ |
|||
virtual void setSampleTimeMs(float sampleTimeMs) override; |
|||
virtual float getSampleTimeMs() override; |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 低通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
virtual void LPFilter_setEnable(bool enable) override; |
|||
virtual void LPFilter_setCutoffFreqHz(float cutoffFreqHz) override; |
|||
virtual void LPFilter_setOrder(int order) override; |
|||
|
|||
virtual bool LPFilter_getEnable() override; |
|||
virtual float LPFilter_getCutoffFreqHz() override; |
|||
virtual int LPFilter_getOrder() override; |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 高通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
virtual void HPFilter_setEnable(bool enable) override; |
|||
virtual void HPFilter_setCutoffFreqHz(float cutoffFreqHz) override; |
|||
virtual void HPFilter_setOrder(int order) override; |
|||
|
|||
virtual bool HPFilter_getEnable() override; |
|||
virtual float HPFilter_getCutoffFreqHz() override; |
|||
virtual int HPFilter_getOrder() override; |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 带阻滤波器 * |
|||
***********************************************************************************************************************/ |
|||
virtual void NOTCHFilter_setEnable(bool enable) override; |
|||
virtual void NOTCHFilter_setCenterFreqHz(float centerFreqHz) override; |
|||
virtual void NOTCHFilter_setNotchWidthHz(float notchWidthHz) override; |
|||
virtual void NOTCHFilter_setOrder(int order) override; |
|||
|
|||
virtual bool NOTCHFilter_getEnable() override; |
|||
virtual float NOTCHFilter_getCenterFreqHz() override; |
|||
virtual float NOTCHFilter_getNotchWidthHz() override; |
|||
virtual int NOTCHFilter_getOrder() override; |
|||
}; |
|||
} // namespace iflytop
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue