dsp.DigitalDownConverter
R2026bTranslate digital signal from intermediate frequency (IF) band to baseband and decimate it
Description
The dsp.DigitalDownConverter object translates digital signal from
intermediate frequency (IF) band to baseband and decimates it.
For a more flexible interface with tunable filter stages, user-defined filter cascades,
and support for Farrow rate converters, use dsp.DDC
instead.
To digitally downconvert the input signal:
Create the
dsp.DigitalDownConverterobject and set its properties.Call the object with arguments, as if it were a function.
To learn more about how System objects work, see What Are System Objects?
This object supports C/C++ code generation and SIMD code generation under certain conditions. For more information, see Code Generation.
Creation
Description
dwnConv = dsp.DigitalDownConverterdwnConv.
dwnConv = dsp.DigitalDownConverter(PropertyName=Value)DecimationFactor to 50.
Properties
Usage
Description
Input Arguments
Output Arguments
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)
Examples
Create a digital upconverter object that up samples a 1 KHz sinusoidal signal by a factor of 20 and up converts it to 50 KHz. Create a digital downconverter object that down converts the signal to 0 Hz and down samples it by a factor of 20.
Create a sine wave generator to obtain the 1 KHz sinusoidal signal with a sample rate of 6 KHz.
Fs = 6e3; % Sample rate sine = dsp.SineWave(Frequency=1000,... SampleRate=Fs,... SamplesPerFrame=1024); x = sine(); % generate signal
Create a DigitalUpConverter object. Use minimum order filter designs and set passband ripple to 0.2 dB and the stopband attenuation to 55 dB. Set the double sided signal bandwidth to 2 KHz.
upConv = dsp.DigitalUpConverter(... InterpolationFactor=20,... SampleRate=Fs,... Bandwidth=2e3,... StopbandAttenuation=55,... PassbandRipple=0.2,... CenterFrequency=50e3);
Create a DigitalDownConverter object. Use minimum order filter designs and set the passband ripple to 0.2 dB and the stopband attenuation to 55 dB.
dwnConv = dsp.DigitalDownConverter(... DecimationFactor=20,... SampleRate=Fs*20,... Bandwidth=3e3,... StopbandAttenuation=55,... PassbandRipple=0.2,... CenterFrequency=50e3);
Create a spectrum estimator to visualize the signal spectrum before up converting, after up converting, and after down converting.
window = hamming(floor(length(x)/10)); figure; pwelch(x,window,[],[],Fs,"centered") title("Spectrum of baseband signal x")
Up convert the signal and visualize the spectrum
xUp = upConv(x); % up convert window = hamming(floor(length(xUp)/10)); figure; pwelch(xUp,window,[],[],20*Fs,"centered"); title("Spectrum of up converted signal xUp")
Down convert the signal and visualize the spectrum
xDown = dwnConv(xUp); % down convert window = hamming(floor(length(xDown)/10)); figure; pwelch(xDown,window,[],[],Fs,"centered") title("Spectrum of down converted signal xDown")
Visualize the response of the decimation filters
visualize(dwnConv)
Get decimation factors of each filter stage of the dsp.DigitalDownConverter System object™.
Create a dsp.DigitalDownConverter System object with the default settings. Using the getDecimationFactors function, obtain the decimation factors of each stage of the object.
dwnConv = dsp.DigitalDownConverter
dwnConv =
dsp.DigitalDownConverter with properties:
DecimationFactor: 100
MinimumOrderDesign: true
Bandwidth: 200000
StopbandFrequencySource: "Auto"
PassbandRipple: 0.1000
StopbandAttenuation: 60
Oscillator: 'Sine wave'
CenterFrequency: 14000000
NormalizedFrequency: false
SampleRate: 30000000
Show all properties
M = getDecimationFactors(dwnConv) %#okM = 1×3
25 2 2
The DecimationFactor property of the object is set to 100. The output M is by default a 1-by-3 vector, where each element in the vector is a factor of the overall decimation factor.
When you set the DecimationFactor to a 1-by-2 vector, the object bypasses the third filter stage and sets the decimation factor of the first and second filtering stages to the values in the first and second vector elements respectively.
dwnConv.DecimationFactor = [10 10]
dwnConv =
dsp.DigitalDownConverter with properties:
DecimationFactor: [10 10]
MinimumOrderDesign: true
Bandwidth: 200000
StopbandFrequencySource: "Auto"
PassbandRipple: 0.1000
StopbandAttenuation: 60
Oscillator: 'Sine wave'
CenterFrequency: 14000000
NormalizedFrequency: false
SampleRate: 30000000
Show all properties
M = getDecimationFactors(dwnConv)
M = 1×2
10 10
The output of the getDecimationFactors function is now a 1-by-2 vector.
More About
The following block diagram represents the DDC arithmetic with signed fixed-point inputs.
WLis the word length of the input, andFLis the fraction length of the input.The input of each filter is cast to the filter input data type. In the
dsp.DigitalDownConverterobject, you can specify the filter input data type through theFiltersInputDataTypeandCustomFiltersInputDataTypeproperties. In the Digital Down-Converter block, you can specify the filter input data type through the Stage input parameter.The oscillator output is cast to a word length equal to the input word length plus one. The fraction length is equal to the input word length minus one.
The scaling at the output of the CIC decimator consists of coarse- and fine-gain adjustments. The coarse gain is achieved using the
reinterpretcast(Fixed-Point Designer) function on the CIC decimator output. The fine gain is achieved using full-precision multiplication.
The following figure depicts the coarse-gain and fine-gain operations.
If the normalization gain is G (where 0<G≦1), then:
WLcicis the word length of the CIC decimator output andFLcicis the fraction length of the CIC decimator output.F1 = abs(nextpow2(G)), indicating the part of G achieved using bit shifts (coarse gain).F2= fraction length specified by the filter input data type.fg = fi((2^F1)*G, true, 16), which indicates that the remaining gain cannot be achieved with a bit shift (fine gain).
Algorithms
The digital downconverter downconverts the input signal by multiplying it with a complex exponential that has the specified center frequency. The algorithm downsamples the frequency downconverted signal using a cascade of three decimation filters. In this case, the filter cascade consists of a CIC decimator, a CIC compensator, and a third FIR decimation stage. The following block diagram shows the architecture of the digital downconverter.
The scaling section normalizes the CIC gain and the oscillator power. It can also contain a correction factor to achieve the desired ripple specification. When you specify an oscillator signal through the input port, the normalization factor does not include the oscillator power factor. Depending on how you set the decimation factor, the block bypasses the third filter stage. When the input data type is double or single, the algorithm implements an N-section CIC decimation filter as an FIR filter with a response that corresponds to a cascade of N boxcar filters. The algorithm emulates a CIC filter with an FIR filter so that you can run simulations with floating-point data. When the input data type is fixed-point, the algorithm implements a true CIC filter with actual comb and integrator sections.
This block diagram represents the DDC arithmetic with single or double-precision, floating-point inputs.
For details about fixed-point operation, see Fixed Point.
