# filter design for a bandpass noise shaper

Started by June 2, 2004
```Is there a simple way to design noise-shaping filters using (for
instance) the tools in the MATLAB Filter Design or Signal Processing
libraries? I would like to design a short FIR band-stop filter under
the constaint that its zeroth-order (i.e. leading) coefficient is
unity. This is because the noise transfer function has the general
form:

G(z) = 1 - z^-1 * H(z),

where H(z) is causal. So if I can design the noise transfer function
G(z) with the unity-coefficient constraint, then it will be easy to
pick out H(z), which is the noise-shaping filter that goes in the
feedback loop.

I'd also like to constrain |G| < 1.6 per Lee's rule of thumb for
stability.

What distinguishes my problem from the usual noise-shaping situation
is:

1) It's not one-bit. I want to feed back the low-order bits of an
extended-length accumulator, because my data memory is only 16 bits
wide.

2) I'm building a bandpass system.

3) I'm doing it in a DSP, so I can easily handle "interesting"
coefficient sets, and don't have to stick to moving averages and the
like.

4) My center frequency isn't at fs/4, so the well-known trick of
mapping
z -> -z^2 isn't ideal. The more general transformation,
z -> -z(z + a)/(az +1)
ends up generating an IIR filter, which I'd prefer to avoid. (Limited
precision is why I'm in this mess to begin with...)

Still, I don't think what I'm doing is _that_ much out of the
ordinary, and surely someone has invented a good algorithm for
optimizing the filter design.

Any suggestions?

David L. Rick
Hach Company
```
```drick@hach.com (David L. Rick) writes:

> Is there a simple way to design noise-shaping filters using (for
> instance) the tools in the MATLAB Filter Design or Signal Processing
> libraries? I would like to design a short FIR band-stop filter under
> the constaint that its zeroth-order (i.e. leading) coefficient is
> unity. This is because the noise transfer function has the general
> form:
>
> G(z) = 1 - z^-1 * H(z),
>
> where H(z) is causal. So if I can design the noise transfer function
> G(z) with the unity-coefficient constraint, then it will be easy to
> pick out H(z), which is the noise-shaping filter that goes in the
> feedback loop.

Hi David,

If

G(z) = 1 - z^-1 * H(z),

then

H(z) = z * (1 - G(z)),

so in order to ensure H(z) is causal you only have to ensure
G(z) is causal with g_0 = 1. So I would say just design your
G(z) using whatever method you want (assuming it gives you a
causal FIR that depends on the current input, i.e., that contains
a g_0 term) and then scale the whole filter by g_0.

This has the effect of changing the noise transfer function gain.
Obviously is g_0 is less than one, the NTF gets boosted, which
may mitigate any advantages you gained in the first place with
the constrained filter design.

From what I've seen, most folks design these filters analytically,
i.e., by choosing the order and where they want the zeros on the
z-plane.

Good luck!
--
%  Randy Yates                  % "Ticket to the moon, flight leaves here today
%% Fuquay-Varina, NC            %  from Satellite 2"
%%% 919-577-9882                % 'Ticket To The Moon'
%%%% <yates@ieee.org>           % *Time*, Electric Light Orchestra
```
```Hi David,

you might want to give FIWIZ a try
(www.icsi.berkeley.edu/~storn/fiwiz.html)

Regards

Rainer

"David L. Rick" <drick@hach.com> schrieb im Newsbeitrag
> Is there a simple way to design noise-shaping filters using (for
> instance) the tools in the MATLAB Filter Design or Signal Processing
> libraries? I would like to design a short FIR band-stop filter under
> the constaint that its zeroth-order (i.e. leading) coefficient is
> unity. This is because the noise transfer function has the general
> form:
>
> G(z) = 1 - z^-1 * H(z),
>
> where H(z) is causal. So if I can design the noise transfer function
> G(z) with the unity-coefficient constraint, then it will be easy to
> pick out H(z), which is the noise-shaping filter that goes in the
> feedback loop.
>
> I'd also like to constrain |G| < 1.6 per Lee's rule of thumb for
> stability.
>
> What distinguishes my problem from the usual noise-shaping situation
> is:
>
> 1) It's not one-bit. I want to feed back the low-order bits of an
> extended-length accumulator, because my data memory is only 16 bits
> wide.
>
> 2) I'm building a bandpass system.
>
> 3) I'm doing it in a DSP, so I can easily handle "interesting"
> coefficient sets, and don't have to stick to moving averages and the
> like.
>
> 4) My center frequency isn't at fs/4, so the well-known trick of
> mapping
> z -> -z^2 isn't ideal. The more general transformation,
> z -> -z(z + a)/(az +1)
> ends up generating an IIR filter, which I'd prefer to avoid. (Limited
> precision is why I'm in this mess to begin with...)
>
> Still, I don't think what I'm doing is _that_ much out of the
> ordinary, and surely someone has invented a good algorithm for
> optimizing the filter design.
>
> Any suggestions?
>
> David L. Rick
> Hach Company

```