一个可变RC滤波器分析

原理图如下：

经matlab求出传递函数：

分析1：

分析2：

分析3：

limit(hs,s,0)
ans =r3/(r1 + r3)
limit(hs,s,inf)
ans =0
limit(hs,r1,0)
ans =1
limit(hs,r1,inf)
ans =(c1*r3*s)/(c1*c2*r2*r3*s^2 + (c1*r2 + c1*r3 + c2*r3)*s + 1)
limit(hs,r2,0)
ans =(r3 + c1*r1*r3*s)/(r1 + r3 + s*(c1*r1*r3 + c2*r1*r3))
limit(hs,r2,0)
ans =(c1*r3*s)/(c1*c2*r1*r3*s^2 + (c1*r1 + c1*r3)*s)
matlab求极限，备存

上述数学分析的电路原理：
当输入频率很低和很高时：

当R1过大和过小时：

当R2过大和过小时，电路解释：


经分析，这个从king5555的三段RC均衡退化成的两段RC均衡器，还是有一些缺陷。
例如R1过小时，没有限流措施，在计算机编程时，R1的下限适当提高。
没想到几个电阻电容搞死人，这只是个二阶电路。

当R1变化时，RC网络的定性分析：

当R2变化时，RC网络的定性分析：

#申请原创# 我自己写了个程序，用近似公式计算与原始传递函数比较
其中get_hs为原函数，get_hs1为r2较小时的函数，get_hs2为让较大时的函数。
python源代码：

复制

import math



def pz(r1,r2):

    return r1*r2/(r1+r2)



def sz(r1,r2):

    return r1+r2



def get_hs(r1,r2,r3,c1,c2,f):

    A=1/(pz(r1,r2)*c2)

    Z=1/(sz(r1,r2)*c1)

    SS=(1j*2*math.pi*f)*(1j*2*math.pi*f)

    B=(1/r1+1/r2+1/r3)/c2+1/(r2*c1)

    BB=1j*2*math.pi*f*B

    C=1/(pz(r1,r3)*r2*c1*c2)

    return abs(A*(1j*2*math.pi*f+Z)/(SS+BB+C))

    



def get_hs1(r1,r2,r3,c1,c2,f):

    AL=c1/(c1+c2)

    ZL=1/(r1*c1)

    PL=1/(r1*(c1+c2))

    return abs(AL*(1j*2*math.pi*f+ZL)/(1j*2*math.pi*f+PL))



def get_hs2(r1,r2,r3,c1,c2,f):

    rp=r1*r3/(r1+r3)

    AH=1/(r1*c2)

    PH=1/(rp*c2)

    return abs(AH/(1j*2*math.pi*f+PH))





def get_db(a):

    return 20*math.log10(a)

H1=get_db(get_hs1(50e3,1,47e3,10e-9,6.8e-9,1000))

H2=get_db(get_hs2(50e3,500e3,47e3,10e-9,6.8e-9,1000))

H3=get_db(get_hs(50e3,1,47e3,10e-9,6.8e-9,1000))

H4=get_db(get_hs(50e3,500e3,47e3,10e-9,6.8e-9,1000))

print("近似(R2=1,R2=500k)",H1,H2)

print("精确(R2=1,R2=500k)",H3,H4)

print("误差(R2=1,R2=500k)",abs(H1-H3),abs(H2-H4))

程序的运行结果：
当R2为1欧变成500k欧时，误差为0.46db，0.617db，误差可以接受

复制

近似(R2=1,R2=500k) -4.240219615562451 -9.45621125978194

精确(R2=1,R2=500k) -4.704943669547606 -8.838560790266058

误差(R2=1,R2=500k) 0.4647240539851545 0.6176504695158815

其中R1的情况，不在讨论。

这是计算机仿真得到结果，很接近

#有奖活动# #申请原创#  
请 @21小跑堂  批阅

今天研究3段均衡器，如原理图如下：

失败经历1：
用matlab求传递函数，代数求解失败，经检查程序，确认程序没问题，缩减4个变量，约半个小时给出传递函数。
有没有电脑强力的朋友帮忙运行一下
matlab程序如下：

复制

clear all;

clc;



syms v1 v2 v3 v4 v5 v6 vo vi C1 C2 C3 C4 R1 R2 R3 R4 RL VR0 a1 a2 a3 s



VR11=a1*VR0

VR12=(1-a1)*VR0

VR21=a2*VR0

VR22=(1-a2)*VR0

VR31=a3*VR0

VR32=(1-a3)*VR0



ZC1=1/s/C1

ZC2=1/s/C2

ZC3=1/s/C3

ZC4=1/s/C4



i01=(v1-v3)/VR11

i02=(v1-v4)/VR21

i03=(v1-v5)/VR31

i04=(v3-v2)/VR12

i05=(v4-v2)/VR22

i06=(v5-v2)/VR32

i07=(v3-v6)/R1

i08=(v4-v6)/ZC1

i09=(v5-vo)/ZC3

i10=(v6-vo)/R2

i11=v6/ZC2

i12=vo/ZC4

i13=vo/RL

i14=(vi-v1)/R3

i15=v2/R4



eq1=i14-(i01+i02+i03)

eq2=i15-(i04+i05+i06)

eq3=i01-(i04+i07)

eq4=i02-(i05+i08)

eq5=i03-(i06+i09)

eq6=(i07+i08)-(i10+i11)

eq7=(i10+i09)-(i11+i13)



S=solve(eq1,eq2,eq3,eq4,eq5,eq6,eq7,v1,v2,v3,v4,v5,v6,vo)

失败经历2：
由于不死心，转向开源代数软件maxima，下载最新版，折腾一段时间
这个更惨，内存爆满

程序文件如下：

复制

G1:1/R1;

G2:1/R2;

G3:1/R3;

G4:1/R4;

GL:1/RL;



VG11:1/(a1*VR0);

VG12:1/((1-a1)*VR0);

VG21:1/(a2*VR0);

VG22:1/((1-a2)*VR0);

VG31:1/(a3*VR0);

VG32:1/((1-a3)*VR0);



YC1:s*C1;

YC2:s*C2;

YC3:s*C3;

YC4:s*C4;



G11:G3+VG11+VG21+VG31;

G12:0;

G13:-VG11;

G14:-VG21;

G15:-VG31;

G16:0;

G17:0;



G21:G12;

G22:G4+VG12+VG22+VG32;

G23:-VG12;

G24:-VG22;

G25:-VG32;

G26:0;

G27:0;



G31:G13;

G32:G23;

G33:VG11+VG12+G1;

G34:0;

G35:0;

G36:-G1;

G37:0;



G41:G14;

G42:G24;

G43:G34;

G44:VG21+VG22+YC1;

G45:0;

G46:-YC1;

G47:0;



G51:G15;

G52:G25;

G53:G35;

G54:G45;

G55:VG31+VG32+YC3;

G56:0;

G57:-YC3;



G61:G16;

G62:G26;

G63:G36;

G64:G46;

G65:G56;

G66:G1+G2+YC1+YC2;

G67:-G2;



G71:G17;

G72:G27;

G73:G37;

G74:G47;

G75:G57;

G76:G67;

G77:G2+GL+YC3+YC4;



Y:matrix(        [G11,G12,G13,G14,G15,G16,G17],

                        [G21,G22,G23,G24,G25,G26,G27],

                        [G31,G32,G33,G34,G35,G36,G37],

                        [G41,G42,G43,G44,G45,G46,G47],

                        [G51,G52,G53,G54,G55,G56,G57],

                        [G61,G62,G63,G64,G65,G66,G67],

                        [G71,G72,G73,G74,G75,G76,G77]        );

I:matrix([vi/R3],[0],[0],[0],[0],[0],[0]);

蛋疼呀。

实在没招数，翻了翻HWM的空间，找到双T陷波器的方法，如下图：

决定采用节点电压法，不得不硬着头皮，复习了下。7x7的矩阵

1楼图的节点电流法矩阵更恐怖
第一行：

第二行：

第三行：

第四行：

第五行：

第六行：

第七行：

编写了python程序，求幅频响应，源代码如下：

复制

import math

import numpy as np



def get_output(a1,a2,a3,VR0,R1,R2,R3,R4,RL,C1,C2,C3,C4,f):

    S=1j*2*math.pi*f

    G1=1/R1

    G2=1/R2

    G3=1/R3

    G4=1/R4

    GL=1/RL

    VG11=1/(a1*VR0)

    VG12=1/((1-a1)*VR0)

    VG21=1/(a2*VR0)

    VG22=1/((1-a2)*VR0)

    VG31=1/(a3*VR0)

    VG32=1/((1-a3)*VR0)

    YC1=S*C1

    YC2=S*C2

    YC3=S*C3

    YC4=S*C4



    G11=G3+VG11+VG21+VG31

    G12=0

    G13=-VG11

    G14=-VG21

    G15=-VG31

    G16=0

    G17=0



    G21=G12

    G22=G4+VG12+VG22+VG32

    G23=-VG21

    G24=-VG22

    G25=-VG32

    G26=0

    G27=0



    G31=G13

    G32=G23

    G33=VG11+VG12+G1

    G34=0

    G35=0

    G36=-G1

    G37=0



    G41=G14

    G42=G24

    G43=G34

    G44=VG21+VG22+YC1

    G45=0

    G46=-YC1

    G47=0



    G51=G15

    G52=G25

    G53=G35

    G54=G45

    G55=VG31+VG32+YC3

    G56=0

    G57=-YC3



    G61=G16

    G62=G26

    G63=G36

    G64=G46

    G65=G56

    G66=G1+G2+YC1+YC2

    G67=-G2



    G71=G17

    G72=G27

    G73=G37

    G74=G47

    G75=G57

    G76=G67

    G77=G2+GL+YC3+YC4

        

    Y=np.matrix([[G11,G12,G13,G14,G15,G16,G17],

               [G21,G22,G23,G24,G25,G26,G27],

               [G31,G32,G33,G34,G35,G36,G37],

               [G41,G42,G43,G44,G45,G46,G47],

               [G51,G52,G53,G54,G55,G56,G57],

               [G61,G62,G63,G64,G65,G66,G67],

               [G71,G72,G73,G74,G75,G76,G77]])

    

    I=np.matrix([[1/R3],

                 [0],

                 [0],

                 [0],

                 [0],

                 [0],

                 [0]])



    out=Y.I*I   

    return out



def get_db(x):

    return 20*math.log10(x)



V1=get_output(0.15,0.15,0.15,50e3,39e3,39e3,1.5e3,220,39e3,10e-9,6.8e-9,1e-9,1.5e-9,100)

V2=get_output(0.15,0.15,0.15,50e3,39e3,39e3,1.5e3,220,39e3,10e-9,6.8e-9,1e-9,1.5e-9,100)

print(abs(V1))

print(abs(V2))

经确认，传递函数是非常长的。
计算思路，由代数分析转向数值分析。代数分析，可以找出一点规律。
由于是数值分析，计算思路，变成了计算机不断从给定的输入，不断的计算出输出响应，然后通过一定的约束条件，计算机找出符合要求的RC组合。上楼贴出的函数就是这个作用。