dsp.DDC

R2026b

Digital downconverter

Since R2026b

Description

The dsp.DDC System object™ mixes a digital input signal with an oscillator and filters the result using a user-defined multirate filter cascade. Use this object to translate a signal from an intermediate frequency (IF) band to baseband and decimate it.

You specify the filter cascade directly or use the designDDC function to generate a CIC-based filter design and populate the object.

Use filterAnalyzer to visualize the frequency response of the filter cascade.

To digitally downconvert the input signal:

1. Create the dsp.DDC object and set its properties.

2. Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?

Creation

Syntax

ddc = dsp.DDC

ddc = dsp.DDC(PropertyName=Value)

Description

You can create a dsp.DDC System object in one of these ways:

• Use the designDDC function, which automatically designs a CIC-based multirate filter cascade from decimation factors and sample rate specifications. For example:

  ddc = designDDC(DecimationFactors=[50 2],InputSampleRate=1e6)

• Use the dsp.DDC creation function, described here.

ddc = dsp.DDC creates a digital downconverter System object with default property values.

ddc = dsp.DDC(PropertyName=Value) creates a digital downconverter with properties set using one or more name-value arguments. For example, dsp.DDC(Filter=dsp.FIRDecimator(10),InputSampleRate=1e6) creates a DDC object with a FIR decimation filter and input sample rate of 1 MHz.

Properties

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the release function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

NormalizedFrequency — Option to use normalized frequency

true (default) | false

Option to use normalized frequency, specified as true or false. When this property is true, frequency values are expressed in units of radians per sample. When this property is false, frequency values are expressed in hertz and the InputSampleRate property is active.

Set this property at construction time using the InputSampleRate constructor argument. Specify InputSampleRate="normalized" to set this property to true, or specify a positive scalar value to set it to false.

To change the sample rate after construction, use the setInputSampleRate object function.

Data Types: logical

InputSampleRate — Input sample rate in hertz

1 (default) | positive scalar

Input sample rate, specified as a positive finite scalar in hertz.

At construction time, the InputSampleRate argument accepts:

• A positive scalar — Sets the input sample rate to the specified value and sets NormalizedFrequency to false.

• "normalized" — Sets NormalizedFrequency to true.

• "auto" — Inherits the sample rate from the filter specified in the Filter property.

Setting this property directly does not scale CenterFrequency. To update the sample rate and scale CenterFrequency proportionally, use the setInputSampleRate object function instead.

Dependencies

To enable this property, set NormalizedFrequency to false.

Data Types: double

Oscillator — Oscillator type

"Sine wave" (default) | "NCO"

Type of oscillator used for frequency translation, specified as one of these values:

• "Sine wave" — Use a sinusoidal oscillator for mixing.

• "NCO" — Use a numerically controlled oscillator for mixing. When you set this property to "NCO", additional NCO configuration properties become active.

Data Types: string

CenterFrequency — Center frequency of the oscillator

real finite scalar

Center frequency of the oscillator used for mixing, specified as a real finite scalar. The units depend on the value of the NormalizedFrequency property. When NormalizedFrequency is true, the center frequency is in normalized units. When NormalizedFrequency is false, the center frequency is in hertz.

If you do not specify CenterFrequency, the software computes the center frequency from the sample rate.

The value of the center frequency must be less than or equal to half the input sample rate.

Data Types: double

Filter — Multirate filter cascade

filter System object that supports filter analysis

Multirate filter or filter cascade used for decimation, specified as a filter System object that supports filter analysis. You can specify a single filter object or a dsp.FilterCascade object containing multiple filter stages. The cascade supports CIC filters, FIR filters, Farrow rate converters, and custom filters. By default, the filter is dsp.FIRDecimator(4).

Use the designDDC function to design a multistage CIC-based decimation cascade suitable for this property.

You can tune individual filter stage parameters, such as coefficients, after construction. For example, you can modify the Numerator property of a dsp.FIRDecimator stage within the cascade.

You cannot replace the filter object after the object is locked.

NumAccumulatorBits — Number of accumulator bits in NCO

16 (default) | positive integer

Number of accumulator bits in the NCO, specified as a positive integer.

Dependencies

To enable this property, set Oscillator to "NCO".

Data Types: double

NumQuantizedAccumulatorBits — Number of quantized accumulator bits in NCO

12 (default) | positive integer

Number of quantized accumulator bits in the NCO, specified as a positive integer.

Dependencies

To enable this property, set Oscillator to "NCO".

Data Types: double

Dither — Option to enable NCO dithering

true (default) | false

Option to enable dithering in the NCO, specified as true or false.

Dependencies

To enable this property, set Oscillator to "NCO".

Data Types: logical

NumDitherBits — Number of dither bits in NCO

4 (default) | positive integer

Number of dither bits in the NCO, specified as a positive integer.

Dependencies

To enable this property, set Oscillator to "NCO" and Dither to true.

Data Types: double

MixerDataType — Data type of mixer output

"Same as input" (default) | numerictype object

Data type of the mixer output, specified as "Same as input" or a numerictype object. When you set this property to "Same as input", the mixer output data type is the same as the input data type.

Usage

Syntax

y = ddc(x)

Description

y = ddc(x) mixes the input signal x with the oscillator and filters the result using the filter cascade specified in the Filter property. The object multiplies the input by the conjugate of the complex exponential generated by the oscillator, and then passes the mixed signal through the decimation filter.

Input Arguments

x — Input signal

column vector | matrix

Input signal, specified as a column vector or matrix. Each column is treated as an independent channel. The number of input rows times the interpolation factor L must be an integer multiple of the decimation factor M, where [L:M] is the overall rate conversion ratio of the filter cascade. For pure-decimation cascades (L=1), this simplifies to the number of rows being a multiple of M.

Data Types: single | double | fi
Complex Number Support: Yes

Output Arguments

y — Downconverted and decimated signal

column vector | matrix

Downconverted and decimated output signal, returned as a column vector or matrix. The number of rows equals the number of input rows divided by the overall decimation factor. The output is complex-valued.

Data Types: single | double | fi
Complex Number Support: Yes

Object Functions

To use an object function, specify the System object as the first input argument. For example, to release system resources of a System object named obj, use this syntax:

release(obj)

Specific to dsp.DDC

setInputSampleRate	Specify input sample rate in filter objects
addFilterStage	Add filter stage to digital converter cascade
info	Information about filter System object

Common to All System Objects

step	Run System object algorithm
release	Release resources and allow changes to System object property values and input characteristics
reset	Reset internal states of System object

Examples

Create a DDC with a Custom Filter Cascade

Create a dsp.DDC object with a custom multirate filter cascade and inspect the design.

Create individual filter stages for a 3-stage DDC: a dsp.CICDecimator object with gain normalization, a CIC compensator dsp.FIRDecimator object, and an auxiliary dsp.FIRDecimator object.

cicFilt = dsp.CICDecimator(DecimationFactor=10,NumSections=4);
compFilt = dsp.FIRDecimator(2,fir1(31,0.4));
auxFilt = dsp.FIRDecimator(2,fir1(15,0.8));

Combine the stages into a filter cascade and create the dsp.DDC object.

F = cascade(cicFilt,1/cicFilt.gain(),compFilt,auxFilt);
ddc = dsp.DDC(Filter=F,InputSampleRate=1e6,CenterFrequency=100e3);

Display design information and visualize the filter response.

info(ddc)

ans = 
    'Digital Down Converter
     ----------------------------
     Input sample rate                    : 1 MHz
     Oscillator type                      : Sine wave
     Oscillator center frequency          : 100 kHz
     
     ----------------------------------------------------
     Filter type           : dsp.FilterCascade
     Rate conversion ratio : 1:40
     
     Discrete-Time Filter Cascade                            
     ----------------------------                            
     Number of stages: 4                                     
     Stage cloning: enabled                                  
     ----------------------------                            
     Stage1: dsp.CICDecimator                                
     -------                                                 
     Discrete-Time FIR Multirate Filter (real)               
     -----------------------------------------               
     Filter Structure    : Cascaded Integrator-Comb Decimator
     Decimation Factor   : 10                                
     Differential Delay  : 1                                 
     Number of Sections  : 4                                 
     Stable              : Yes                               
     Linear Phase        : Yes (Type 1)                      
                                                             
     Stage2: double                                          
     -------                                                 
     Stage3: dsp.FIRDecimator                                
     -------                                                 
     Discrete-Time FIR Multirate Filter (real)               
     -----------------------------------------               
     Filter Structure   : Direct-Form FIR Polyphase Decimator
     Decimation Factor  : 2                                  
     Polyphase Length   : 16                                 
     Filter Length      : 32                                 
     Stable             : Yes                                
     Linear Phase       : Yes (Type 2)                       
                                                             
     Stage4: dsp.FIRDecimator                                
     -------                                                 
     Discrete-Time FIR Multirate Filter (real)               
     -----------------------------------------               
     Filter Structure   : Direct-Form FIR Polyphase Decimator
     Decimation Factor  : 2                                  
     Polyphase Length   : 8                                  
     Filter Length      : 16                                 
     Stable             : Yes                                
     Linear Phase       : Yes (Type 2)                       
                                                             
                                                             
     
     '

filterAnalyzer(ddc.Filter)

Upconvert and Downconvert a Sine Wave Signal Using dsp.DUC and dsp.DDC

Upconvert a 1 kHz sine wave to 50 kHz using a dsp.DUC object, then downconvert it back to baseband using a dsp.DDC object.

Create a 1 kHz sine wave at a sample rate of 6 kHz.

Fs = 6e3;
sine = dsp.SineWave(Frequency=1000, ...
    SampleRate=Fs, ...
    SamplesPerFrame=1024);
x = sine();

Design a dsp.DUC object that interpolates by a factor of 20 and upconverts to 50 kHz. Upconvert the signal.

duc = designDUC(InterpolationFactors=[2 2 5], ...
    InputSampleRate=Fs, ...
    Bandwidth=2e3, ...
    StopbandAttenuation=55);
duc.CenterFrequency = 50e3;
xUp = duc(x);

Design a dsp.DDC object that decimates by a factor of 20 and downconverts from 50 kHz to baseband. Downconvert the signal.

ddc = designDDC(DecimationFactors=[5 2 2], ...
    InputSampleRate=Fs*20, ...
    Bandwidth=2e3, ...
    StopbandAttenuation=55);
ddc.CenterFrequency = 50e3;
xDown = ddc(xUp);

Visualize the spectrum at each stage.

window = hamming(floor(length(x)/10));
pwelch(x,window,[],[],Fs,"centered")
title("Spectrum of Baseband Signal")

window = hamming(floor(length(xUp)/10));
figure
pwelch(xUp,window,[],[],Fs*20,"centered")
title("Spectrum of Upconverted Signal")

window = hamming(floor(length(xDown)/10));
figure
pwelch(xDown,window,[],[],Fs,"centered")
title("Spectrum of Downconverted Signal")

Algorithms

Algorithms

The dsp.DDC object performs digital downconversion in two steps:

1. Mixing — The object multiplies the input signal by the conjugate of a complex exponential generated by the oscillator at the specified center frequency. This shifts the signal from IF to baseband.

2. Filtering — The mixed signal passes through the multirate filter cascade specified in the Filter property, which decimates the signal to a lower sample rate.

The oscillator generates a complex exponential at the specified center frequency. The mixer multiplies the input signal by the conjugate of the oscillator output to shift the signal from an intermediate frequency to baseband. The multirate filter then decimates the mixed signal to a lower sample rate. The filter cascade is specified by the Filter property and can contain CIC filters, FIR filters, Farrow rate converters, or custom filter stages.

Version History

Introduced in R2026b