11 changed files with 1988 additions and 689 deletions
-
5CMakeLists.txt
-
6CMakeLists.txt.user
-
2ify_hrs_protocol
-
8libzqt/logger.cpp
-
98mainwindow.cpp
-
6mainwindow.h
-
2027mainwindow.ui
-
134src/algo/iflytop_simple_filter.cpp
-
72src/algo/iflytop_simple_filter.h
-
163src/filter_algo_mgr.cpp
-
156src/filter_algo_mgr.hpp
@ -1 +1 @@ |
|||
Subproject commit 4ed480c0ba1b2326d4465f8139ee97673f35ffa8 |
|||
Subproject commit 391a9551d21fd8b591e1eb4a5c8555ec2d59ff3c |
|||
2027
mainwindow.ui
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,134 @@ |
|||
|
|||
#include "iflytop_simple_filter.h"
|
|||
|
|||
#include <math.h>
|
|||
#include <stdint.h>
|
|||
#include <stdlib.h>
|
|||
#include <stdio.h>
|
|||
|
|||
#include "logger.hpp"
|
|||
|
|||
#define PI 3.141592653
|
|||
|
|||
/********************************************************************************************************
|
|||
* LOW PASS FILTER |
|||
********************************************************************************************************/ |
|||
|
|||
void LPFilter_Init(LPFilter_t *filter, float cutoffFreqHz, float sampleTimeS, bool enable) { |
|||
float RC = 0.0; |
|||
RC = 1.0 / (2 * PI * cutoffFreqHz); |
|||
filter->coef[0] = sampleTimeS / (sampleTimeS + RC); |
|||
filter->coef[1] = RC / (sampleTimeS + RC); |
|||
|
|||
filter->v_out[0] = 0.0; |
|||
filter->v_out[1] = 0.0; |
|||
|
|||
filter->enable = enable; |
|||
|
|||
ZLOGI("FILTER","LPFilter_Init: cutoffFreqHz=%f, sampleTimeS=%f, enable=%d", cutoffFreqHz, sampleTimeS, enable); |
|||
} |
|||
|
|||
float LPFilter_Update(LPFilter_t *filter, float v_in) { |
|||
if (filter->enable == false) return v_in; |
|||
|
|||
filter->v_out[1] = filter->v_out[0]; |
|||
filter->v_out[0] = (filter->coef[0] * v_in) + (filter->coef[1] * filter->v_out[1]); |
|||
|
|||
return (filter->v_out[0]); |
|||
} |
|||
|
|||
/********************************************************************************************************
|
|||
* HIGH PASS FILTER |
|||
********************************************************************************************************/ |
|||
void HPFilter_Init(HPFilter_t *filter, float cutoffFreqHz, float sampleTimeS, bool enable) { |
|||
float RC = 0.0; |
|||
RC = 1.0 / (2 * PI * cutoffFreqHz); |
|||
|
|||
filter->coef = RC / (sampleTimeS + RC); |
|||
|
|||
filter->v_in[0] = 0.0; |
|||
filter->v_in[1] = 0.0; |
|||
|
|||
filter->v_out[0] = 0.0; |
|||
filter->v_out[1] = 0.0; |
|||
|
|||
filter->enable = enable; |
|||
} |
|||
|
|||
float HPFilter_Update(HPFilter_t *filter, float v_in) { |
|||
if (filter->enable == false) return v_in; |
|||
|
|||
filter->v_in[1] = filter->v_in[0]; |
|||
filter->v_in[0] = v_in; |
|||
|
|||
filter->v_out[1] = filter->v_out[0]; |
|||
|
|||
filter->v_out[0] = filter->coef * (filter->v_in[0] - filter->v_in[1] + filter->v_out[1]); |
|||
|
|||
return (filter->v_out[0]); |
|||
} |
|||
|
|||
/********************************************************************************************************
|
|||
* BAND PASS FILTER |
|||
********************************************************************************************************/ |
|||
|
|||
void PBFilter_Init(PBFilter_t *filter, float HPF_cutoffFreqHz, float LPF_cutoffFreqHz, float sampleTimeS, bool enable) { |
|||
LPFilter_Init(&filter->lpf, LPF_cutoffFreqHz, sampleTimeS, enable); |
|||
HPFilter_Init(&filter->hpf, HPF_cutoffFreqHz, sampleTimeS, enable); |
|||
filter->out_in = 0.0; |
|||
filter->enable = enable; |
|||
} |
|||
|
|||
float PBFilter_Update(PBFilter_t *filter, float v_in) { |
|||
if (filter->enable == false) return v_in; |
|||
|
|||
filter->out_in = HPFilter_Update(&filter->hpf, v_in); |
|||
|
|||
filter->out_in = LPFilter_Update(&filter->lpf, filter->out_in); |
|||
|
|||
return (filter->out_in); |
|||
} |
|||
|
|||
/********************************************************************************************************
|
|||
* NOTCH FILTER |
|||
********************************************************************************************************/ |
|||
|
|||
void NOTCHFilter_Init(NOTCHFilter_t *filter, float centerFreqHz, float notchWidthHz, float sampleTimeS, bool enable) { |
|||
// filter frequency to angular (rad/s)
|
|||
float w0_rps = 2.0 * PI * centerFreqHz; |
|||
float ww_rps = 2.0 * PI * notchWidthHz; |
|||
|
|||
// pre warp center frequency
|
|||
float w0_pw_rps = (2.0 / sampleTimeS) * tanf(0.5 * w0_rps * sampleTimeS); |
|||
|
|||
// computing filter coefficients
|
|||
|
|||
filter->alpha = 4.0 + w0_rps * w0_pw_rps * sampleTimeS * sampleTimeS; |
|||
filter->beta = 2.0 * ww_rps * sampleTimeS; |
|||
|
|||
// clearing input and output buffers
|
|||
|
|||
for (uint8_t n = 0; n < 3; n++) { |
|||
filter->vin[n] = 0; |
|||
filter->vout[n] = 0; |
|||
} |
|||
filter->enable = enable; |
|||
} |
|||
|
|||
float NOTCHFilter_Update(NOTCHFilter_t *filter, float vin) { |
|||
if (filter->enable == false) return vin; |
|||
|
|||
// shifting samples
|
|||
filter->vin[2] = filter->vin[1]; |
|||
filter->vin[1] = filter->vin[0]; |
|||
|
|||
filter->vout[2] = filter->vout[1]; |
|||
filter->vout[1] = filter->vout[0]; |
|||
|
|||
filter->vin[0] = vin; |
|||
|
|||
// compute new output
|
|||
filter->vout[0] = (filter->alpha * filter->vin[0] + 2.0 * (filter->alpha - 8.0) * filter->vin[1] + filter->alpha * filter->vin[2] - (2.0f * (filter->alpha - 8.0) * filter->vout[1] + (filter->alpha - filter->beta) * filter->vout[2])) / (filter->alpha + filter->beta); |
|||
|
|||
return (filter->vout[0]); |
|||
} |
|||
@ -0,0 +1,72 @@ |
|||
#ifndef FILTERS_H |
|||
#define FILTERS_H |
|||
#include <stdbool.h> |
|||
|
|||
// #ifdef __cplusplus |
|||
// extern "C" { |
|||
// #endif |
|||
|
|||
|
|||
/******************************************************************************************************** |
|||
* LOW PASS FILTER |
|||
********************************************************************************************************/ |
|||
typedef struct { |
|||
float coef[2]; |
|||
float v_out[2]; |
|||
bool enable; |
|||
} LPFilter_t; |
|||
|
|||
void LPFilter_Init(LPFilter_t *filter, float cutoffFreqHz, float sampleTimeS, bool enable); |
|||
float LPFilter_Update(LPFilter_t *filter, float v_in); |
|||
|
|||
/******************************************************************************************************** |
|||
* HIGH PASS FILTER |
|||
********************************************************************************************************/ |
|||
typedef struct { |
|||
float coef; |
|||
float v_out[2]; |
|||
float v_in[2]; |
|||
bool enable; |
|||
|
|||
} HPFilter_t; |
|||
|
|||
void HPFilter_Init(HPFilter_t *filter, float cutoffFreqHz, float sampleTimeS, bool enable); |
|||
float HPFilter_Update(HPFilter_t *filter, float v_in); |
|||
|
|||
/******************************************************************************************************** |
|||
* BAND PASS FILTER |
|||
********************************************************************************************************/ |
|||
|
|||
typedef struct { |
|||
LPFilter_t lpf; |
|||
HPFilter_t hpf; |
|||
float out_in; |
|||
bool enable; |
|||
|
|||
} PBFilter_t; |
|||
|
|||
void PBFilter_Init(PBFilter_t *filter, float HPF_cutoffFreqHz, float LPF_cutoffFreqHz, float sampleTimeS, bool enable); |
|||
float PBFilter_Update(PBFilter_t *filter, float v_in); |
|||
|
|||
/******************************************************************************************************** |
|||
* NOTCH FILTER |
|||
********************************************************************************************************/ |
|||
|
|||
typedef struct { |
|||
float alpha; |
|||
float beta; |
|||
|
|||
float vin[3]; |
|||
float vout[3]; |
|||
bool enable; |
|||
|
|||
} NOTCHFilter_t; |
|||
|
|||
void NOTCHFilter_Init(NOTCHFilter_t *filter, float centerFreqHz, float notchWidthHz, float sampleTimeS, bool enable); |
|||
float NOTCHFilter_Update(NOTCHFilter_t *filter, float vin); |
|||
|
|||
// #ifdef __cplusplus |
|||
// } |
|||
// #endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,163 @@ |
|||
#include "filter_algo_mgr.hpp"
|
|||
|
|||
#include <mutex>
|
|||
|
|||
#include "ify_hrs_protocol/heart_rate_sensor_protocol.h"
|
|||
#include "zexception.hpp"
|
|||
|
|||
using namespace iflytop; |
|||
|
|||
void FilterGroup::initialize() {} |
|||
|
|||
int32_t FilterGroup::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 FilterGroup::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 FilterGroup::setSampleTimeMs(float sampleTimeMs) { |
|||
if (sampleTimeMs < 0.4) { |
|||
throw zexception(kifyhrs_ecode_upper_exception, "sampleTimeMs must be greater than 0.4ms"); |
|||
} |
|||
this->sampleTimeMs = sampleTimeMs; |
|||
} |
|||
float FilterGroup::getSampleTimeMs() { return sampleTimeMs; } |
|||
|
|||
void FilterGroup::LPFilter_setOrder(int order) { |
|||
if (order < 1) { |
|||
order = 1; |
|||
} |
|||
if (order > FILTER_MAX_ORDER) { |
|||
order = FILTER_MAX_ORDER; |
|||
} |
|||
lpfilter_order = order; |
|||
} |
|||
int FilterGroup::LPFilter_getOrder() { return lpfilter_order; } |
|||
void FilterGroup::HPFilter_setOrder(int order) { |
|||
if (order < 1) { |
|||
order = 1; |
|||
} |
|||
if (order > FILTER_MAX_ORDER) { |
|||
order = FILTER_MAX_ORDER; |
|||
} |
|||
hpfilter_order = order; |
|||
} |
|||
int FilterGroup::HPFilter_getOrder() { return hpfilter_order; } |
|||
void FilterGroup::NOTCHFilter_setOrder(int order) { |
|||
if (order < 1) { |
|||
order = 1; |
|||
} |
|||
if (order > FILTER_MAX_ORDER) { |
|||
order = FILTER_MAX_ORDER; |
|||
} |
|||
notchfilter_order = order; |
|||
} |
|||
int FilterGroup::NOTCHFilter_getOrder() { return notchfilter_order; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 低通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
void FilterGroup::LPFilter_setEnable(bool enable) { lpfilter_enable = enable; } |
|||
void FilterGroup::LPFilter_setCutoffFreqHz(float cutoffFreqHz) { LPFilter_cutoffFreqHz = cutoffFreqHz; } |
|||
|
|||
bool FilterGroup::LPFilter_getEnable() { return lpfilter_enable; } |
|||
float FilterGroup::LPFilter_getCutoffFreqHz() { return LPFilter_cutoffFreqHz; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 高通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void FilterGroup::HPFilter_setEnable(bool enable) { hpfilter_enable = enable; } |
|||
void FilterGroup::HPFilter_setCutoffFreqHz(float cutoffFreqHz) { HPFilter_cutoffFreqHz = cutoffFreqHz; } |
|||
|
|||
bool FilterGroup::HPFilter_getEnable() { return hpfilter_enable; } |
|||
float FilterGroup::HPFilter_getCutoffFreqHz() { return HPFilter_cutoffFreqHz; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 带阻滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void FilterGroup::NOTCHFilter_setEnable(bool enable) { notchfilter_enable = enable; } |
|||
void FilterGroup::NOTCHFilter_setCenterFreqHz(float centerFreqHz) { NOTCHFilter_centerFreqHz = centerFreqHz; } |
|||
void FilterGroup::NOTCHFilter_setNotchWidthHz(float notchWidthHz) { NOTCHFilter_notchWidthHz = notchWidthHz; } |
|||
|
|||
bool FilterGroup::NOTCHFilter_getEnable() { return notchfilter_enable; } |
|||
float FilterGroup::NOTCHFilter_getCenterFreqHz() { return NOTCHFilter_centerFreqHz; } |
|||
float FilterGroup::NOTCHFilter_getNotchWidthHz() { return NOTCHFilter_notchWidthHz; } |
|||
|
|||
/***********************************************************************************************************************
|
|||
* FilterAlgoMgr * |
|||
***********************************************************************************************************************/ |
|||
|
|||
FilterAlgoMgr* FilterAlgoMgr::ins() { |
|||
static FilterAlgoMgr ins; |
|||
return &ins; |
|||
} |
|||
|
|||
int32_t FilterAlgoMgr::processData(string channel, int32_t data) { return filter.processData(data); } |
|||
|
|||
void FilterAlgoMgr::LPFilter_setEnable(bool enable) { filter.LPFilter_setEnable(enable); } |
|||
void FilterAlgoMgr::LPFilter_setCutoffFreqHz(float cutoffFreqHz) { filter.LPFilter_setCutoffFreqHz(cutoffFreqHz); } |
|||
|
|||
bool FilterAlgoMgr::LPFilter_getEnable() { return filter.LPFilter_getEnable(); } |
|||
float FilterAlgoMgr::LPFilter_getCutoffFreqHz() { return filter.LPFilter_getCutoffFreqHz(); } |
|||
|
|||
void FilterAlgoMgr::HPFilter_setEnable(bool enable) { filter.HPFilter_setEnable(enable); } |
|||
void FilterAlgoMgr::HPFilter_setCutoffFreqHz(float cutoffFreqHz) { filter.HPFilter_setCutoffFreqHz(cutoffFreqHz); } |
|||
|
|||
bool FilterAlgoMgr::HPFilter_getEnable() { return filter.HPFilter_getEnable(); } |
|||
float FilterAlgoMgr::HPFilter_getCutoffFreqHz() { return filter.HPFilter_getCutoffFreqHz(); } |
|||
|
|||
void FilterAlgoMgr::NOTCHFilter_setEnable(bool enable) { filter.NOTCHFilter_setEnable(enable); } |
|||
void FilterAlgoMgr::NOTCHFilter_setCenterFreqHz(float centerFreqHz) { filter.NOTCHFilter_setCenterFreqHz(centerFreqHz); } |
|||
void FilterAlgoMgr::NOTCHFilter_setNotchWidthHz(float notchWidthHz) { filter.NOTCHFilter_setNotchWidthHz(notchWidthHz); } |
|||
|
|||
bool FilterAlgoMgr::NOTCHFilter_getEnable() { return filter.NOTCHFilter_getEnable(); } |
|||
float FilterAlgoMgr::NOTCHFilter_getCenterFreqHz() { return filter.NOTCHFilter_getCenterFreqHz(); } |
|||
float FilterAlgoMgr::NOTCHFilter_getNotchWidthHz() { return filter.NOTCHFilter_getNotchWidthHz(); } |
|||
|
|||
void FilterAlgoMgr::FilterCommon_setSampleTimeMs(float sampleTimeMs) { filter.setSampleTimeMs(sampleTimeMs); } |
|||
float FilterAlgoMgr::FilterCommon_getSampleTimeMs() { return filter.getSampleTimeMs(); } |
|||
|
|||
void FilterAlgoMgr::LPFilter_setOrder(int order) { filter.LPFilter_setOrder(order); } |
|||
int FilterAlgoMgr::LPFilter_getOrder() { return filter.LPFilter_getOrder(); } |
|||
void FilterAlgoMgr::HPFilter_setOrder(int order) { filter.HPFilter_setOrder(order); } |
|||
int FilterAlgoMgr::HPFilter_getOrder() { return filter.HPFilter_getOrder(); } |
|||
void FilterAlgoMgr::NOTCHFilter_setOrder(int order) { filter.NOTCHFilter_setOrder(order); } |
|||
int FilterAlgoMgr::NOTCHFilter_getOrder() { return filter.NOTCHFilter_getOrder(); } |
|||
|
|||
void FilterAlgoMgr::updateParameter() { filter.updateParameter(); } |
|||
@ -0,0 +1,156 @@ |
|||
#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"
|
|||
|
|||
namespace iflytop { |
|||
using namespace std; |
|||
#define FILTER_MAX_ORDER 10
|
|||
|
|||
class FilterGroup { |
|||
private: |
|||
LPFilter_t lpfilter[10] = {0}; |
|||
HPFilter_t hpfilter[10] = {0}; |
|||
NOTCHFilter_t notchfilter[10] = {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: |
|||
void initialize(); |
|||
|
|||
int32_t processData(int32_t data); |
|||
|
|||
void updateParameter(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 通用参数 * |
|||
***********************************************************************************************************************/ |
|||
void setSampleTimeMs(float sampleTimeMs); |
|||
float getSampleTimeMs(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 低通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
void LPFilter_setEnable(bool enable); |
|||
void LPFilter_setCutoffFreqHz(float cutoffFreqHz); |
|||
void LPFilter_setOrder(int order); |
|||
|
|||
bool LPFilter_getEnable(); |
|||
float LPFilter_getCutoffFreqHz(); |
|||
int LPFilter_getOrder(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 高通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void HPFilter_setEnable(bool enable); |
|||
void HPFilter_setCutoffFreqHz(float cutoffFreqHz); |
|||
void HPFilter_setOrder(int order); |
|||
|
|||
bool HPFilter_getEnable(); |
|||
float HPFilter_getCutoffFreqHz(); |
|||
int HPFilter_getOrder(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 带阻滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void NOTCHFilter_setEnable(bool enable); |
|||
void NOTCHFilter_setCenterFreqHz(float centerFreqHz); |
|||
void NOTCHFilter_setNotchWidthHz(float notchWidthHz); |
|||
void NOTCHFilter_setOrder(int order); |
|||
|
|||
bool NOTCHFilter_getEnable(); |
|||
float NOTCHFilter_getCenterFreqHz(); |
|||
float NOTCHFilter_getNotchWidthHz(); |
|||
int NOTCHFilter_getOrder(); |
|||
}; |
|||
|
|||
class FilterAlgoMgr { |
|||
private: |
|||
FilterGroup filter; |
|||
|
|||
public: |
|||
FilterAlgoMgr(/* args */) {} |
|||
~FilterAlgoMgr() {} |
|||
|
|||
static FilterAlgoMgr* ins(); |
|||
|
|||
int32_t processData(string channel, int32_t data); |
|||
|
|||
void updateParameter(); |
|||
|
|||
void FilterCommon_setSampleTimeMs(float sampleTimeMs); |
|||
float FilterCommon_getSampleTimeMs(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 低通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
|
|||
void LPFilter_setEnable(bool enable); |
|||
void LPFilter_setCutoffFreqHz(float cutoffFreqHz); |
|||
void LPFilter_setOrder(int order); |
|||
|
|||
bool LPFilter_getEnable(); |
|||
float LPFilter_getCutoffFreqHz(); |
|||
int LPFilter_getOrder(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 高通滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void HPFilter_setEnable(bool enable); |
|||
void HPFilter_setCutoffFreqHz(float cutoffFreqHz); |
|||
void HPFilter_setOrder(int order); |
|||
|
|||
bool HPFilter_getEnable(); |
|||
float HPFilter_getCutoffFreqHz(); |
|||
int HPFilter_getOrder(); |
|||
|
|||
/***********************************************************************************************************************
|
|||
* 带阻滤波器 * |
|||
***********************************************************************************************************************/ |
|||
void NOTCHFilter_setEnable(bool enable); |
|||
void NOTCHFilter_setCenterFreqHz(float centerFreqHz); |
|||
void NOTCHFilter_setNotchWidthHz(float notchWidthHz); |
|||
void NOTCHFilter_setOrder(int order); |
|||
|
|||
bool NOTCHFilter_getEnable(); |
|||
float NOTCHFilter_getCenterFreqHz(); |
|||
float NOTCHFilter_getNotchWidthHz(); |
|||
int NOTCHFilter_getOrder(); |
|||
}; |
|||
|
|||
} // namespace iflytop
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue