Learn more about Signal Processing Toolbox

fdesign - Filter specification object

Syntax

d = fdesign.response d = fdesign.response(spec) d = fdesign.response(...,fs) d = fdesign.response(...,magunits)

Description

Filter Specification Objects

d = fdesign.response returns a filter specification object d, of filter response response. To create filters from d, use one of the design methods listed in Designing a Filter in Fdesign — Process Overview

Here is how you design filters using fdesign.

Use fdesign.response to construct a filter specification object.
Use designmethods to determine which filter design methods work for your new filter specification object.
Use design to apply your filter design method from step 2 to your filter specification object to construct a filter object.
Use FVTool to inspect and analyze your filter object.

Note fdesign does not create filters. fdesign returns a filter specification object that contains the specifications for a filter, such as the passband cutoff or attenuation in the stopband. To design a filter hd from a filter specification object d, use d with a filter design method such as butter —hd = design(d,'butter').

For more guidance about using fdesign, refer to the examples in Designing a Filter in Fdesign — Process Overview. Alternatively, type the following at the MATLAB prompt for more information:

help fdesign

response can be one of the entries in the following table that specify the filter response desired, such as a bandstop filter or an interpolator.

fdesign Response String	Description
`arbmag`	`fdesign.arbmag` creates an object to specify IIR filters that have arbitrary magnitude responses defined by the input arguments.
`bandpass`	`fdesign.bandpass` creates an object to specify bandpass filters.
`bandstop`	`fdesign.bandstop` creates an object to specify bandstop filters.
`differentiator`	`fdesign.differentiator` creates an object to specify differentiators.
`highpass`	`fdesign.highpass` creates an object to specify highpass filters.
`hilbert`	`fdesign.hilbert` creates an object to specify Hilbert filters.
`lowpass`	`fdesign.lowpass` creates an object to specify lowpass filters.
`pulseshaping`	`fdesign.pulseshaping` creates an object to specify pulse-shaping filters.

Use the doc fdesign.response syntax at the MATLAB prompt to get help on a specific structure. Using doc in a syntax like

doc fdesign.lowpass
doc fdesign.bandstop

gets more information about the lowpass or bandstop structure objects.

Each response has a property Specification that defines the specifications to use to design your filter. You can use defaults or specify the Specification property when you construct the specifications object.

With the strings for the Specification property, you provide filter constraints such as the filter order or the passband attenuation to use when you construct your filter from the specification object.

Properties

fdesign returns a filter specification object. Every filter specification object has the following properties.

Property Name	Default Value	Description
`Response`	Depends on the chosen type	Defines the type of filter to design, such as an interpolator or bandpass filter. This is a read-only value.
`Specification`	Depends on the chosen type	Defines the filter characteristics used to define the desired filter performance, such as the cutoff frequency `Fstop` or the filter order `N`.
`Description`	Depends on the filter type you choose	Contains descriptions of the filter specifications used to define the object, and the filter specifications you use when you create a filter from the object. This is a read-only value.
`NormalizedFrequency`	Logical `true`	Determines whether the filter calculation uses normalized frequency from 0 to 1, or the frequency band from 0 to Fs/2, the sampling frequency. Accepts either `true` or `false` without single quotation marks.

d = fdesign.response(spec). In spec, you specify the variables to use that define your filter design, such as the passband frequency or the stopband attenuation. These variables are applied to the filter design method you choose to design your filter.

For example, when you create a default lowpass filter specification object d, fdesign sets the passband frequency Fpass, the stopband frequency Fstop, the stopband attenuation Astop, and the passband attenuation Apass (ripple in the passband) for d:

d = fdesign.lowpass
 
d =
 
               Response: 'Lowpass'      
          Specification: 'Fp,Fst,Ap,Ast'
            Description: {4x1 cell}     
    NormalizedFrequency: true           
                  Fpass: 0.45           
                  Fstop: 0.55           
                  Apass: 1              
                  Astop: 60

However, lowpass design syntax accepts any one of the following Spec strings (among others) to define the filter response:

Spec String	Description
`Fp,Fst,Ap,Ast`	Define the filter by specifying the passband cutoff, the stopband cutoff, the ripple in the passband, and the attenuation in the stopband. This is the default string for a lowpass filter.
`N,Fc`	Set the filter order and the cutoff frequency to define the filter.
`N,Fp,Ap`	Set the filter order, passband cutoff frequency, and passband ripple.
`N,Fst,Ast`	Define the filter by setting the order, stopband frequency, and stopband attenuation.
`N,Fp,Ap,Ast`	Set the order, passband cutoff frequency, passband ripple, and stopband attenuation.
`N,Fp,Fst,Ap`	Set the filter order, passband cutoff frequency, stopband frequency, and passband ripple.

Other filter object types, such as Nyquist or highpass, accept a different set of strings for Spec. Refer to the Help system for details about the strings for each filter type.

One important note is that the Spec string you choose controls which design method works for the specifications object.

For the lowpass filter specification object d from earlier, you can use butter, cheby1, cheby2, or equiripple (to name a few) to design a filter. However, if the Spec string had been 'n,fp,fst,ap', you could only use the ellip design method to design your filter.

When you implement this lowpass filter hd using a filter design method such as Butterworth (the butter design function), the constraints in fp, fst, ap, and ast (the default string and filter specification) define the response of the final minimum-order lowpass filter:

hd = design(d,'butter')
 
hd =
 
         FilterStructure: 'Direct-Form II, Second-Order Sections'
              Arithmetic: 'double'                               
               sosMatrix: [13x6 double]                          
             ScaleValues: [14x1 double]                          
        PersistentMemory: false

FVTool shows that hd is a lowpass filter that meets the design specification.

d = fdesign.response(...,fs) adds the argument fs, specified in Hz to define the sampling frequency to use. In this case, all frequencies in the specifications are in Hz as well.

d = fdesign.response(...,magunits) specifies the units for any magnitude specification you provide in the input arguments. magunits can be one of

linear — specify the magnitude in linear units
dB — specify the magnitude in decibels
squared — specify the magnitude in power units

When you omit the magunits argument, fdesign assumes that all magnitudes are in decibels. Note that fdesign stores all magnitude specifications in decibels (converting to decibels when necessary) regardless of how you specify the magnitudes.

Using Filter Design Methods with Specification Objects

After you create a filter specification object, you use a filter design method to implement your filter with a selected algorithm. The following methods are available for filter specification objects, but all methods do not apply to all object types. Also, the specification string you use to define the object changes the algorithms available to design a filter. Enter doc butter, for example, to get more information about using the Butterworth design method with your filter specification object.

Design Function	Description
`butter`	Implement a Butterworth filter resulting in an SOS filter with direct-form II structure
`cheby1`	Implement a Chebyshev Type I filter, resulting in a direct-form II second-order filter
`cheby2`	Implement a Chebyshev Type II filter, resulting in an SOS filter with direct-form II structure
`ellip`	Implement an elliptic filter resulting in an SOS filter with direct-form II structure
`equiripple`	Implement an equiripple filter
`firls`	Implement a least-squares filter
`kaiserwin`	Implement a filter that uses a Kaiser window

When you use any of the design methods without providing an output argument, the resulting filter design appears in FVTool by default.

Along with filter design methods, fdesign works with supporting methods that help you create filter specification objects or determine which design methods work for a given specifications object.

Supporting Function	Description
`designmethods`	Return the design methods.
`designopts`	Return the input arguments and default values that apply to a specifications object and method

You can set filter specification values by passing them after the Specification argument, or by passing the values without the Specification string.

When the first input to fdesign is not a valid Specification string like 'n,fc', fdesign assumes that the input argument is a filter specification and applies it using the default Specification string —fp,fst,ap,ast for a lowpass object, for example.

Examples

The following examples require only the Signal Processing Toolbox.

Example 1–Bandstop Filter

A bandstop filter specification object for data sampled at 8,000 Hertz. The stopband between 2000 and 2400 Hertz is attenuated at least 80 dB.

d = fdesign.bandstop('Fp1,Fst1,Fst2,Fp2,Ap1,Ast,Ap2',...
           1600,2000,2400,2800,1,80,1,8000);

Example 2–Lowpass Filter

A lowpass filter specification object for data sampled at 10,000 Hertz. The passband frequency is 500 Hz and the stopband frequency is 750 Hz. The passband ripple is set to 1 dB and the required attenuation in the stopband is 80 dB.

d=fdesign.lowpass('Fp,Fst,Ap,Ast',500,750,1,80,10000);

Example 3–Highpass Filter

A default highpass filter specification object.

d=fdesign.highpass % Creates specifications object.
 
d =
 
               Response: 'Minimum-order highpass'
      Specification    : 'Fst,Fp,Ast,Ap'
            Description: {4x1 cell}
    NormalizedFrequency: true
                     Fs: 'Normalized'
                  Fstop: 0.4500
                  Fpass: 0.5500
                  Astop: 60
                  Apass: 1

d.Description

ans = 

    'Stopband Frequency'
    'Passband Frequency'
    'Stopband Attenuation (dB)'
    'Passband Ripple (dB)'

Notice the correspondence between the properties Specification and Description — in Description you see in words the definitions of the variables shown in Specification.

Example 4–Filter Specification and Design

Lowpass Butterworth filter specification object

Use a filter specification object to construct a lowpass Butterworth filter with default Specification fp,fst,ap,ast — the edge frequencies of the passband and stopband, the attenuation in the passband, and the attenuation in the stopband. Start by creating the specifications object d and providing the filter order and cutoff frequency values.

d = fdesign.lowpass(0.4,0.5,1,80);

Determine which design methods apply to d. With only the Signal Processing Toolbox installed, you can choose among the following algorithms:

>>designmethods(d)


Design Methods for class fdesign.lowpass:


butter
cheby1
cheby2
ellip

With the Filter Design Toolbox installed, you have additional algorithms available.

>>designmethods(d)

Design Methods for class fdesign.lowpass (Fp,Fst,Ap,Ast):

butter
cheby1
cheby2
ellip
equiripple
ifir
kaiserwin
multistage

You can use d and the butter design method to design a Butterworth filter.

hd = design(d,'butter','matchexactly','passband'); 
fvtool(hd);

The resulting filter magnitude response shown by FVTool appears in the following figure.

If you had a default Nyquist filter specification object d

d = fdesign.nyquist

you could find out which design methods apply to d by entering

designmethods(d)


Design methods for class fdesign.nyquist:


kaiserwin