dsp.HDLChannelizer

Polyphase filter bank and fast Fourier transform—optimized for HDL code generation

Description

The dsp.HDLChannelizer System object™ separates a broadband input signal into multiple narrowband output signals. It provides hardware speed and area optimization for streaming data applications. The object accepts scalar or vector input of real or complex data, provides hardware-friendly control signals, and has optional output frame control signals. You can achieve giga-sample-per-second (GSPS) throughput by using vector input. The object implements a polyphase filter, with one subfilter per input vector element. The hardware implementation interleaves the subfilters, which results in sharing each filter multiplier (FFT Length / Input Size) times. The object implements the same pipelined Radix 2^2 FFT algorithm as the dsp.HDLFFT System object.

To channelize input data:

Create the dsp.HDLChannelizer object 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?.

Creation

Syntax

channelizer = dsp.HDLChannelizer

channelizer = dsp.HDLChannelizer(Name,Value)

Description

channelizer = dsp.HDLChannelizer returns a System object, channelizer, that implements a raised-cosine filter and an 8-point FFT.

example

channelizer = dsp.HDLChannelizer(Name,Value) sets properties using one or more name-value pairs. Enclose each property name in single quotes.

Properties

expand all

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.

`NumFrequencyBands` — FFT length
`8` (default) | integer power of two

FFT length, specified as an integer power of two. For HDL code generation, the FFT length must be between 2³ and 2¹⁶, inclusive.

`FilterCoefficients` — Polyphase filter coefficients
`[-0.032 0.121 0.318 0.482 0.546 0.482 0.318 0.121 -0.032]` (default) | vector of numeric values

Polyphase filter coefficients, specified as a vector of numeric values. If the number of coefficients is not a multiple of NumFrequencyBands, the object pads this vector with zeros. The default filter specification is a raised-cosine FIR filter, rcosdesign(0.25,2,4,'sqrt'). You can specify a vector of coefficients or a call to a filter design function that returns the coefficient values. Complex coefficients are not supported. By default, the object casts the coefficients to the same data type as the input.

`ComplexMultiplication` — HDL implementation of complex multipliers
`'Use 4 multipliers and 2 adders'` (default) | `'Use 3 multipliers and 5 adders'`

HDL implementation of complex multipliers, specified as either 'Use 4 multipliers and 2 adders' or 'Use 3 multipliers and 5 adders'. Depending on your synthesis tool and target device, one option may be faster or smaller.

Dependencies

This option applies only if you use the Radix 2^2 architecture.

`OutputSize` — Size of output data
`'Same as number of frequency bands'` (default) | `'Same as input size'`

Size of output data, specified as:

'Same as number of frequency bands' — Output data is a 1-by-M vector, where M is the FFT length.
'Same as input size' — Output data is an M-by-1 vector, where M is the input vector size.

The output order is bit natural for both output sizes.

`Normalize` — FFT scaling
`true` (default) | `false`

FFT output scaling, specified as either:

true — The FFT implements an overall 1/N scale factor by scaling the result of each pipeline stage by 2. This adjustment keeps the output of the FFT in the same amplitude range as its input.
false — The FFT avoids overflow by increasing the word length by one bit at each stage.

`RoundingMethod` — Rounding mode used for internal fixed-point calculations
`'Floor'` (default) | `'Ceiling'` | `'Convergent'` | `'Nearest'` | `'Round'` | `'Zero'`

Rounding mode used for fixed-point operations. The object uses fixed-point arithmetic for internal calculations when the input is any integer or fixed-point data type. This option does not apply when the input is single or double. Each FFT stage rounds after the twiddle factor multiplication but before the butterflies. Rounding can also occur when casting the coefficients and the output of the polyphase filter to the data types you specify.

`OverflowAction` — Overflow handling for internal fixed-point calculations
`'Wrap'` (default) | `'Saturate'`

Overflow Handling used for fixed-point operations. The object uses fixed-point arithmetic for internal calculations when the input is any integer or fixed-point data type. This option does not apply when the input is single or double. This option applies to casting the coefficients and the output of the polyphase filter to the data types you specify.

The FFT algorithm avoids overflow by either scaling the output of each stage (Normalize enabled), or by increasing the word length by 1 bit at each stage (Normalize disabled).

`CoefficientsDataType` — Data type of filter coefficients
`'Same word length as input'` (default) | `numerictype` object

The object casts the polyphase filter coefficients to this data type, using the rounding and overflow settings you specify. When you select Inherit: Same word length as input (default), the object selects the binary point using fi() best-precision rules.

`FilterOutputDataType` — Data type of output of polyphase filter
`'Same word length as input'` (default) | `'Full precision'` | `numerictype` object

Data type of the output of the polyphase filter, specified as 'Same word length as input', 'Full precision', or a numerictype object. The object casts the output of the polyphase filter (the input to the FFT) to this data type, using the rounding and overflow settings you specify. When you specify 'Same word length as input', the object selects a best-precision binary point by considering the values of your filter coefficients and the range of your input data type.

By default, the FFT logic does not change the data type. When you disable Normalize, the FFT algorithm avoids overflow by increasing the word length by 1 bit at each stage.

`ResetInputPort` — Enable reset argument
`false` (default) | `true`

Enable reset input argument to the object. When reset is 1 (true), the object stops calculation and clears all internal state.

`StartOutputPort` — Enable start output argument
`false` (default) | `true`

Enable startOut output argument of the object. When enabled, the object returns an additional output signal that is 1 (true) on the first cycle of each valid output frame.

`EndOutputPort` — Enable end output argument
`false` (default) | `true`

Enable endOut output argument of the object. When enabled, the object returns an additional output signal that is 1 (true) on the first cycle of each valid output frame.

Usage

Syntax

[dataOut,validOut]
= channelizer(dataIn,validIn)

[dataOut,validOut]
= channelizer(dataIn,validIn,reset)

[dataOut,startOut,endOut,validOut]
= channelizer(___)

Description

example

[dataOut,validOut] = channelizer(dataIn,validIn) filters and computes a fast Fourier transform, and returns the frequency channels, dataOut, detected in the input signal, dataIn, when validIn is 1 (true). The validIn and validOut arguments are logical scalars that indicate the validity of the input and output signals, respectively.

[dataOut,validOut] = channelizer(dataIn,validIn,reset) returns the frequency channels, dataOut, detected in the input signal, dataIn, when validIn is 1 (true) and reset is 0 (false). When reset is 1 (true), the object stops the current calculation and clears all internal state.

To use this syntax, set the ResetInputPort property to true. For example:

channelizer = dsp.HDLChannelizer(...,'ResetInputPort',true);
...
[dataOut,validOut] = channelizer(dataIn,validIn,reset)

[dataOut,startOut,endOut,validOut] = channelizer(___) returns the frequency channels, dataOut, computed from the input arguments of any of the previous syntaxes. startOut is 1 (true) for the first sample of a frame of output data. endOut is 1 (true) for the last sample of a frame of output data.

To use this syntax, set the StartOutputPort and EndOutputPort properties to true. For example:

channelizer = dsp.HDLChannelizer(...,'StartOutputPort',true,'EndOutputPort',true);
...
[dataOut,startOut,endOut,validOut] = channelizer(dataIn,validIn)

Input Arguments

expand all

`dataIn` — Input data
scalar or column vector of real or complex values

Input data, specified as a scalar or column vector of real or complex values. The vector size must be a power of 2 between 1 and 64 that is not greater than the number of channels (FFT length).

double and single data types are supported for simulation, but not for HDL code generation.

The object does not accept uint64 data.

`validIn` — Validity of input data
`logical` scalar

Validity of input data, specified as a logical scalar. When validIn is 1 (true), the object captures the value on dataIn.

Data Types: logical

`reset` — Reset internal state
`logical` scalar

Reset internal state, specified as a logical scalar. When reset is 1 (true), the object stops the current calculation and clears internal state.

Dependencies

To enable this argument, set ResetInputPort to true.

Data Types: logical

Output Arguments

expand all

`dataOut` — Frequency channel output data
row vector

Frequency channel output data, returned as a row vector.

If you set OutputSize to 'Same as number of frequency bands' (default), the output data is a 1-by-M vector, where M is the FFT length.
If you set OutputSize to 'Same as input size', the output data is an M-by-1 vector, where M is the input vector size.

The output order is bit natural for either output size. The data type is a result of the FilterOutputDataType and the FFT bit growth necessary to avoid overflow.

`validOut` — Validity of output data
`logical` scalar

Validity of output data, returned as a logical scalar. The object sets validOut to 1 (true) with each valid sample on dataOut.

Data Types: logical

`startOut` — First valid cycle of output data
`logical` scalar

First sample of output frame, returned as a logical scalar. The object sets startOut to 1 (true) during the first valid sample on dataOut.

Dependencies

To enable this argument, set StartOutputPort to true.

Data Types: logical

`endOut` — Last valid cycle of output data
`logical` scalar

Last sample of output frame, returned as a logical scalar. The object sets endOut to 1 (true) during the last valid sample on dataOut.

Dependencies

To enable this argument, set EndOutputPort to true.

Data Types: logical

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)

expand all

Specific to dsp.HDLChannelizer

getLatency Latency of FFT or channelizer calculation

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

collapse all

Create Channelizer for HDL Generation

Open Script

Create a function that contains a channelizer object and supports HDL code generation.

Create the specifications and input signal. The signal has 8 frequency channels.

N = 8;
loopCount = 1024;
offsets = [-40 -30 -20 10 15 25 35 -15];
sinewave = dsp.SineWave('ComplexOutput',true,'Frequency', ...
     offsets+(-375:125:500),'SamplesPerFrame',loopCount);
spectrumAnalyzer = dsp.SpectrumAnalyzer('ShowLegend',true, ...
     'SampleRate',sinewave.SampleRate/N);

Write a function that creates and calls the channelizer System object™. You can generate HDL from this function.

function [yOut,validOut] = HDLChannelizer8(yIn,validIn)
%HDLChannelizer8 
% Process one sample of data using the dsp.HDLChannelizer System object
% yIn is a fixed-point scalar or column vector. 
% validIn is a logical scalar value.
% You can generate HDL code from this function.

  persistent channelize8;
  coder.extrinsic('tf');
  coder.extrinsic('dsp.Channelizer');
  
  if isempty(channelize8)
    % Use filter coeffs from non-HDL channelizer, or supply your own.  
    channelizer = coder.const(dsp.Channelizer('NumFrequencyBands',8));
    coeff = coder.const(tf(channelizer));
    channelize8 = dsp.HDLChannelizer('NumFrequencyBands',8,'FilterCoefficients',coeff);
  end    
  [yOut,validOut] = channelize8(yIn,validIn);
end

Channelize the input data by calling the object for each data sample.

y = zeros(loopCount/N,N);
validOut = false(loopCount/N,1);
yValid = zeros(loopCount/(N*N),N);
for reps=1:20
   x = fi(sum(sinewave(),2),1,18);
   for loop=1:length(x)
      [y(loop,:),validOut(loop)]= HDLChannelizer8(x(loop),true);
   end
   yValid = y(validOut == 1,:);
   spectrumAnalyzer(yValid);
end

Explore Latency of the HDL Channelizer Object

Open Live Script

The latency of the dsp.HDLChannelizer object varies with the FFT length and the vector size. Use the getLatency function to find the latency of a particular configuration. The latency is measured as the number of cycles between the first valid input and the first valid output, assuming that the input is contiguous. The number of filter coefficients does not affect the latency. Setting the output size equal to the input size reduces the latency because the samples are not saved and reordered.

Create a dsp.HDLChannelizer object and request the latency.

channelize = dsp.HDLChannelizer('NumFrequencyBands',512);
L512 = getLatency(channelize)

L512 = 1118

Request hypothetical latency information about a similar object with a different number of frequency bands (FFT length). The properties of the original object do not change.

L256 = getLatency(channelize,256)

L256 = 592

N = channelize.NumFrequencyBands

N = 512

Request hypothetical latency information of a similar object that accepts eight-sample vector input.

L256v8 = getLatency(channelize,256,8)

L256v8 = 132

Enable scaling at each stage of the FFT. The latency does not change.

channelize.Normalize = true;
L512n = getLatency(channelize)

L512n = 1118

Request the same output size and order as the input data. The latency decreases because the object does not need to store and reorder the data before output. The default input size is scalar.

channelize.OutputSize = 'Same as input size';
L512r = getLatency(channelize)

L512r = 1084

Check the latency of a vector input implementation where the input and output are the same size. Specify the current value of the FFT length and a vector size of 8 samples. The latency decreases because the object computes results in parallel when the input is a vector.

L256rv8 = getLatency(channelize,channelize.NumFrequencyBands,8)

L256rv8 = 218

Algorithms

expand all

This object implements the algorithm described on the Channelizer HDL Optimized block reference page.

Latency

The latency varies with the FFT length and the vector size. Use the getLatency function to find the latency of a particular configuration. The latency is the number of cycles between the first valid input and the first valid output, assuming that the input is contiguous. The filter coefficients do not affect the latency. Setting the output size equal to the input size reduces the latency, because the samples are not saved and reordered.

Control Signals

This diagram shows validIn and validOut signals for contiguous input data with a vector size of 16 and an FFT length of 512.

The diagram also shows the optional startOut and endOut signals that indicate frame boundaries. When enabled, startOut pulses for one cycle with the first validOut of the frame, and endOut pulses for one cycle with the last validOut of the frame.

If you apply continuous input frames (no gap in validIn between frames), the output will also be continuous, after the initial latency.

The validIn signal can be noncontiguous. Data accompanied by a validIn signal is stored until a frame is filled. Then the data is output in a contiguous frame of N (FFT length) cycles. This diagram shows noncontiguous input and contiguous output for an FFT length of 512 and a vector size of 16 samples.

Performance

These resource and performance data are the place-and-route results from the generated HDL targeted to a Xilinx^® Virtex^® 6 (XC6VLX240-1ff784) FPGA. The three examples in the tables use this configuration:

FFT length (default) — 8
Filter length — 96 coefficients
16-bit complex input data
Coefficient and filter output data types (default) — Same as number of frequency bands
Complex multiplication (default) — 4 multipliers, 2 adders
Output scaling — Enabled
Minimize clock enables (HDL Coder™ parameter)

Performance of the synthesized HDL code varies with your target and synthesis options.

For scalar input, the design achieves a clock frequency of 346 MHz. The latency is 53 cycles. The subfilters share each multiplier eight (N) times. The design uses these resources.

Resource	Number Used
LUT	1591
FFS	2681
Xilinx LogiCORE^® DSP48	16

For four-sample vector input, the design achieves a clock frequency of 333 MHz. The latency is 31 cycles. The subfilters share each multiplier twice (N/M). The design uses these resources.

Resource	Number Used
LUT	1912
FFS	3986
Xilinx LogiCORE DSP48	56

For eight-sample vector input, the design achieves a clock frequency of 292 MHz. The latency is 20 cycles. When the input size is the same as the FFT length, the subfilters do not share any multipliers. The design uses these resources.

Resource	Number Used
LUT	1388
FFS	2302
Xilinx LogiCORE DSP48	110

Documentation

dsp.HDLChannelizer

Description

Creation

Syntax

Description

Properties

NumFrequencyBands — FFT length 8 (default) | integer power of two

FilterCoefficients — Polyphase filter coefficients [-0.032 0.121 0.318 0.482 0.546 0.482 0.318 0.121 -0.032] (default) | vector of numeric values

ComplexMultiplication — HDL implementation of complex multipliers 'Use 4 multipliers and 2 adders' (default) | 'Use 3 multipliers and 5 adders'

Dependencies

OutputSize — Size of output data 'Same as number of frequency bands' (default) | 'Same as input size'

Normalize — FFT scaling true (default) | false

RoundingMethod — Rounding mode used for internal fixed-point calculations 'Floor' (default) | 'Ceiling' | 'Convergent' | 'Nearest' | 'Round' | 'Zero'

OverflowAction — Overflow handling for internal fixed-point calculations 'Wrap' (default) | 'Saturate'

CoefficientsDataType — Data type of filter coefficients 'Same word length as input' (default) | numerictype object

FilterOutputDataType — Data type of output of polyphase filter 'Same word length as input' (default) | 'Full precision' | numerictype object

ResetInputPort — Enable reset argument false (default) | true

StartOutputPort — Enable start output argument false (default) | true

EndOutputPort — Enable end output argument false (default) | true

Usage

Syntax

Description

Input Arguments

dataIn — Input data scalar or column vector of real or complex values

validIn — Validity of input data logical scalar

reset — Reset internal state logical scalar

Dependencies

Output Arguments

dataOut — Frequency channel output data row vector

validOut — Validity of output data logical scalar

startOut — First valid cycle of output data logical scalar

Dependencies

endOut — Last valid cycle of output data logical scalar

Dependencies

Object Functions

Specific to dsp.HDLChannelizer

Common to All System Objects

Examples

Create Channelizer for HDL Generation

Explore Latency of the HDL Channelizer Object

Algorithms

Latency

Control Signals

Performance

See Also

Blocks

Objects

DSP System Toolbox Documentation

Support

`NumFrequencyBands` — FFT length
`8` (default) | integer power of two

`FilterCoefficients` — Polyphase filter coefficients
`[-0.032 0.121 0.318 0.482 0.546 0.482 0.318 0.121 -0.032]` (default) | vector of numeric values

`ComplexMultiplication` — HDL implementation of complex multipliers
`'Use 4 multipliers and 2 adders'` (default) | `'Use 3 multipliers and 5 adders'`

`OutputSize` — Size of output data
`'Same as number of frequency bands'` (default) | `'Same as input size'`

`Normalize` — FFT scaling
`true` (default) | `false`

`RoundingMethod` — Rounding mode used for internal fixed-point calculations
`'Floor'` (default) | `'Ceiling'` | `'Convergent'` | `'Nearest'` | `'Round'` | `'Zero'`

`OverflowAction` — Overflow handling for internal fixed-point calculations
`'Wrap'` (default) | `'Saturate'`

`CoefficientsDataType` — Data type of filter coefficients
`'Same word length as input'` (default) | `numerictype` object

`FilterOutputDataType` — Data type of output of polyphase filter
`'Same word length as input'` (default) | `'Full precision'` | `numerictype` object

`ResetInputPort` — Enable reset argument
`false` (default) | `true`

`StartOutputPort` — Enable start output argument
`false` (default) | `true`

`EndOutputPort` — Enable end output argument
`false` (default) | `true`

`dataIn` — Input data
scalar or column vector of real or complex values

`validIn` — Validity of input data
`logical` scalar

`reset` — Reset internal state
`logical` scalar

`dataOut` — Frequency channel output data
row vector

`validOut` — Validity of output data
`logical` scalar

`startOut` — First valid cycle of output data
`logical` scalar

`endOut` — Last valid cycle of output data
`logical` scalar