一阶RC高通滤波器详解（仿真+matlab+C语言实现）

文章目录

预备知识

关于电容
HPF的推导

simulink 仿真
simulink 运行结果
matlab 实现
matlab 运行结果
C语言实现

如果本文帮到了你，帮忙点个赞；

如果本文帮到了你，帮忙点个赞；

如果本文帮到了你，帮忙点个赞；

HPF 一阶RC高通滤波器详解（仿真+matlab+C语言实现）

LPF 一阶RC低通滤波器详解（仿真+matlab+C语言实现）

预备知识

高通滤波器（HPF-high pass filter）可以滤除频率低于截止频率的信号，类似的还有低通滤波器，带通滤波器，带阻滤波器。一阶RC高通滤波器的电路如下图所示；

关于电容

首先对电容的几个公式做一下补充；

电容大小CCC满足；

C=qV⋯①
C=\cfrac{q}{V} \cdots①
C=Vq⋯①

其中 qqq 是电容所带的电荷量，VVV 是电容两端的电势差；

另外，电流相当于单位时间流过导体的电荷量；因此电流 iii 满足；

i=dqdt⋯② i = \cfrac{dq}{dt}\cdots②i=dtdq⋯②

根据①，②可以得到电容大小 CCC 和电容的电流 iii 以及两端电压 VVV 的关系；

i(t)=Cdv(t)dti(t) = C\cfrac{dv(t)}{dt}i(t)=Cdtdv(t)

HPF的推导

由以上电路可知，假设电流为 i(t)i(t)i(t)，则可知

{Vout=Ri(t)⋯③i(t)=CdQc(t)dt⋯④
\begin{cases}
V_{out} = Ri(t) \cdots③ \\
i(t) = C\cfrac{dQ_c(t)}{dt} \cdots④\\
\end{cases}
⎩⎨⎧Vout=Ri(t)⋯③i(t)=CdtdQc(t)⋯④

电容两端的电压为 Vc(t)V_c(t)Vc(t) 根据基尔霍夫定律，满足；

−Vin+VC+Vout=0-V_{in} + V_C + V_{out} = 0−Vin+VC+Vout=0

所以结合①，③，④可以得到；

Qc(t)=C(Vin(t)−Vout(t))⋯⑤Q_c(t) = C( V_{in}(t) - V_{out}(t)) \cdots ⑤Qc(t)=C(Vin(t)−Vout(t))⋯⑤

根据 ③，④，⑤ 可以得到以下关系；

Vout=C(dVindt−dVoutdt)⏞I(t)R=RC(dVindt−dVoutdt)⋯⑥
V_{out} = \overbrace{ C( \cfrac{dV_{in}}{dt} - \cfrac{dV_{out}}{dt}) }^{I(t)} R = RC(\cfrac{dV_{in}}{dt} - \cfrac{dV_{out}}{dt}) \cdots ⑥
Vout=C(dtdVin−dtdVout)I(t)R=RC(dtdVin−dtdVout)⋯⑥

将方程进行离散化，如果输入VinV_{in}Vin和输出输入VoutV_{out}Vout按照 △T\bigtriangleup_{T}△T的时间采样，那么可以将输入和输出序列化，则

VinV_{in}Vin序列化为：

(x1,x2,x3⋯ ,xn−1,xn)(x_{1},x_{2},x_{3}\cdots,x_{n-1},x_{n})(x1,x2,x3⋯,xn−1,xn)

VoutV_{out}Vout序列化为：

(y1,y2,y3⋯ ,yn−1,yn)(y_{1},y_{2},y_{3}\cdots,y_{n-1},y_{n})(y1,y2,y3⋯,yn−1,yn)

根据⑥式可以进行离散化，因此最终滤波输出的序列 yiy_{i}yi 如下所示；

yi=RC(xi−xi−1△T−yi−yi−1△T)⋯⑦
y_{i} = RC(\cfrac{x_{i}-x_{i-1}}{\bigtriangleup_{T}} -\cfrac{y_{i}-y_{i-1}}{\bigtriangleup_{T}} )\cdots⑦
yi=RC(△Txi−xi−1−△Tyi−yi−1)⋯⑦

将⑦再进一步简化得到；

yi=αyi−1+α(xi−xi−1)
y_{i} = \alpha y_{i-1} + \alpha(x_i - x_{i-1})
yi=αyi−1+α(xi−xi−1)

其中 α=RCRC+△T\alpha = \cfrac{RC}{RC+\bigtriangleup_{T}}α=RC+△TRC

所以换成得到；

RC=△T(α1−α)⋯⑧RC = \bigtriangleup_{T}(\cfrac{\alpha}{1-\alpha}) \cdots⑧RC=△T(1−αα)⋯⑧

另外截止频率和低通滤波器的相同；

fc=12πRCf_c = \cfrac{1}{2\pi RC}fc=2πRC1

将⑧式代入可以得到截止频率和 α\alphaα 的关系；

fc=1−α2πα△Tf_c = \cfrac{1-\alpha}{2\pi \alpha \bigtriangleup_{T}}fc=2πα△T1−α

这个公式便于简化后面程序以及截止频率的计算。

simulink 仿真

这里根据公式⑥构建simulink的子模块subsystem；

Vout=RC(dVindt−dVoutdt)
V_{out} = RC(\cfrac{dV_{in}}{dt} - \cfrac{dV_{out}}{dt})
Vout=RC(dtdVin−dtdVout)

具体如下所示；

整体的仿真如下图所示；

其中Sine Wave频率设置为2*pi*40，频率为40赫兹;

其中Sine Wave1频率设置为2*pi*4，频率为4赫兹;

所以这里需要使得2*pi*4的信号衰减，所以根据，截止频率 fcf_cfc 的计算公式，可以改变增益的值，具体如下所示；

这里RC增益为0.005，因此

fc=12πRC=12π∗0.005≈31.8f_c = \cfrac{1}{2\pi RC} = \cfrac{1}{2\pi *0.005} \approx 31.8fc=2πRC1=2π∗0.0051≈31.8

simulink 运行结果

matlab 实现

matlab根据以下这个公式进行数字滤波器的设计；

yi=αyi−1+α(xi−xi−1)
y_{i} = \alpha y_{i-1} + \alpha(x_i - x_{i-1})
yi=αyi−1+α(xi−xi−1)

另外 α\alphaα 的值如何确定需要参考⑧式；

Serial = 0:0.1:100;

Fs = 1;

Phase = 0;

Amp = 1;

N0 = 2*pi*Fs*Serial - Phase;

X0 = Amp*sin(N0);

subplot(4,1,1);

plot(X0);

Fs = 0.02;

N1 = 2*pi*Fs*Serial - Phase;

X1 = Amp*sin(N1);

subplot(4,1,2);

plot(X1);

X2=X0+X1;

subplot(4,1,3);

plot(X2);

len = length(X2);

X3=X2;

p=0.75;

for i=2:len

    X3(i) = p*X3(i-1)+p*(X2(i)- X2(i-1))

end

subplot(4,1,4);

plot(X3);

简单地分析一下，代码中的X1，X2，X3；

X1频率为1
X2频率为0.02

{α=p=0.75△T=0.1fc=1−α2πα△T \begin{cases}
\alpha = p=0.75 \\
\bigtriangleup_{T} = 0.1 \\
f_c = \cfrac{1-\alpha}{2\pi \alpha \bigtriangleup_{T}} \end{cases}⎩⎪⎪⎪⎨⎪⎪⎪⎧α=p=0.75△T=0.1fc=2πα△T1−α

因此可以得到截止频率如下；

fc=0.252π∗0.75∗0.1≈0.53f_c=\cfrac{0.25}{2\pi *0.75* 0.1} \approx 0.53fc=2π∗0.75∗0.10.25≈0.53

matlab 运行结果

C语言实现

typedef struct

{

     int16_t  Input[2];

     int16_t  Output[2];

     int32_t  FilterTf;

     int32_t  FilterTs;

     int32_t  Ky;

} high_filter;

void high_filter_init(high_filter *v);

int16_t high_filter_calc(high_filter *v);

其中；

FilterTs为采样时间 △T\bigtriangleup_{T}△T；
FilterTf为RC时间常数；
Input[0]表示 xix_ixi；
Input[1]表示 xi−1x_{i-1}xi−1；
Output[0]表示 yiy_iyi；
Output[1]表示 yi−1y_{i-1}yi−1；
Ky表示RCRC+△T\cfrac{RC}{RC+\bigtriangleup_{T}}RC+△TRC；

参考公式如下所示；

void high_filter_init(high_filter *v){

     v->Ky = v->FilterTf*1024/(v->FilterTs + v->FilterTf);

}

int16_t high_filter_calc(high_filter *v){

	int32_t tmp = 0;

	tmp = ((int32_t)v->Ky*v->Output[1] + v->Ky*(v->Input[0] - v->Input[1]))/1024;

	if(tmp>32767){

		tmp = 32767;

	}

	if( tmp < -32768){

		tmp = -32768;

	}

    v->Output[0] = (int16_t)tmp;

    v->Output[1] = v->Output[0];

    v->Input[1] = v->Input[0];

	return v->Output[0];

}