Design of an A frequency weighting circuit

Question

I started by doing what is described in the image below.

Some simple calculations were made and I obtained these capacitance values:

The values I placed for the resistors were at random.

Then implemented this in LTspice:

Igot this response:

The ideal response should look like this:

For example, at 1000Hz it is -15dB when it should be 0dB.

Do you guys have any idea how to fix this?

I also have no idea how can we go from the transfer function to the circuit shown in the first picture I placed here. In the document I found (that has figure 2.5) there's no mention about that, and I can't seem to find anything about it in other places.

Answer 1

Try adding buffers between stages, especially those stages that are duplicates. This plot uses your calculated values, but a gain-of-one buffer (high input impedance, zero output impedance) inserted between each RC stage:

You could use unity-gain op amps for each buffer.

Answer 2

While the other answers suggesting the use of buffers between each stage are correct, this increases the cost and power consumption of the circuit (which may or may not be relevant in your case).

If that is a concern, you can design 2-stage active filters, using e.g. the techniques from this document. With this, you could do with 2 amp ops for the first part (2 LP + 2 HP), 1 amp op for the A-weighing part, and possibly no amp ops for the B-weighing part if you don't need to match impedances for the output. Although, if you use an IC with 4 amp ops and are not too concerned about power consumption, you could put the spare 4th amp op to use by making an active filter for the B-weighing part, which IIRC is just an RC followed by an unity gain buffer for a first-order filter such as this.

If you really need to cut on cost/power consumption, you could design a 4-stage passive filter for the first part, followed by an unity gain buffer, and use passive filters for the A-weighing and B-weighing parts (assuming impedance matching is not an issue). Note that, as mentioned in the answer by @Mattman944, the first-order RC filter equation is not applicable here. You'll need to use the methods outlined in the document I linked above.

Answer 3

The equations that you are using for RC filters are only valid if the source impedance is zero and the load impedance is infinite. When you cascade simple filters, this is not true, the filters are interacting with each other.

You need to use active filters, or add buffers after each stage.

Answer 4

This is a corollary to the other answers, just in case you're wondering why you can't use unbuffered RC sections.

An RC filter, by itself, is a 1st order system. When buffered 1st order stages are added (all the same, for simplicity), it is possible to make a filter whose transfer function is:

$$H(s)^N=\left(\dfrac{\dfrac{1}{RC}}{s+\dfrac{1}{RC}}\right)^N=\dfrac{1}{(sRC+1)^N} \tag{1}\label{1}$$

Suppose only two sections are considered. Then, the transfer function will be a 2nd order whose \$Q=0.5\$ and you will never be able to exceed it. For \$R=1,\;C=1\$:

$$H(s)^2=\dfrac{1}{(s+1)^2}=\dfrac{1}{s^2+2s+1} \tag{2}\label{2}$$

For an unbuffered 2nd order filter, the transfer function will be (you can derive this however you wish):

$$G(s)=\dfrac{1}{s^2+3s+1} \tag{3}\label{3}$$

Here \$Q=0.33\$ and it will never go above this. This is why your attempt at "gluing" RC sections would never be able to achieve an active filter's response -- it will never have a high enough \$Q\$. It's also the reason why you see the filters represented as triangles in the 1st picture: they are meant to be active filters. Also, there's a matter of gain, since your last picture shows a slight gain at the peak. You might be able to achieve peaking with RC filters, but its not a practical solution. A pure passive RC network will always have attenuation due to the finite impedances of the input and output.

Also, see @swineone's answer for a way to optimize the overall filter.

Answer 5

• C5 & C6 are using a comma (",") for the decimal point.
• You need to place buffers between each filter stage as stages before and after each stage are influencing the response of the individual stages.

[Edit]
Regarding the use of comma as the decimal point in LTspice:
My operating system is set up to use a 'period' as the decimal point. LTspice gives different results depending on the use of a 'period' or 'comma' for the decimal point on my computer as seen in the simulation below.